name string | code string | asm string | file string |
|---|---|---|---|
Catch::SectionStats::SectionStats(Catch::SectionInfo const&, Catch::Counts const&, double, bool) | SectionStats::SectionStats( SectionInfo const& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( _sectionInfo ),
assertions( _assertions ),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x71564(%rip), %rax # 0x8db50
movq %rax, (%rdi)
leaq 0x8(%rdi), %r13
leaq 0x18(%rdi), %rbp
movq %rbp, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TestCaseStats::TestCaseStats(Catch::TestCaseInfo const&, Catch::Totals const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
std::string const& _stdOut,
std::string const& _stdErr,
bool _aborting )
: testInfo( _testI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
leaq 0x7146f(%rip), %rax # 0x8db70
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0x37a0c
movq 0x30(%r12), %rax
movq %rax, 0xe0(%r14)
movups (%r12), ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TestGroupStats::TestGroupStats(Catch::GroupInfo const&) | TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
: groupInfo( _groupInfo ),
aborting( false )
{} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x71267(%rip), %rax # 0x8db90
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
callq 0x434f2
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x28(%r14)
movl $0x0, 0x38(%r14... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TestGroupStats::~TestGroupStats() | TestGroupStats::~TestGroupStats() = default; | movq %rdi, %rax
leaq 0x7120e(%rip), %rcx # 0x8db90
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x1c99d
movq (%rax), %rsi
incq %rsi
jmp 0x125d0
retq
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::listTests(Catch::Config const&) | std::size_t listTests( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Matching test cases:\n";
else {
Catch::cout() << "All available test cases:\n";
}
auto matchedTestCases = filterT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, 0x30(%rsp)
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x7547c(%rip), %rdi # 0x91fa8
testb %al, %al
je 0x1cb3e
leaq 0x4955d(%rip), %rsi #... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TestCaseInfo::tagsAsString[abi:cxx11]() const | std::string TestCaseInfo::tagsAsString() const {
std::string ret;
// '[' and ']' per tag
std::size_t full_size = 2 * tags.size();
for (const auto& tag : tags) {
full_size += tag.size();
}
ret.reserve(full_size);
for (const auto& tag : tags) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x60(%rsi), %rax
movq 0x68(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
cmpq %rax, %rcx
je 0x1d1c5
addq 0x8(%rax), %rsi
addq $0x20... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::listTags(Catch::Config const&) | std::size_t listTags( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Tags for matching test cases:\n";
else {
Catch::cout() << "All available tags:\n";
}
std::map<std::string, TagInfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x74aa4(%rip), %rdi # 0x91fa8
testb %al, %al
je 0x1d516
leaq 0x48bdd(%rip), %rsi ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::toLower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string toLower( std::string const& s ) {
std::string lc = s;
toLowerInPlace( lc );
return lc;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x434f2
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1db9f
movq (%rbx), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0x12860
... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::list(std::shared_ptr<Catch::Config> const&) | Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
Option<std::size_t> listedCount;
getCurrentMutableContext().setConfig( config );
if( config->listTests() )
listedCount = listedCount.valueOr(0) + listTests( *config );
if( config->listTestNamesOnly() )
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
movq 0x74b82(%rip), %rdi # 0x92a40
testq %rdi, %rdi
jne 0x1def7
movl $0x30, %edi
callq 0x125a0
movq %rax, %rdi
leaq 0x6fb59(%rip), %rax # 0x8da30
movq %rax, (%rdi)
leaq 0x6fb9f(%rip), %rax # 0x8da80
movq %rax... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
non-virtual thunk to Catch::Matchers::Floating::WithinUlpsMatcher::match(double const&) const | bool WithinUlpsMatcher::match(double const& matchee) const {
switch (m_type) {
case FloatingPointKind::Float:
return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
case FloatingPointKind::Double:
return almostEqualUlps<double>(m... | addq $-0x28, %rdi
jmp 0x1e6bc
nop
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Matchers::Floating::WithinRelMatcher::WithinRelMatcher(double, double) | WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
m_target(target),
m_epsilon(epsilon){
CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense.");
CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x6f11b(%rip), %rax # 0x8dc88
movq %rax, (%rdi)
leaq 0x6f141(%rip), %rax # 0x8dcb8
movq %rax, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movsd %xmm1, 0x38(%rdi)
x... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Matchers::StdString::CasedString::adjustString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string CasedString::adjustString( std::string const& str ) const {
return m_caseSensitivity == CaseSensitive::No
? toLower( str )
: str;
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x1effc
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1db56
jmp 0x1f015
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x434f2
movq %rbx, %rax
popq %rbx
retq
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Matchers::StdString::StartsWithMatcher::StartsWithMatcher(Catch::Matchers::StdString::CasedString const&) | StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x46dbb(%rip), %rsi # 0x6630b
leaq 0x46dbf(%rip), %rdx # 0x66316
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3be4c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Matchers::StdString::RegexMatcher::describe[abi:cxx11]() const | std::string RegexMatcher::describe() const {
return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x2911e
leaq 0x469f0(%rip), %rcx # 0x66321
movl $0x8, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x12680
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Capturer::Capturer(Catch::StringRef, Catch::SourceLineInfo const&, Catch::ResultWas::OfType, Catch::StringRef) | Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
auto trimmed = [&] (size_t start, size_t end) {
while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
++start;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, 0x30(%rsp)
movq %rdi, %rbp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movl %r8d, 0x4(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x13e16
movq %rax, 0x18(%rbp)
movq $0x0, 0x20(%rbp)
leaq 0x50(%rsp... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::RedirectedStreams::~RedirectedStreams() | RedirectedStreams::~RedirectedStreams() {
m_redirectedCout += m_redirectedStdOut.str();
m_redirectedCerr += m_redirectedStdErr.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
addq $0x8, %rsi
movq %rsp, %rdi
callq 0x12910
movq (%rbx), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x12180
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x206c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x125... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::cleanupSingletons() | static auto getSingletons() -> std::vector<ISingleton*>*& {
static std::vector<ISingleton*>* g_singletons = nullptr;
if( !g_singletons )
g_singletons = new std::vector<ISingleton*>();
return g_singletons;
} | pushq %r15
pushq %r14
pushq %rbx
movq 0x72662(%rip), %rbx # 0x92e88
testq %rbx, %rbx
je 0x20830
movq (%rbx), %r14
jmp 0x20855
movl $0x18, %edi
callq 0x125a0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x72636(%rip) # 0x92e88
xorl %r14d, %r14d
movq 0x8(%rbx), %r15
cmp... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::(anonymous namespace)::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
if( startsWith( tag, '.' ) ||
tag == "!hide" )
return TestCaseInfo::IsHidden;
else if( tag == "!throws" )
return TestCaseInfo::Throws;
else if( tag == "!shouldf... | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x263b8
movq (%rbx), %rcx
movl $0x2, %eax
cmpb $0x2e, (%rcx)
je 0x26455
leaq 0x403f3(%rip), %rsi # 0x667b2
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x26434
leaq 0x4194e(%rip), %rsi # 0x67d20
movq %rbx, %rdi
callq 0x12160
testl %eax, %eax
je 0x2643b
lea... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::AutoReg::AutoReg(Catch::ITestInvoker*, Catch::SourceLineInfo const&, Catch::StringRef const&, Catch::NameAndTags const&) | AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
CATCH_TRY {
getMutableRegistryHub()
.registerTest(
makeTestCase(
invoker,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
leaq 0x667eb(%rip), %rax # 0x8e2e0
movq %rax, (%rdi)
callq 0x35726
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x271bd
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TestSpec::Pattern::~Pattern() | TestSpec::Pattern::~Pattern() = default; | movq %rdi, %rax
leaq 0x6667e(%rip), %rcx # 0x8e300
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x27c9d
movq (%rax), %rsi
incq %rsi
jmp 0x125d0
retq
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TestSpec::Filter::name[abi:cxx11]() const | std::string TestSpec::Filter::name() const {
std::string name;
for( auto const& p : m_patterns )
name += p->name();
return name;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r12
cmpq %r12, %r14
je 0x281e7
movq (%r14), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x12180
addq $0x1... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TestSpecParser::processNameChar(char) | void TestSpecParser::processNameChar( char c ) {
if( c == '[' ) {
if( m_substring == "exclude:" )
m_exclusion = true;
else
endMode();
startNewMode( Tag );
}
} | cmpb $0x5b, %sil
jne 0x2874b
pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
leaq 0x3e22d(%rip), %rsi # 0x6695a
callq 0x12160
testl %eax, %eax
je 0x28740
movq %rbx, %rdi
callq 0x285a8
jmp 0x28744
movb $0x1, 0x8(%rbx)
movl $0x3, (%rbx)
popq %rbx
retq
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::StringMaker<std::basic_string_view<char, std::char_traits<char>>, void>::convert[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) | std::string StringMaker<std::string_view>::convert(std::string_view str) {
return ::Catch::Detail::stringify(std::string{ str });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3be4c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2911e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x29331
movq 0x10(%rsp), ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::StringMaker<long long, void>::convert[abi:cxx11](long long) | std::string StringMaker<long long>::convert(long long value) {
ReusableStringStream rss;
rss << value;
if (value > Detail::hexThreshold) {
rss << " (0x" << std::hex << value << ')';
}
return rss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x648e8(%rip), %rax # 0x8e0b8
movq %rax, 0x8(%rsp)
callq 0x54b14
leaq 0x8(%rax), %rdi
callq 0x38840
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0x54b14
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x18(%rsp)
movq %r14... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::StringMaker<signed char, void>::convert[abi:cxx11](signed char) | std::string StringMaker<signed char>::convert(signed char value) {
if (value == '\r') {
return "'\\r'";
} else if (value == '\f') {
return "'\\f'";
} else if (value == '\n') {
return "'\\n'";
} else if (value == '\t') {
return "'\\t'";
} else if ('\0' <= value && valu... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal -0x9(%rsi), %eax
cmpl $0x4, %eax
ja 0x29a5a
leaq 0x3a7e8(%rip), %rcx # 0x641cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3cf9f(%rip), %rsi # 0x6699a
leaq 0x3cf9c(%rip), %rdx # 0x6699e
jmp 0x29a47... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::(anonymous namespace)::hexEscapeChar(std::ostream&, unsigned char) | void hexEscapeChar(std::ostream& os, unsigned char c) {
std::ios_base::fmtflags f(os.flags());
os << "\\x"
<< std::uppercase << std::hex << std::setfill('0') << std::setw(2)
<< static_cast<int>(c);
os.flags(f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r15d
leaq 0x3dc0c(%rip), %rsi # 0x67dad
movl $0x2, %edx
callq 0x126a0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000
movq -0x18... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting) | XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
if( !text.empty() ){
bool tagWasOpen = m_tagIsOpen;
ensureTagClosed();
if (tagWasOpen && shouldIndent(fmt)) {
m_os << m_indent;
}
m_os << XmlEncode( text );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x2a498
movl %edx, %ebp
movq %rsi, %r14
movb (%rbx), %r15b
movq %rbx, %rdi
callq 0x2a696
testb $0x1, %bpl
je 0x2a43e
testb %r15b, %r15b
je 0x2a43e
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::XmlWriter::writeComment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting) | XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
ensureTagClosed();
if (shouldIndent(fmt)) {
m_os << m_indent;
}
m_os << "<!--" << text << "-->";
applyFormatting(fmt);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x2a696
testb $0x1, %bl
je 0x2a8c9
movq 0x40(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
callq 0x126a0
movq 0x40(%r14), %r12
leaq 0x3c0ff(%rip), %rsi # 0x669d3
movl $0x4, %edx
movq %r12, %rdi
cal... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::CompactReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void CompactReporter::noMatchingTestCases( std::string const& spec ) {
stream << "No test cases matched '" << spec << '\'' << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x3be70(%rip), %rsi # 0x66a6a
movl $0x17, %edx
movq %r14, %rdi
callq 0x126a0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x126a0
leaq 0x7(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x126a0
movq %ra... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::CompactReporter::sectionEnded(Catch::SectionStats const&) | void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
double dur = _sectionStats.durationInSeconds;
if ( shouldShowDuration( *m_config, dur ) ) {
stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << std::endl;
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x70(%rsi), %xmm0
movq 0x8(%rdi), %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2aa42
testb %al, %al
je 0x2b551
movq 0x18(%r14), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2a9c5
movq (%r15), %rsi
movq 0x8(%r15),... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ConsoleReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
stream << "No test cases matched '" << spec << '\'' << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x3a5e2(%rip), %rsi # 0x66a6a
movl $0x17, %edx
movq %r14, %rdi
callq 0x126a0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x126a0
leaq 0x7(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x126a0
movq %ra... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&) | bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
AssertionResult const& result = _assertionStats.assertionResult;
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
// Drop out if result was successful but we're not printing them.
if (!includeRes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x2c597
movl 0x90(%r12), %eax
testb $0x10, %al
je 0x2c58c
movl 0x38(%r12), %ecx
andl $0x8, %ecx
je 0x2c597
xorl %... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
std::size_t i = _string.find(": ");
if (i != std::string::npos)
i += 2;
else
i = 0;
stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x37dd7(%rip), %rsi # 0x666dc
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x12a00
leaq 0x2(%rax), %r13
cmpq $-0x1, %rax
cmoveq %r12, %r13
movq 0x18(%r15), %r15
lea... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::JunitReporter::JunitReporter(Catch::ReporterConfig const&) | JunitReporter::JunitReporter( ReporterConfig const& _config )
: CumulativeReporterBase( _config ),
xml( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x39d20
leaq 0x5f8b4(%rip), %rax # 0x8e508
movq %rax, (%rbx)
leaq 0xd8(%rbx), %rdi
movq (%r14), %rsi
callq 0x2a4ca
xorl %eax, %eax
movq %rax, 0x120(%rbx)
leaq 0x138(%rbx), %rcx
movq %rcx, 0x128(%rbx)
movq %rax, 0x130(%rbx)
movb %al, 0x138(%rbx)
... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::(anonymous namespace)::formatDuration[abi:cxx11](double) | std::string formatDuration( double seconds ) {
ReusableStringStream rss;
rss << std::fixed << std::setprecision( 3 ) << seconds;
return rss.str();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x5e7ee(%rip), %rax # 0x8e0b8
movq %rax, 0x10(%rsp)
callq 0x54b14
leaq 0x8(%rax), %rdi
callq 0x38840
movq %rax, %r14
movq %rax, 0x18(%rsp)
callq 0x54b14
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x20(%rsp)
movq (%r14),... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ListeningReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
for ( auto const& listener : m_listeners ) {
listener->noMatchingTestCases( spec );
}
m_reporter->noMatchingTestCases( spec );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x30bd1
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x8, %r15
jmp 0x30bba
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
mov... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ListeningReporter::assertionStarting(Catch::AssertionInfo const&) | void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
for ( auto const& listener : m_listeners ) {
listener->assertionStarting( assertionInfo );
}
m_reporter->assertionStarting( assertionInfo );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x30d81
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x48(%rax)
addq $0x8, %r15
jmp 0x30d6a
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
mov... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::XmlReporter::XmlReporter(Catch::ReporterConfig const&) | XmlReporter::XmlReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config ),
m_xml(_config.stream())
{
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3a734
leaq 0x5d6ea(%rip), %rax # 0x8e650
movq %rax, (%rbx)
movq $0x0, 0x168(%rbx)
leaq 0x170(%rbx), %rdi
movq (%r14), %rsi
callq 0x2a4ca
movl $0x0, 0x1b8(%rbx)
movw $0x101, 0x160(%rbx) # imm = 0x101
addq $0x8, %rsp
popq %rbx
popq %r14
retq... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::XmlReporter::testGroupStarting(Catch::GroupInfo const&) | void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
StreamingReporterBase::testGroupStarting( groupInfo );
m_xml.startElement( "Group" )
.writeAttribute( "name", groupInfo.name );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x50, %rdi
callq 0x42ef8
leaq 0x58(%r14), %r15
leaq 0x68(%r14), %rax
movq %rax, 0x58(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x434f2
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x78(%... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::use(Catch::Colour::Code) | void use( Colour::Code _colourCode ) override {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32... | pushq %rbx
subq $0x50, %rsp
cmpl $0x17, %esi
ja 0x32fab
movl %esi, %eax
leaq 0x31345(%rip), %rcx # 0x64200
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3479c(%rip), %rdi # 0x67667
jmp 0x32f2e
leaq 0x347d6(%rip), %rdi # 0x676aa
jmp 0x32f2e
leaq 0x347b8(%rip), %rdi # 0x67695
jmp 0x32f2e
le... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x12300
xorl %eax, %eax
leaq 0x48(%rsp), %r12
movq %rax, -0x18(%r12)
leaq 0x5... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
non-virtual thunk to Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq -0x8(%rdi), %rbx
leaq 0x5a2ec(%rip), %rax # 0x8fe78
movq %rax, -0x8(%rdi)
leaq 0x5a361(%rip), %rax # 0x8fef8
movq %rax, (%rdi)
leaq 0x5a3af(%rip), %rax # 0x8ff50
movq %rax, 0x8(%rdi)
leaq 0x58eb4(%rip), %rax # 0x8ea60
movq %rax, 0x120(%rdi)
addq $0x1... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
non-virtual thunk to Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq -0x148(%rdi), %rbx
leaq 0x59fa1(%rip), %rax # 0x8fe78
movq %rax, -0x148(%rdi)
leaq 0x5a013(%rip), %rax # 0x8fef8
movq %rax, -0x140(%rdi)
leaq 0x5a05d(%rip), %rax # 0x8ff50
movq %rax, -0x138(%rdi)
leaq 0x58b5f(%rip), %rax # 0x8ea60
movq %rax, -0x20(%r... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Matchers::Exception::ExceptionMessageMatcher::ExceptionMessageMatcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ExceptionMessageMatcher(std::string const& message):
m_message(message)
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x5681b(%rip), %rax # 0x8e740
movq %rax, (%rdi)
leaq 0x56841(%rip), %rax # 0x8e770
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Option<Catch::AssertionResult>::operator=(Catch::AssertionResult const&) | Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x53b90
movq 0x30(%r14), %rax
movq %rax, 0x38(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x28(%rbx)
movups %xmm1, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
leaq 0x40(%rbx), %r15
leaq 0x5... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::StringStreams::release(unsigned long) | void release( std::size_t index ) {
m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
m_unused.push_back(index);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rsp)
movq (%rdi), %rax
movq (%rax,%rsi,8), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movq 0x30(%rbx), %rax
leaq 0x30(%rbx), %rsi
addq -0x18(%rax), %rsi
callq 0x12270
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x38918
movq %r14, (%rsi)... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::TablePrinter::close() | void close() {
if (m_isOpen) {
*this << RowBreak();
m_os << std::endl;
m_isOpen = false;
}
} | cmpb $0x1, 0x19c(%rdi)
jne 0x3995a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x198(%rdi)
jle 0x39922
movq (%rbx), %rdi
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
callq 0x126a0
movl $0xffffffff, 0x198(%rbx) # imm = 0xFFFFFFFF
movq (%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::ReporterRegistrar<Catch::ConsoleReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x35726
movq %rax, %r14
leaq 0x8(%rax), %r15
movl $0x18, %edi
callq 0x125a0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x5760d(%rip), %rcx # 0x912d0
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x5764f(%rip), ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::BasicResult<void>::~BasicResult() | explicit BasicResult( BasicResult<U> const &other )
: ResultValueBase<T>( other.type() ),
m_errorMessage( other.errorMessage() )
{
assert( type() != ResultBase::Ok );
} | movq %rdi, %rax
leaq 0x540dc(%rip), %rcx # 0x901c0
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x3c0ff
movq (%rax), %rsi
incq %rsi
jmp 0x125d0
retq
| /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::Opt::Opt<Catch::clara::detail::Help::Help(bool&)::'lambda'(bool)>(Catch::clara::detail::Help::Help(bool&)::'lambda'(bool) const&) | explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x125a0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x53e40(%rip), %rcx # 0x904d8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x53e82(%rip), %rdx # 0x90528
movq %rdx, 0x10(%rax)
movq ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseState>::BasicResult<void>(Catch::clara::detail::BasicResult<void> const&) | explicit BasicResult( BasicResult<U> const &other )
: ResultValueBase<T>( other.type() ),
m_errorMessage( other.errorMessage() )
{
assert( type() != ResultBase::Ok );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
leaq 0x53112(%rip), %rax # 0x90228
movq %rax, (%rdi)
addq $0x40, %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x434f2
cmpl $0x0, 0x8(%rbx)
... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Arg>::ParserRefImpl<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::vector<std::__cxx11::basic_string<char, std::cha... | ParserRefImpl( T &ref, std::string const &hint )
: m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint )
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x529e7(%rip), %rax # 0x906e8
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movl $0x20, %edi
callq 0x125a0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x529f6(%rip), %rcx # 0x90720
movq %rcx, (%rax)
... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::ResultValueBase<Catch::clara::detail::ParseState>::operator=(Catch::clara::detail::ResultValueBase<Catch::clara::detail::ParseState> const&) | auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
if( m_type == ResultBase::Ok )
m_value.~T();
ResultBase::operator=(other);
if( m_type == ResultBase::Ok )
new( &m_value ) T( other.m_value );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jne 0x3ecad
leaq 0x28(%rbx), %rdi
callq 0x3c42c
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
testl %eax, %eax
jne 0x3ecd8
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
leaq 0x28(%rbx), %rdi... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::TextFlow::Columns::iterator::iterator(Catch::clara::TextFlow::Columns const&, Catch::clara::TextFlow::Columns::iterator::EndTag) | iterator(Columns const& columns, EndTag)
: m_columns(columns.m_columns),
m_activeIterators(0) {
m_iterators.reserve(m_columns.size());
for (auto const& col : m_columns)
m_iterators.push_back(col.end());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
leaq 0x8(%rdi), %r14
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAA... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::Parser::getHelpColumns() const | auto getHelpColumns() const -> std::vector<HelpColumns> {
std::vector<HelpColumns> cols;
for (auto const &o : m_options) {
auto childCols = o.getHelpColumns();
cols.insert( cols.end(), childCols.begin(), childCols.end() );
}
return cols;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %r12
cmpq %r12, %r14
je 0x40825
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x40966
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::Option<Catch::TestCaseInfo>::reset() | void reset() {
if( nullableValue )
nullableValue->~T();
nullableValue = nullptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x42ee8
leaq 0x78(%r14), %rdi
callq 0x389a4
leaq 0x60(%r14), %rdi
callq 0x389a4
movq 0x40(%r14), %rdi
leaq 0x50(%r14), %rax
cmpq %rax, %rdi
je 0x42eb9
movq (%rax), %rsi
incq %rsi
callq 0x125d0
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::convertInto<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int&) | inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
std::stringstream ss;
ss << source;
ss >> target;
if( ss.fail() )
return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
else
return P... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x12410
leaq 0x58(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x126a0
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x12a20
movq 0x48(%rsp), %rax
movq -0x18(... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
Catch::StreamingReporterBase<Catch::CompactReporter>::StreamingReporterBase(Catch::ReporterConfig const&) | StreamingReporterBase( ReporterConfig const& _config )
: m_config( _config.fullConfig() ),
stream( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = false;
if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
CATCH_ERRO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x37632(%rip), %rax # 0x90860
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x5925b
movq 0x38d53(%rip), %rcx # 0x91fa0
cmpb $0x0, ... | /JamesBoer[P]Scs/Tests/UnitTests/catch.hpp |
bin_mdef_read_text | bin_mdef_t *
bin_mdef_read_text(ps_config_t *config, const char *filename)
{
bin_mdef_t *bmdef;
mdef_t *mdef;
int i, nodes, ci_idx, lc_idx, rc_idx;
int nchars;
(void)config;
if ((mdef = mdef_init((char *) filename, TRUE)) == NULL)
return NULL;
/* Enforce some limits. */
if (m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdi
movl $0x1, %esi
callq 0x59dc
testq %rax, %rax
je 0x3a5b
movq %rax, %rbx
movl 0x10(%rax), %r8d
cmpl $0x10000, %r8d # imm = 0x10000
jl 0x35e1
leaq 0xbb70(%rip), %rsi # 0xf140
leaq 0xbbc3(%rip), %rcx # 0xf19a
xo... | /cmusphinx[P]pocketsphinx/src/bin_mdef.c |
bin_mdef_read | bin_mdef_t *
bin_mdef_read(ps_config_t *config, const char *filename)
{
bin_mdef_t *m;
FILE *fh;
size_t tree_start;
int32 val, i, do_mmap, swap;
long pos, end;
int32 *sseq_size;
/* Try to read it as text first. */
if ((m = bin_mdef_read_text(config, filename)) != NULL)
return m;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %rbp
callq 0x3598
movq %rax, %rbx
testq %rax, %rax
jne 0x3c90
leaq 0xb606(%rip), %rsi # 0xf140
leaq 0xb73a(%rip), %rcx # 0xf27b
xorl %ebx, %ebx
movl $0x150, %edx # imm = 0x150
movl $0x1, %e... | /cmusphinx[P]pocketsphinx/src/bin_mdef.c |
bin_mdef_ciphone_id_nocase | int
bin_mdef_ciphone_id_nocase(bin_mdef_t * m, const char *ciphone)
{
int low, mid, high;
/* Exact binary search on m->ciphone */
low = 0;
high = m->n_ciphone;
while (low < high) {
int c;
mid = (low + high) / 2;
c = strcmp_nocase(ciphone, m->ciname[mid]);
if (c == 0... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %r12d
xorl %r13d, %r13d
cmpl %r12d, %r13d
jge 0x5242
leal (%r12,%r13), %r15d
shrl %r15d
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xbd1e
leal 0x1(%r15), %ecx
testl %eax, %eax
jg 0x523b
movl ... | /cmusphinx[P]pocketsphinx/src/bin_mdef.c |
bin_mdef_phone_id_nearest | int
bin_mdef_phone_id_nearest(bin_mdef_t * m, int32 b, int32 l, int32 r, int32 pos)
{
int p, tmppos;
/* In the future, we might back off when context is not available,
* but for now we'll just return the CI phone. */
if (l < 0 || r < 0)
return b;
p = bin_mdef_phone_id(m, b, l, r, pos);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %ecx, %eax
orl %edx, %eax
js 0x5458
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
movl %ebx, %esi
callq 0x52ab
testl %eax, %eax
js 0x5469
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %... | /cmusphinx[P]pocketsphinx/src/bin_mdef.c |
mdef_phone_str | int
mdef_phone_str(mdef_t * m, int pid, char *buf)
{
char *wpos_name;
assert(m);
assert((pid >= 0) && (pid < m->n_phone));
wpos_name = WPOS_NAME;
buf[0] = '\0';
if (pid < m->n_ciphone)
sprintf(buf, "%s", mdef_ciphone_str(m, pid));
else {
sprintf(buf, "%s %s %s %c",
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5792
testl %esi, %esi
js 0x5773
movq %rdi, %r14
cmpl %esi, 0x4(%rdi)
jle 0x5773
movq %rdx, %rbx
movb $0x0, (%rdx)
cmpl %esi, (%r14)
jle 0x56f2
movq %r14, %rdi
callq 0x5650
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3080
jmp 0x5767
movq 0x28(%r14)... | /cmusphinx[P]pocketsphinx/src/mdef.c |
mdef_phone_id | int
mdef_phone_id(mdef_t * m,
int ci, int lc, int rc, word_posn_t wpos)
{
ph_lc_t *lcptr;
ph_rc_t *rcptr;
int newl, newr;
assert(m);
assert((ci >= 0) && (ci < m->n_ciphone));
assert((lc >= 0) && (lc < m->n_ciphone));
assert((rc >= 0) && (rc < m->n_ciphone));
assert((wpos >... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5905
testl %esi, %esi
js 0x58e6
movl (%rdi), %r9d
cmpl %esi, %r9d
jle 0x58e6
movl %r8d, %r10d
movl %esi, %esi
testl %edx, %edx
js 0x5889
cmpl %edx, %r9d
jle 0x5889
movl %ecx, %r11d
testl %ecx, %ecx
js 0x58a8
cmpl %r11d, %r9d
jle 0x58a8
cmpl $0x4, %r8d
jae 0x58c7
mo... | /cmusphinx[P]pocketsphinx/src/mdef.c |
parse_tmat_senmap | static void
parse_tmat_senmap(mdef_t * m, char *line, long off, int p)
{
int32 wlen, n, s;
char *lp;
__BIGSTACKVARIABLE__ char word[1024];
lp = line + off;
/* Read transition matrix id */
if ((sscanf(lp, "%d%n", &n, &wlen) != 1) || (n < 0))
E_FATAL("Missing or bad transition matrix id:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq %rsi, %r14
leaq 0x94bb(%rip), %rsi # 0x101b0
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x3220
cmpl ... | /cmusphinx[P]pocketsphinx/src/mdef.c |
ps_config_str | char const *
ps_config_str(cmd_ln_t *config, char const *name)
{
cmd_ln_val_t *val;
val = cmd_ln_access_r(config, name);
if (val == NULL)
return NULL;
if (!(val->type & ARG_STRING)) {
E_ERROR("Argument %s does not have string type\n", name);
return NULL;
}
return (char co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xbe04
testq %rax, %rax
je 0x7738
testb $0x8, 0x8(%rax)
jne 0x773d
leaq 0x8d90(%rip), %rsi # 0x104a8
leaq 0x901a(%rip), %rcx # 0x10739
xorl %r14d, %r14d
movl $0x25d, %edx # imm = 0x25D
movl $0x3, %edi
movq %rbx, %r8
xorl %eax, %eax
callq 0xd7c7... | /cmusphinx[P]pocketsphinx/src/ps_config.c |
json_error | void
json_error(int err)
{
const char *errstr;
switch (err) {
case JSMN_ERROR_INVAL:
errstr = "JSMN_ERROR_INVAL - bad token, JSON string is corrupted";
break;
case JSMN_ERROR_NOMEM:
errstr = "JSMN_ERROR_NOMEM - not enough tokens, JSON string is too large";
break;
case... | addl $0x3, %edi
cmpl $0x3, %edi
ja 0x7765
movl %edi, %eax
leaq 0x8d3c(%rip), %rcx # 0x10498
movslq (%rcx,%rax,4), %r8
addq %rcx, %r8
jmp 0x776c
leaq 0x8ecd(%rip), %r8 # 0x10639
leaq 0x8d35(%rip), %rsi # 0x104a8
leaq 0x8ecd(%rip), %rcx # 0x10647
movl $0xb9, %edx
movl $0x3, %edi
xorl %eax, %eax
jmp 0... | /cmusphinx[P]pocketsphinx/src/ps_config.c |
ps_config_set_str | const anytype_t *
ps_config_set_str(ps_config_t *config, char const *name, char const *val)
{
cmd_ln_val_t *cval = cmd_ln_access_r(config, name);
if (cval == NULL) {
E_ERROR("Unknown parameter %s\n", name);
return NULL;
}
if (anytype_from_str(&cval->val, cval->type, val) == NULL) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0xbe04
testq %rax, %rax
je 0x7b42
movq %rax, %rbx
movl 0x8(%rax), %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x81dc
testq %rax, %rax
cmoveq %rax, %rbx
jmp 0x7b66
leaq 0x895f(%rip), %rsi # 0x104a8
leaq 0x8c63(%rip), %rcx # 0x107b3
xorl %ebx... | /cmusphinx[P]pocketsphinx/src/ps_config.c |
nrv_alloc | static char *
nrv_alloc(char *s, char **rve, int n)
{
char *rv, *t;
rv = rv_alloc(n);
if (rv == NULL)
return NULL;
t = rv;
while((*t = *s++)) t++;
if (rve)
*rve = t;
return rv;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %edi
callq 0xb8ca
testq %rax, %rax
je 0xb8c2
movb (%r14), %dl
movb %dl, (%rax)
movq %rax, %rcx
testb %dl, %dl
je 0xb8ba
incq %r14
movq %rax, %rcx
movb (%r14), %dl
movb %dl, 0x1(%rcx)
incq %rcx
incq %r14
testb %dl, %dl
jne 0xb8aa
testq %rbx, %rb... | /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
rv_alloc | static char *
rv_alloc(int i)
{
int j, k, *r;
j = sizeof(ULong);
for(k = 0;
sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= (unsigned)i;
j <<= 1)
k++;
r = (int*)Balloc(k);
if (r == NULL)
return NULL;
*r = k;
return (char *)(r+1);
} | pushq %rbx
xorl %ebx, %ebx
cmpl $0x1c, %edi
jb 0xb8eb
movl %edi, %eax
movl $0x4, %ecx
xorl %ebx, %ebx
incl %ebx
addl %ecx, %ecx
movslq %ecx, %rdx
addq $0x18, %rdx
cmpq %rax, %rdx
jbe 0xb8db
movl %ebx, %edi
callq 0x9ba6
testq %rax, %rax
je 0xb8ff
movl %ebx, (%rax)
addq $0x4, %rax
jmp 0xb901
xorl %eax, %eax
popq %rbx
ret... | /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
hi0bits | static int
hi0bits(ULong x)
{
int k = 0;
if (!(x & 0xffff0000)) {
k = 16;
x <<= 16;
}
if (!(x & 0xff000000)) {
k += 8;
x <<= 8;
}
if (!(x & 0xf0000000)) {
k += 4;
x <<= 4;
}
if (!(x & 0xc0000000)) {
k += 2;
x <<= 2;
}
... | movl %edi, %eax
shll $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovael %edi, %eax
shll $0x4, %ecx
movl %eax, %edx
shll $0x8, %edx
cmpl $0x1000000, %eax # imm = 0x1000000
cmovael %eax, %edx
leal 0x8(%rcx), %eax
cmovael %ecx, %eax
movl %edx, %ecx
shll $0x4, %ecx
cmpl $0x1000... | /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
strncmp_nocase | int32
strncmp_nocase(const char *str1, const char *str2, size_t len)
{
char c1, c2;
if (str1 && str2) {
size_t n;
for (n = 0; n < len; ++n) {
c1 = *(str1++);
c1 = UPPER_CASE(c1);
c2 = *(str2++);
c2 = UPPER_CASE(c2);
if (c1 != c2)
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xbde8
testq %rdx, %rdx
je 0xbdf4
decq %rdx
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %eax
leal -0x61(%rax), %r8d
leal -0x20(%rax), %r9d
cmpb $0x1a, %r8b
movzbl %r9b, %r8d
cmovael %eax, %r8d
movzbl (%rsi,%rcx), %eax
leal -0x61(%rax), %r9d
leal -0x20(%rax), ... | /cmusphinx[P]pocketsphinx/src/util/case.c |
cmd_ln_log_help_r | void
cmd_ln_log_help_r(ps_config_t *cmdln, ps_arg_t const* defn)
{
if (defn == NULL)
return;
E_INFO("Arguments list definition:\n");
if (cmdln == NULL) {
cmdln = cmd_ln_parse_r(NULL, defn, 0, NULL, FALSE);
arg_log_r(cmdln, defn, TRUE, FALSE);
ps_config_free(cmdln);
}
... | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc701
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5e40(%rip), %rsi # 0x12510
leaq 0x600b(%rip), %rcx # 0x126e2
movl $0x22a, %edx # imm = 0x22A
movl $0x1, %edi
xorl %eax, %eax
callq 0xd7c7
testq %r14, %r14
je 0xc709
movq %r14, %rdi
movq %rbx, %rsi
mov... | /cmusphinx[P]pocketsphinx/src/util/cmd_ln.c |
cmd_ln_set_str_extra_r | void
cmd_ln_set_str_extra_r(ps_config_t *cmdln, char const *name, char const *str)
{
cmd_ln_val_t *val;
if (hash_table_lookup(cmdln->ht, name, (void **)&val) < 0) {
val = cmd_ln_val_init(ARG_STRING, name, str);
hash_table_enter(cmdln->ht, val->name, (void *)val);
} else {
if (!(val->type & ARG_STR... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %rdx
callq 0xcdc9
testl %eax, %eax
js 0xcb40
movq 0x8(%rsp), %rax
testb $0x8, 0x8(%rax)
jne 0xcb67
leaq 0x59ed(%rip), %rsi # 0x12510
leaq 0x3c0f(%rip), %rcx # 0x10739
movl $0x... | /cmusphinx[P]pocketsphinx/src/util/cmd_ln.c |
keycmp_nocase | static int32
keycmp_nocase(hash_entry_t * entry, const char *key)
{
char c1, c2;
int32 i;
const char *str;
str = entry->key;
for (i = 0; (uint32)i < entry->len; i++) {
c1 = *(str++);
c1 = UPPER_CASE(c1);
c2 = *(key++);
c2 = UPPER_CASE(c2);
if (c1 != c2)
... | movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xd735
movq (%rdi), %rcx
xorl %edx, %edx
movzbl (%rcx,%rdx), %r8d
leal -0x61(%r8), %edi
leal -0x20(%r8), %r9d
cmpb $0x1a, %dil
movzbl %r9b, %edi
cmovael %r8d, %edi
movzbl (%rsi,%rdx), %r9d
leal -0x61(%r9), %r8d
leal -0x20(%r9), %r10d
cmpb $0x1a, %r8b
movzbl %r10b, %r8d
cmovael %... | /cmusphinx[P]pocketsphinx/src/util/hash_table.c |
err_msg | void
err_msg(err_lvl_t lvl, const char *path, long ln, const char *fmt, ...)
{
char msg[1024];
va_list ap;
if (!err_cb)
return;
if (lvl < min_loglevel)
return;
va_start(ap, fmt);
vsnprintf(msg, sizeof(msg), fmt, ap);
va_end(ap);
if (path) {
const char *fname =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0xd81c
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0x... | /cmusphinx[P]pocketsphinx/src/util/err.c |
_ckd_salloc__ | char *
__ckd_salloc__(const char *orig, const char *caller_file,
int caller_line)
{
size_t len;
char *buf;
if (!orig)
return NULL;
len = strlen(orig) + 1;
buf = (char *) __ckd_malloc__(len, caller_file, caller_line);
strcpy(buf, orig);
return (buf);
} | testq %rdi, %rdi
je 0xddbc
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x30e0
leaq 0x1(%rax), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xdd23
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3080
xorl %eax, %eax
retq
| /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
glist_insert_float32 | gnode_t *
glist_insert_float32(gnode_t * gn, float32 val)
{
gnode_t *newgn;
newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
newgn->data.fl = (double)val;
newgn->next = gn->next;
gn->next = newgn;
return newgn;
} | pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x40b9(%rip), %rdx # 0x12b1d
movl $0x1, %edi
movl $0x10, %esi
movl $0xea, %ecx
callq 0xdce0
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%rbx)
addq $0x10, %rsp
popq %... | /cmusphinx[P]pocketsphinx/src/util/glist.c |
gnode_free | gnode_t *
gnode_free(gnode_t * gn, gnode_t * pred)
{
gnode_t *next;
next = gn->next;
if (pred) {
assert(pred->next == gn);
pred->next = next;
}
ckd_free((char *) gn);
return next;
} | pushq %rbx
movq 0x8(%rdi), %rbx
testq %rsi, %rsi
je 0xeaf0
cmpq %rdi, 0x8(%rsi)
jne 0xeafa
movq %rbx, 0x8(%rsi)
callq 0xdeb8
movq %rbx, %rax
popq %rbx
retq
leaq 0x4078(%rip), %rdi # 0x12b79
leaq 0x4015(%rip), %rsi # 0x12b1d
leaq 0x407b(%rip), %rcx # 0x12b8a
movl $0x107, %edx # imm = 0x107
call... | /cmusphinx[P]pocketsphinx/src/util/glist.c |
path_is_absolute | int
path_is_absolute(const char *path)
{
#if defined(_WIN32) && !defined(_WIN32_WCE) /* FIXME: Also SymbianOS */
return /* Starts with drive letter : \ or / */
(strlen(path) >= 3
&&
((path[0] >= 'A' && path[0] <= 'Z')
|| (path[0] >= 'a' && path[0] <= 'z'))
&& path[1] == ... | xorl %eax, %eax
cmpb $0x2f, (%rdi)
sete %al
retq
| /cmusphinx[P]pocketsphinx/src/util/filename.c |
cppcms::json::value::get[abi:cxx11](char const*, char const*) const | std::string get(char const *path,char const *def) const
{
value const &v=find(path);
if(v.is_undefined())
return def;
try {
return v.get_value<std::string>();
}
catch(std::bad_cast const &e) {
return def;
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4200
movq %rax, %r15
movq %rax, %rdi
callq 0x4400
testb %al, %al
je 0x490f
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4350
jmp 0x4930
movq %r15, %rdi
callq 0x43c0
leaq 0x10(%rbx), ... | /artyom-beilis[P]cppcms/cppcms/json.h |
submitter::operator()() const | void operator()() const
{
srv_->thread_pool().post(runner(*srv_));
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x4170
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x5446
movq %rsp, %rdi
movq %r14, %rsi
callq 0x551e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4230
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x53e6
movq %rsp,... | /artyom-beilis[P]cppcms/tests/client.h |
linklist_5_3::del_same_(linklist_5_3::node*&, int) | int del_same_(LinkList &a, int x) {
LinkList p = a, q = a->next, w;
while (q != nullptr) {
if (q->data == x) {
w = q;
q = q->next;
p->next = q;
free(w);
} else {
p = q;
q = q->next;
... | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq (%rdi), %r14
movq 0x8(%r14), %r15
movq %r15, %rdi
movq 0x8(%r15), %r15
cmpl %ebx, (%rdi)
jne 0x19bd
movq %r15, 0x8(%r14)
callq 0x10d0
jmp 0x19a7
movq %rdi, %r14
jmp 0x19a7
| /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
linklist_5_3::create_tail(linklist_5_3::node*&, int*, int) | int create_tail(LinkList &list, int *a, int n = 10) {
LinkList q = newNode, p;
q->next = nullptr;
for (int i = 0; i < n; i++) {
p = newNode;
p->data = a[i];
q->next = p;
q = p;
}
ps_link_list(q);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
pushq $0x10
popq %r15
movq %r15, %rdi
callq 0x10e0
movq %rax, %r12
andq $0x0, 0x8(%rax)
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0x1b59
movq %r15, %rdi
callq 0x10e0
movl (%r14,%r13,4), %ecx
movl %ecx,... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
linklist_5_3::get_common_arr(int*, int, int*, int) | int get_common_arr(int *a, int n1, int *b, int n2) {
int i = 0, j = 0;
LinkList list = newNode, p, q;
list->next = nullptr;
q = list;
while (i < n1 && j < n2) {
if (a[i] == b[j]) {
p = newNode;
p->data = a[i];
// q->next ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
pushq $0x10
popq %rdi
callq 0x10e0
movq %rax, 0x8(%rsp)
andq $0x0, 0x8(%rax)
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r15d, %r15d
movslq %ecx, %rax
movslq %r15d, %r15
cmpl %ebp... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
linklist_5_3::test_1() | void test_1() {
LinkList list;
auto a = newNode;
a->data = 0;
a->next = list;
ps_link_list(list);
// insert(list, 3, 12);
// int e;
// del_(list, 4, &e);
// reverse_order(list);
// reverse(a);
// ps_link_list(a);
// sort_asc(a);
//... | pushq %rbx
subq $0x10, %rsp
pushq $0x10
popq %rdi
callq 0x10e0
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
andl $0x0, (%rax)
callq 0x173e
movq %rbx, %rdi
callq 0x1a88
| /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
stack_5_3::semmetry(linklist_5_3::node*&, int) | void test() {
linklist_5_3::LinkList list;
int aa[] = {1, 2, 3, 2, 1};
list = linklist_5_3::create(aa, 3, 5);
linklist_5_3::LinkList a = (linklist_5_3::LinkList) malloc(sizeof(linklist_5_3::node));
a->next = list;
semmetry(a, 5);
} | pushq %rax
leaq 0x1ee6(%rip), %rdi # 0x4140
pushq $0x3
popq %rsi
pushq $0x5
popq %rdx
callq 0x17bf
| /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
queue_5_3::deQueue(queue_5_3::sq_queue&, int&) | int deQueue(sq_queue &q, int &e) {
if (q.front == q.rear)
return errCode("空队", 0);
e = q.data[q.front];
q.front = (q.front + 1) % q.ssize;
return 1;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movslq 0x8(%rdi), %rax
cmpl 0xc(%rdi), %eax
jne 0x2332
leaq 0x1d9e(%rip), %rsi # 0x40a6
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1050
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x130b
leaq 0x8(%rsp), %rdi
callq 0x1070
jmp 0x2349
movq (%rdi)... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
tree_5_3::preOrder(tree_5_3::node*) | int preOrder(Btree t) {
Btree p = t, stack[22];
int top = -1;
do {
while (p != nullptr) {
stack[++top] = p;
p = p->left;
}
p = stack[top--];
printf("%c\t", p->data);
p = p->right;
} while (top != ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
pushq $-0x1
popq %r14
leaq 0x1bd8(%rip), %rbx # 0x40ad
movabsq $0x100000000, %r15 # imm = 0x100000000
movq %r14, %rax
shlq $0x20, %rax
movslq %r14d, %r14
decq %r14
testq %rdi, %rdi
je 0x2501
movq %rdi, 0x10(%rsp,%r14,8)
movq (%rdi), %rdi
incq %r14
a... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
tree_5_3::layorOrder(tree_5_3::node*) | int layorOrder(Btree t) {
Btree p = t, q[22];
int f, r;
if (p != nullptr) {
q[0] = p;
f = -1;
r = 0;
while (f < r) {
p = q[++f];
printf("%c\t", p->data);
if (p->left != nullptr)
q[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
testq %rdi, %rdi
je 0x262d
movq %rdi, (%rsp)
pushq $-0x1
popq %r14
leaq 0x1ac9(%rip), %rbx # 0x40ad
xorl %ebp, %ebp
movslq %ebp, %r15
cmpq %r15, %r14
jge 0x262d
movq 0x8(%rsp,%r14,8), %r12
movl 0x10(%r12), %esi
movq %rbx, %rdi
xorl %eax, %eax
... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
tree_5_3::search_2(tree_5_3::node*, int) | Btree search_2(Btree t, int e) {
Btree p = t;
while (p != nullptr && p->data != e) {
if (e < p->data)
p = p->left;
else
p = p->right;
}
return p;
} | movq %rdi, %rax
testq %rax, %rax
je 0x26c0
cmpl %esi, 0x10(%rax)
je 0x26c0
setle %cl
movzbl %cl, %ecx
movq (%rax,%rcx,8), %rax
jmp 0x26aa
retq
| /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
grapg_5_3::m_bfs(grapg_5_3::m_graph, int) | int m_bfs(m_graph g, int v) {
visited[v] = 1;
//visit;
int q[g.vnum];
int f = -1, r = 0;
for (int i = 0; i < g.vnum; i++) {
if (visited[i] == 0) {
visited[i] = 1;
q[r++] = i;
while (f < r) {
i = q[++f... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x10(%rbp), %rax
movslq %edi, %rdx
leaq 0x4959(%rip), %rcx # 0x70e0
movl $0x1, (%rcx,%rdx,4)
movl 0x1b8(%rax), %r8d
movq %rsp, %rdx
leaq 0xf(,%r8,4), %rsi
andq $-0x10, %rsi
subq %rsi, %rdx
movq %rdx, %rsp
xorl %esi, %esi
testl %r8d, %r8d
movl $0x0, %edi
cmovgl ... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
grapg_5_3::dfs(grapg_5_3::graph, int) | int dfs(graph g, int v) {
visited[v] = 1;
//visit;
enode *e = g.vexs[v].edge;
while (e != nullptr) {
if (visited[e->adjvex] == 0)
dfs(g, e->adjvex);
e = e->next;
}
} | subq $0xa8, %rsp
leaq 0xb0(%rsp), %rsi
movslq %edi, %rax
leaq 0x47f2(%rip), %rcx # 0x70e0
movl $0x1, (%rcx,%rax,4)
shlq $0x4, %rax
leaq (%rsp,%rax), %rdx
addq $0xb8, %rdx
movq (%rdx), %rdx
movslq (%rdx), %rax
addq $0x8, %rdx
cmpl $0x0, (%rcx,%rax,4)
jne 0x2904
pushq $0x15
popq %rcx
movq %rsp, %rdi
rep movsq (%rsi... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
grapg_5_3::kruskal(grapg_5_3::m_graph) | int prim_3(m_graph g) {
int adj[g.vnum], dis[g.vnum], min, j, k;
adj[0] = 0;
dis[0] = 0;
for (int i = 1; i < g.vnum; i++) {
dis[i] = g.arc[0][i];
adj[i] = 0;
}
for (int i = 0; i < g.vnum; i++) {
j = 1;
k = 0;
mi... | pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movslq 0x1b8(%rax), %rsi
movl %esi, %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,4), %rdi
andq $-0x10, %rdi
subq %rdi, %rdx
movq %rdx, %rsp
pushq $0x1
popq %rdi
cmpq %rsi, %rdi
jge 0x2a24
movl (%rax,%rdi,4), %r8d
movl %r8d, (%rdx,%rdi,4)
incq %rdi
jmp 0x2a12
pushq $0x1
popq %rsi
... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
grapg_5_3::dijkstra_1(grapg_5_3::m_graph, int) | int dijkstra_1(m_graph g, int v) {
int min, k;
int ver[g.vnum];
int dis[g.vnum];
int flag[g.vnum];
for (int i = 0; i < g.vnum; i++) {
dis[i] = g.arc[v][i];
flag[i] = 0;
ver[i] = 0;
}
flag[0] = 1;//自己一个点不用求
dis[0] = 0;//自... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x10(%rbp), %rax
movl 0x1b8(%rax), %ecx
movq %rsp, %rdx
leaq 0xf(,%rcx,4), %r8
andq $-0x10, %r8
subq %r8, %rdx
movq %rdx, %rsp
movq %rsp, %rsi
subq %r8, %rsi
movq %rsi, %rsp
movslq %edi, %r9
xorl %edi, %edi
testl %ecx, %ecx
movl $0x0, %r8d
cmovgl %ecx, %r8d
imulq $0... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
search_5_3::index(char*, char*, int) | int index(char *s, char *t, int p = 0) {
int i = p, j = 1;
int *a;
next(t, a);
while (i < s[0] && j < t[0]) {
if (s[i] == t[j]) {
i++, j++;
} else {
j = a[j];
}
}
if (j > t[0])
return i - t[0]... | pushq %rax
movq %rsi, %rdi
callq 0x2cdc
| /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
sort_5_3::shell_sort_1(int*, int, int) | int shell_sort_1(int *a, int n, int gap = 2) {
int j, g = n / gap, t;
while (g > 0) {
for (int i = g; i < n; i++) {
t = a[i];
for (j = i - g; j >= 0 && a[j] > t; j -= g) {
a[j + g] = a[j];
}
a[j + g] = t;
... | pushq %rbx
movl %edx, %ecx
movl %esi, %eax
movslq %esi, %rsi
cltd
idivl %ecx
xorl %edx, %edx
movq %rax, %r8
cmpq %rsi, %r8
jge 0x2e36
movl (%rdi,%r8,4), %r9d
movl %edx, %r10d
testl %r10d, %r10d
js 0x2e6a
movl %r10d, %r11d
movl (%rdi,%r11,4), %r11d
cmpl %r9d, %r11d
jle 0x2e6a
leal (%rax,%r10), %ebx
movl %ebx, %ebx
movl ... | /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
sort_5_3::test() | void test() {
int a1[] = {12, 4, 67, 5, 88, 15, 34, 26, 33, 19};
ps_int(a1, 10);
// select_sort_1(a1, 10);
// bubble_sort_1(a1, 10);
// insert_sort_1(a1, 10);
// insert_sort_b_1(a1, 10);
// shell_sort_1(a1, 10);
// quick_sort_2(a1, 0, 9);
// heap_sort_4(a... | pushq %rbx
leaq 0x1039(%rip), %rbx # 0x4160
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x16ab
pushq $0x9
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x310e
| /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
run_3::test() | void test() {
sort_5_3::test();
// search_5_3::test();
// grapg_5_3::test();
// tree_5_3::test();
// queue_5_3::test();
// stack_5_3::test();
// linklist_5_3::test();
// sqlist_5_3::test();
} | pushq %rax
callq 0x311f
| /baiyuu[P]c_datastruct/d_5/r1/run_3.h |
sort_5_4::insert_b_sort_1(int*, int) | int insert_b_sort_1(int *a, int n) {
int mid, low, high, t;
for (int i = 0; i < n; i++) {
low = 0, high = i - 1, t = a[i];
while (low <= high) {
mid = (low + high) / 2;
// if (t < a[mid])
// high = mid - 1;
// else
... | pushq $-0x1
popq %rax
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
leal -0x1(%rcx), %esi
xorl %r8d, %r8d
cmpl %esi, %r8d
jg 0x32be
leal (%r8,%rsi), %r9d
shrl %r9d
cmpl (%rdi,%r9,4), %edx
jl 0x32b6
decl %r9d
movl %r9d, %esi
jmp 0x329c
incl %r9d
movl %r9d, %r8d
jmp 0x329c
movl %r8d, %esi
movq %rax, %r8
cmpq %rsi, %r8
jl 0x32... | /baiyuu[P]c_datastruct/d_5/r4.h |
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.