name string | code string | asm string | file string |
|---|---|---|---|
(anonymous namespace)::CreateInstallFilesGenerator(cmMakefile*, 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>>>> const&, cmInstallCommandArguments const&, bool, std::__cxx11::basic_... | std::unique_ptr<cmInstallFilesGenerator> CreateInstallFilesGenerator(
cmMakefile* mf, const std::vector<std::string>& absFiles,
const cmInstallCommandArguments& args, bool programs,
const std::string& destination)
{
cmInstallGenerator::MessageLevel message =
cmInstallGenerator::SelectMessageLevel(mf);
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
leaq 0x2(%rsp), %rax
movb %r8b, (%rax)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x330e80
leaq 0x4(%rsp), %rcx
movl %eax, (%rcx)
movq %r15, %rdi... | /JKorbelRA[P]CMake/Source/cmInstallCommand.cxx |
ArgumentParser::ParseResult cmArgumentParser<void>::Parse<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::char_traits<char>, std:... | ParseResult Parse(Range const& args,
std::vector<std::string>* unparsedArguments,
std::size_t pos = 0) const
{
ParseResult parseResult;
Instance instance(this->Bindings, &parseResult, unparsedArguments);
instance.Parse(args, pos);
return parseResult;
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %edi, %edi
movq %rdi, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rdi, 0x28(%rbx)
movq %rsp, %rdi
movq %rsi, (%rdi)
movq %rbx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [50]>(cmAlphaNum const&, cmAlphaNum const&, char const (&) [50]) | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movq %rsp, %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq %rcx, %rdi
callq 0x39d50
movq %rax, 0x20(%r15)
movq %rbx, 0x28(%r15)
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xec4e... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [24]>(cmAlphaNum const&, cmAlphaNum const&, char const (&) [24]) | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movq %rsp, %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq %rcx, %rdi
callq 0x39d50
movq %rax, 0x20(%r15)
movq %rbx, 0x28(%r15)
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xec4e... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmInstallRuntimeDependencySet::AddBundleExecutable(cmInstallTargetGenerator*) | bool AddBundleExecutable(cmInstallTargetGenerator* bundleExecutable)
{
return this->AddBundleExecutable(
cm::make_unique<TargetItem>(bundleExecutable));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x39460
leaq 0x5d4c2b(%rip), %rcx # 0x77ba00
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x337a38
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a6dff
... | /JKorbelRA[P]CMake/Source/cmInstallRuntimeDependencySet.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [14]>(cmAlphaNum const&, cmAlphaNum const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [... | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movq %rsp, %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r8, %rdi
callq 0x39d50
movq %rax, 0x30(%r15)
m... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmInstallRuntimeDependencySet::AddLibrary(cmInstallImportedRuntimeArtifactsGenerator*) | void AddLibrary(cmInstallImportedRuntimeArtifactsGenerator* library)
{
this->AddLibrary(cm::make_unique<ImportedTargetItem>(library));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x39460
leaq 0x5d3c53(%rip), %rcx # 0x77ba48
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x337a24
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a7e1d
movq (%rdi), %ra... | /JKorbelRA[P]CMake/Source/cmInstallRuntimeDependencySet.h |
cmInstallRuntimeDependencySet::AddExecutable(cmInstallImportedRuntimeArtifactsGenerator*) | void AddExecutable(cmInstallImportedRuntimeArtifactsGenerator* executable)
{
this->AddExecutable(cm::make_unique<ImportedTargetItem>(executable));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x39460
leaq 0x5d3b87(%rip), %rcx # 0x77ba48
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x337a1a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a7ee9
movq (%rdi), %ra... | /JKorbelRA[P]CMake/Source/cmInstallRuntimeDependencySet.h |
(anonymous namespace)::HandleLengthCommand(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>>>> const&, cmExecutionStatus&) | bool HandleLengthCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("sub-command LENGTH requires two arguments.");
return false;
}
const std::string& listName = args[1];
const std::string& variableName = args.back(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %r14
movq %r14, %r12
subq %rsi, %r12
cmpq $0x60, %r12
jne 0x1aca31
addq $0x20, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rbx), %rdx
cal... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::TransformNoSelector::~TransformNoSelector() | TransformNoSelector()
: TransformSelector("NO SELECTOR")
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x5c3bc1(%rip), %rax # 0x777f48
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x1b43a2
movq (%rax), %rsi
incq %rsi
callq 0x39320
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x39320
| /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::cmStringSorter::operator()(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 operator()(const std::string& a, const std::string& b)
{
std::string af = this->ApplyFilter(a);
std::string bf = this->ApplyFilter(b);
bool result;
if (this->descending) {
result = this->sortMethod(bf, af);
} else {
result = this->sortMethod(af, bf);
}
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b4fba
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b4fba
cmpq $0x0, 0x20(%rbx)
je 0x1b4f6e
c... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
(anonymous namespace)::FilterRegex(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>>>> const&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cons... | bool FilterRegex(std::vector<std::string> const& args, bool includeMatches,
std::string const& listName,
std::vector<std::string>& varArgsExpanded,
cmExecutionStatus& status)
{
const std::string& pattern = args[4];
cmsys::RegularExpression regex(pattern);
if (!re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r8, %r14
movq %rcx, %r15
movq %rdx, 0x20(%rsp)
movl %esi, %ebp
movq %rdi, %r12
xorl %eax, %eax
leaq 0x78(%rsp), %r13
movq %rax, 0xb0(%r13)
movq %rax, 0xc0(%r13)
movl $0x0, 0xc8(%r13)
movl $0xaa, %edx
movq ... | /JKorbelRA[P]CMake/Source/cmListCommand.cxx |
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>>>>::const_iterator cmRemoveIndices<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::all... | typename Range::iterator cmRemoveDuplicates(Range& r)
{
return cmRemoveDuplicates(r.begin(), r.end());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %r13
movq 0x8(%rsi), %rdx
movq 0x8(%rdi), %r15
cmpq %rdx, %r13
je 0x1b57ab
movq (%r13), %rsi
movq %rsi, %r14
shlq $0x5, %r14
addq (%rdi), %r14
leaq 0x8(%r13), %rax
cmpq %r15, %r14
setne %cl
cmpq %rdx, %rax
setne %al
andb %cl... | /JKorbelRA[P]CMake/Source/cmAlgorithms.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [10], int, char [17], unsigned long, char [3], unsigned long, char [3]>(cmAlphaNum const&, cmAlphaNum const&, char const (&) [10], int const&, char const (&) [17], unsigned long const&, char const (&) [3], unsigned long const&,... | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %r9, %r13
movq %r8, %rbp
movq %rcx, %r15
movq %rdi, %rbx
movq 0x168(%rsp), %r12
movups (%rsi), %xmm0
leaq 0x98(%rsp), %r14
movups %xmm0, (%r14)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r14)
movq %rcx, %rdi
... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmGetProjectName(void*) | static const char* CCONV cmGetProjectName(void* arg)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
static std::string name;
name = mf->GetStateSnapshot().GetProjectName();
return name.c_str();
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb 0x5d39e7(%rip), %al # 0x78ce70
testb %al, %al
je 0x1b94e3
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa6f66
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xeadf2
leaq 0x5d399e(%rip), %rdi # 0x78ce50
movq %rbx, %rsi
callq 0x3a1e... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileGetPropertyAsBool(void*, char const*) | static int CCONV cmSourceFileGetPropertyAsBool(void* arg, const char* prop)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
return rsf->GetPropertyAsBool(prop) ? 1 : 0;
}
return cmIsOn(cmSourceFileGetProperty(arg, prop)) ? 1 : 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1b9c78
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x5aaf2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd8008
movl %eax, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b9c87
movq 0x18(%rsp), %rsi
incq ... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileSetName(void*, char const*, char const*, int, char const**, int, char const**) | static void CCONV cmSourceFileSetName(void* arg, const char* name,
const char* dir, int numSourceExtensions,
const char** sourceExtensions,
int numHeaderExtensions,
con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
cmpq $0x0, (%rdi)
jne 0x1ba3c9
movl %r9d, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
xorl %eax, %eax
movq %rax, 0xb0(%rsp)
movq %rax, 0x90(%rsp)
movaps ... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileSetName2(void*, char const*, char const*, char const*, int) | static void CCONV cmSourceFileSetName2(void* arg, const char* name,
const char* dir, const char* ext,
int headerFileOnly)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (sf->RealSourceFile) {
// SetName i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, (%rdi)
jne 0x1ba69b
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testl %r8d, %r8d
je 0x1ba5af
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3e185d(%rip), %rsi # 0x59bdcc
leaq 0x3e1866(%rip), %rdx ... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmSourceFileSetProperty(void*, char const*, char const*) | static void CCONV cmSourceFileSetProperty(void* arg, const char* prop,
const char* value)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
rsf->SetProperty(prop, value);
} else if (prop) {
if (... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq (%rdi), %r12
testq %r12, %r12
je 0x1ba720
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x5aaf2
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0xd7d58
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmCapitalized(char const*) | static char* CCONV cmCapitalized(const char* name)
{
std::string sres = cmSystemTools::Capitalized(name);
return strdup(sres.c_str());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5aaf2
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f5bb8
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ba80f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x39320
leaq 0x40... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmCopyFileIfDifferent(char const*, char const*) | static void CCONV cmCopyFileIfDifferent(const char* name1, const char* name2)
{
cmSystemTools::CopyFileIfDifferent(name1, name2);
} | pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5aaf2
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %rbx, %rsi
callq 0x5aaf2
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3f6ab4
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ba8c... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmGetFilenameWithoutExtension(char const*) | static char* CCONV cmGetFilenameWithoutExtension(const char* name)
{
std::string sres = cmSystemTools::GetFilenameWithoutExtension(name);
return strdup(sres.c_str());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5aaf2
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x3fa528
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ba96e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x39320
leaq 0x40... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmGetFilenamePath(char const*) | static char* CCONV cmGetFilenamePath(const char* name)
{
std::string sres = cmSystemTools::GetFilenamePath(name);
return strdup(sres.c_str());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5aaf2
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f777a
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1baa10
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x39320
leaq 0x40... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmRemoveFile(char const*) | static void CCONV cmRemoveFile(const char* name)
{
cmSystemTools::RemoveFile(name);
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5aaf2
movq %rbx, %rdi
callq 0x3f7638
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1baaa9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x39320
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq ... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmAddCustomCommandToOutput(void*, char const*, char const*, int, char const**, char const*, int, char const**) | static void CCONV cmAddCustomCommandToOutput(void* arg, const char* output,
const char* command, int numArgs,
const char** args,
const char* main_dependency,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r9, %r14
movq %r8, %r12
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rax
movq %rdx, %rsi
movq %r... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmAddCustomCommandToTarget(void*, char const*, char const*, int, char const**, int) | static void CCONV cmAddCustomCommandToTarget(void* arg, const char* target,
const char* command, int numArgs,
const char** args,
int commandType)
{
// Get the makefile instance.
cmM... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, %ebp
movq %r8, 0x48(%rsp)
movl %ecx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmDisplayStatus(void*, char const*) | static void CCONV cmDisplayStatus(void* arg, const char* message)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
mf->DisplayStatus(message, -1);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x5aaf2
movss 0x3efcae(%rip), %xmm0 # 0x5aae7c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xac710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bb1f4
movq 0x18(%rsp), %rsi
incq %rsi
c... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
cmCreateNewSourceFile(void*) | static void* CCONV cmCreateNewSourceFile(void*)
{
return new cmCPluginAPISourceFile;
} | pushq %rax
movl $0xb8, %edi
callq 0x39460
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), %rdx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb ... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
DefineSourceFileProperty(void*, char const*, char const*, char const*, int) | static void CCONV DefineSourceFileProperty(void* arg, const char* name,
const char* briefDocs,
const char* longDocs, int chained)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
mf->GetState()->DefineProperty(name, cmProperty::S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
callq 0x9e354
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movq %r15, %rsi
callq 0x5aaf2
testq %r12, %r12
leaq 0x451bab(%rip), %r15 # 0x60ce89
cmoveq %r15,... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
addLinkLibrary(cmMakefile*, 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&, cmTargetLinkLibraryType) | static void addLinkLibrary(cmMakefile* mf, std::string const& target,
std::string const& lib, cmTargetLinkLibraryType llt)
{
cmTarget* t = mf->FindLocalNonAliasTarget(target);
if (!t) {
std::ostringstream e;
e << "Attempt to add link library \"" << lib << "\" to target \"" << targ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0xae38a
testq %rax, %rax
je 0x1bb611
movq %rax, %r15
movq %rbx, %rdi
callq 0xa3cf0
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x31... | /JKorbelRA[P]CMake/Source/cmCPluginAPI.cxx |
(anonymous namespace)::SignalHandlerGuard::SignalHandlerGuard(char const*) | explicit SignalHandlerGuard(const char* name)
{
LastName = name != nullptr ? name : "????";
signal(SIGSEGV, TrapsForSignals);
#ifdef SIGBUS
signal(SIGBUS, TrapsForSignals);
#endif
signal(SIGILL, TrapsForSignals);
} | pushq %rbx
testq %rdi, %rdi
leaq 0x43e4af(%rip), %rax # 0x5f9bf2
cmovneq %rdi, %rax
movq %rax, 0x5d16fa(%rip) # 0x78ce48
leaq -0x17d06f(%rip), %rbx # 0x3e6e6
movl $0xb, %edi
movq %rbx, %rsi
callq 0x39c20
movl $0x7, %edi
movq %rbx, %rsi
callq 0x39c20
movl $0x4, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x39c20
nop
| /JKorbelRA[P]CMake/Source/cmLoadCommandCommand.cxx |
cmMacroCommand(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>>>> const&, cmExecutionStatus&) | bool cmMacroCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
// create a function blocker
{
auto fb = cm::make_unique<cmMacroFunctionBlocker>();
cm::ap... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq (%rdi), %rbx
movq 0x8(%rdi), %r14
cmpq %r14, %rbx
je 0x1bc3b2
movl $0xb0, %edi
callq 0x39460
movq %rax, %r12
leaq 0x10(%rax), %rdi
xorl %r13d, %r13d
movl $0x90, %edx
xorl %esi, %esi
callq 0x39a90
leaq 0x18(%r12), %rax
movq %rax... | /JKorbelRA[P]CMake/Source/cmMacroCommand.cxx |
(anonymous namespace)::cmMacroFunctionBlocker::Replay(std::vector<cmListFileFunction, std::allocator<cmListFileFunction>>, cmExecutionStatus&) | bool cmMacroFunctionBlocker::Replay(std::vector<cmListFileFunction> functions,
cmExecutionStatus& status)
{
cmMakefile& mf = status.GetMakefile();
mf.AppendProperty("MACROS", this->Args[0]);
// create a new command and add it to cmake
cmMacroHelperCommand f;
f.Args = this->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r12
movq %rdi, %r15
movq (%rdx), %r14
leaq 0x90(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x41c1e4(%rip), %rsi # 0x5d8763
leaq 0x41c1e3(%rip), %rdx # 0x5d8769
leaq 0x80(%rsp), %rdi
callq 0x5b4c6
... | /JKorbelRA[P]CMake/Source/cmMacroCommand.cxx |
cmMakeDirectoryCommand(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>>>> const&, cmExecutionStatus&) | bool cmMakeDirectoryCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 1) {
status.SetError("called with incorrect number of arguments");
return false;
}
if (!status.GetMakefile().CanIWriteThisFile(args[0])) {
std::string e = "atte... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x1bdc8a
movq %rdi, %r14
movq (%rbx), %rdi
callq 0xa8390
testb %al, %al
je 0x1bdcc1
movq (%r14), %rdi
xorl %esi, %esi
callq 0x3f532a
movb $0x1, %al
jmp 0x1bdd7c
leaq 0x18(%rsp), %r14
movq %... | /JKorbelRA[P]CMake/Source/cmMakeDirectoryCommand.cxx |
cmMarkAsAdvancedCommand(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>>>> const&, cmExecutionStatus&) | bool cmMarkAsAdvancedCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
unsigned int i = 0;
const char* value = "1";
bool overwrite = false;
if (arg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
cmpq 0x8(%r14), %rdi
je 0x1be125
leaq 0x4006cb(%rip), %rsi # 0x5be4bb
callq 0x3b1f0
testl %eax, %eax
je 0x1bde24
movq (%r14), %rdi
leaq 0x432192(%rip), %rsi # 0x5eff95
callq 0x3b1f0... | /JKorbelRA[P]CMake/Source/cmMarkAsAdvancedCommand.cxx |
cmMathCommand(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>>>> const&, cmExecutionStatus&) | bool cmMathCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("must be called with at least one argument.");
return false;
}
const std::string& subCommand = args[0];
if (subCommand == "EXPR") {
return HandleExprCommand(ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp # imm = 0x538
movq %rsi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rdi), %r14
je 0x1be2b3
movq %rdi, %r15
leaq 0x4003f1(%rip), %rsi # 0x5be658
movq %r14, %rdi
callq 0x3b1f0
testl %eax, %eax
je 0x1be321
leaq 0x4003df(%rip), %rsi ... | /JKorbelRA[P]CMake/Source/cmMathCommand.cxx |
cmMessageCommand(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>>>> const&, cmExecutionStatus&) | bool cmMessageCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
auto& mf = status.GetMakefile();
auto i = args.cbegin();
auto type = MessageType::MESSAGE;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %r12
cmpq %r12, %rbx
movq %r12, 0x50(%rsp)
je 0x1bee0e
movq %rdi, %r15
movq (%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x3ffa3d(%rip), %rsi # 0x5be6fc
movq %rbx,... | /JKorbelRA[P]CMake/Source/cmMessageCommand.cxx |
(anonymous namespace)::IndentText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmMakefile&) | std::string IndentText(std::string text, cmMakefile& mf)
{
auto indent =
cmJoin(cmExpandedList(mf.GetSafeDefinition("CMAKE_MESSAGE_INDENT")), "");
const auto showContext = mf.GetCMakeInstance()->GetShowLogContext() ||
mf.IsOn("CMAKE_MESSAGE_CONTEXT_SHOW");
if (showContext) {
auto context = cmJoin(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3fefad(%rip), %rsi # 0x5be745
leaq 0x3fefba(%rip), %rdx # 0x5be759
movq %rsp, %rdi
callq 0x5b4c6
movq %rsp, %rsi
movq %r15, %rdi
callq 0x9cb42... | /JKorbelRA[P]CMake/Source/cmMessageCommand.cxx |
(anonymous namespace)::ReportCheckResult(std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmMakefile&) | void ReportCheckResult(cm::string_view what, std::string result,
cmMakefile& mf)
{
if (mf.GetCMakeInstance()->HasCheckInProgress()) {
auto text = mf.GetCMakeInstance()->GetTopCheckInProgressMessage() + " - " +
std::move(result);
mf.DisplayStatus(IndentText(std::move(text), mf), -1... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0x9c6b4
movq 0x848(%rax), %rcx
cmpq 0x828(%rax), %rcx
je 0x1bfbd2
movq %rbx, %rdi
callq 0x9c6b4
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1c01bc
leaq 0x3... | /JKorbelRA[P]CMake/Source/cmMessageCommand.cxx |
cmake::GetTopCheckInProgressMessage[abi:cxx11]() | std::string GetTopCheckInProgressMessage()
{
auto message = this->CheckInProgressMessages.top();
this->CheckInProgressMessages.pop();
return message;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x848(%rsi), %rax
cmpq 0x850(%rsi), %rax
jne 0x1c01e6
movq 0x860(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
addq $0x818, %r14 # imm = 0x818
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq -0x20(%rax), %rsi
mo... | /JKorbelRA[P]CMake/Source/cmake.h |
(anonymous namespace)::ListDependencies((anonymous namespace)::cmDependInformation const*, _IO_FILE*, std::set<(anonymous namespace)::cmDependInformation const*, std::less<(anonymous namespace)::cmDependInformation const*>, std::allocator<(anonymous namespace)::cmDependInformation const*>>*) | void ListDependencies(cmDependInformation const* info, FILE* fout,
std::set<cmDependInformation const*>* visited)
{
// add info to the visited set
visited->insert(info);
// now recurse with info's dependencies
for (cmDependInformation* d : info->DependencySet) {
if (visited->find(d) ==... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
leaq 0x8(%rdx), %rbp
movq %rdx, 0x8(%rsp)
movq 0x10(%rdx), %rcx
movq %rbp, %r14
testq %rcx, %rcx
movq %rbp, 0x10(%rsp)
je 0x1c0d42
movq %rcx, %r14
movq 0x20(%rcx), %rax
xorl %ecx, %ecx
cmpq %r15, %ra... | /JKorbelRA[P]CMake/Source/cmOutputRequiredFilesCommand.cxx |
(anonymous namespace)::cmLBDepend::GenerateDependInformation((anonymous namespace)::cmDependInformation*) | void GenerateDependInformation(cmDependInformation* info)
{
// If dependencies are already done, stop now.
if (info->DependDone) {
return;
}
// Make sure we don't visit the same file more than once.
info->DependDone = true;
const std::string& path = info->FullPath;
if (path.empty())... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
cmpb $0x0, 0x30(%rsi)
jne 0x1c2385
movq %rsi, %rbx
movb $0x1, 0x30(%rsi)
cmpq $0x0, 0x48(%rsi)
je 0x1c18d5
movq %rdi, %r13
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x3f592e
testb %al, %al
movq... | /JKorbelRA[P]CMake/Source/cmOutputRequiredFilesCommand.cxx |
(anonymous namespace)::cmLBDepend::AddDependency((anonymous namespace)::cmDependInformation*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void AddDependency(cmDependInformation* info, const std::string& file)
{
cmDependInformation* dependInfo =
this->GetDependInformation(file, info->PathOnly);
this->GenerateDependInformation(dependInfo);
info->AddDependencies(dependInfo);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x60(%rsi), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1c10ce
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x1c1810
cmpq %rbx, %r14
je 0x1c2716
leaq 0x8(%rbx), %r15
movq 0x10(%rbx), %rcx
movq %r15, %r12
testq %rcx, %r... | /JKorbelRA[P]CMake/Source/cmOutputRequiredFilesCommand.cxx |
cmMakefile::GetIncludeRegularExpression[abi:cxx11]() const | const std::string& GetIncludeRegularExpression() const
{
return this->GetProperty("INCLUDE_REGULAR_EXPRESSION");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3e400e(%rip), %rsi # 0x5a6804
leaq 0x3e4021(%rip), %rdx # 0x5a681e
movq %rsp, %r14
movq %r14, %rdi
callq 0x5b4c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa3370
movq %rax, %rbx
movq (%rsp), %rdi
cmp... | /JKorbelRA[P]CMake/Source/cmMakefile.h |
cmParseArgumentsCommand(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>>>> const&, cmExecutionStatus&) | bool cmParseArgumentsCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
// cmake_parse_arguments(prefix options single multi <ARGN>)
// 1 2 3 4
// or
// cmake_parse_arguments(PARSE_ARGV N prefix options single multi)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp # imm = 0x3C8
movq %rsi, 0x8(%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %r12
movq %r12, %r14
subq %r15, %r14
cmpq $0x60, %r14
jbe 0x1c34fd
movq %rdi, %rbx
movq $0x0, 0xe0(%rsp)
leaq 0x3fbc2f(%rip), %rsi # 0x5be922
movq %r15, ... | /JKorbelRA[P]CMake/Source/cmParseArgumentsCommand.cxx |
JoinList(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>>>> const&, bool) | static std::string JoinList(std::vector<std::string> const& arg, bool escape)
{
return escape ? cmJoin(cmMakeRange(arg).transform(EscapeArg), ";")
: cmJoin(cmMakeRange(arg), ";");
} | subq $0x28, %rsp
leaq 0x8(%rsp), %rax
testl %ecx, %ecx
je 0x1c41a2
movq %rsi, (%rax)
leaq 0x48(%rip), %rcx # 0x1c41c8
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
leaq 0x3e4d54(%rip), %rcx # 0x5a8ee7
movl $0x1, %edx
movq %rax, %rsi
callq 0x17284e
jmp 0x1c41c3
movq %rsi, (%rax)
movq %rdx, 0... | /JKorbelRA[P]CMake/Source/cmParseArgumentsCommand.cxx |
EscapeArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string EscapeArg(const std::string& arg)
{
// replace ";" with "\;" so output argument lists will split correctly
std::string escapedArg;
for (char i : arg) {
if (i == ';') {
escapedArg += '\\';
}
escapedArg += i;
}
return escapedArg;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
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 0x8(%rsi), %r14
testq %r14, %r14
je 0x1c4223
movq (%rsi), %r12
xorl %r13d, %r13d
movb (%r12,%r13), %bpl
cmpb $0x3b, %bpl
jne 0x1c420f
movq ... | /JKorbelRA[P]CMake/Source/cmParseArgumentsCommand.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoin<cmRange<std::_Rb_tree_const_iterator<std::basic_string_view<char, std::char_traits<char>>>>>(cmRange<std::_Rb_tree_const_iterator<std::basic_string_view<char, std::char_traits<char>>>> const&, std::basic_string_view<char, std::char_tr... | std::string cmJoin(Range const& rng, cm::string_view separator)
{
if (rng.empty()) {
return std::string();
}
std::ostringstream os;
auto it = rng.begin();
auto const end = rng.end();
os << *it;
while (++it != end) {
os << separator << *it;
}
return os.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x1c43a9
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rsp, %rdi
callq 0x3b3d0
movq (%r13), %r12
movq 0x8(%r13), %rbp
movq 0x20(%r12), %rdx
movq ... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
bool cmArgumentParser<void>::Bind<bool>(std::basic_string_view<char, std::char_traits<char>>, bool&) | bool Bind(cm::string_view name, T& ref)
{
return this->MaybeBind(name,
[&ref](Instance& instance) { instance.Bind(ref); });
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x174(%rip), %rcx # 0x1c460a
movq %rcx, 0x18(%rax)
leaq 0x177(%rip), %rcx # 0x1c4618
movq %rcx, 0x10(%rax)
movq %rax, %rcx
callq 0x1443a4
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1c44c6
movq %rsp, %rdi... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
bool cmArgumentParser<void>::Bind<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool Bind(cm::string_view name, T& ref)
{
return this->MaybeBind(name,
[&ref](Instance& instance) { instance.Bind(ref); });
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x1dc(%rip), %rcx # 0x1c4834
movq %rcx, 0x18(%rax)
leaq 0x1df(%rip), %rcx # 0x1c4842
movq %rcx, 0x10(%rax)
movq %rax, %rcx
callq 0x1443a4
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1c4688
movq %rsp, %rdi... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
bool cmArgumentParser<void>::Bind<ArgumentParser::NonEmpty<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::basic_string_view<char, std::char_traits<char>>, ArgumentParser::N... | bool Bind(cm::string_view name, T& ref)
{
return this->MaybeBind(name,
[&ref](Instance& instance) { instance.Bind(ref); });
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x29c(%rip), %rcx # 0x1c4b1e
movq %rcx, 0x18(%rax)
leaq 0x29f(%rip), %rcx # 0x1c4b2c
movq %rcx, 0x10(%rax)
movq %rax, %rcx
callq 0x1443a4
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1c48b2
movq %rsp, %rdi... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
cmProjectCommand(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>>>> const&, cmExecutionStatus&) | bool cmProjectCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("PROJECT called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
if (!IncludeByVariable(status, "CMAKE_PROJECT_I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rsi, %rbx
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x1c4da4
movq %rdi, %r13
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0xa0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3fa01c(%rip), %rsi # 0x5bed03
leaq... | /JKorbelRA[P]CMake/Source/cmProjectCommand.cxx |
IncludeByVariable(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool IncludeByVariable(cmExecutionStatus& status,
const std::string& variable)
{
cmMakefile& mf = status.GetMakefile();
cmValue include = mf.GetDefinition(variable);
if (!include) {
return true;
}
std::string includeFile =
cmSystemTools::CollapseFullPath(*include,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, %rdi
callq 0x9d080
testq %rax, %rax
je 0x1c73fc
movq %rax, %r14
movq %r15, %rdi
callq 0x9f030
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3f9728
movq %r12, %rdi
callq 0x... | /JKorbelRA[P]CMake/Source/cmProjectCommand.cxx |
TopLevelCMakeVarCondSet(cmMakefile&, 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&) | static void TopLevelCMakeVarCondSet(cmMakefile& mf, std::string const& name,
std::string const& value)
{
// Set the CMAKE_PROJECT_XXX variable to be the highest-level
// project name in the tree. If there are two project commands
// in the same CMakeLists.txt file, and it is th... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9d080
testq %rax, %rax
je 0x1c7573
movq %r14, %rdi
callq 0xa3e84
testb %al, %al
je 0x1c75a1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa690c
movq (%r15), %rdx
leaq 0x3f77a7(%rip), %rcx # 0x5bed2f
movq %r14, %rdi
movq %rbx, %rsi
mov... | /JKorbelRA[P]CMake/Source/cmProjectCommand.cxx |
cmQTWrapCPPCommand(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>>>> const&, cmExecutionStatus&) | bool cmQTWrapCPPCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
// Get the moc executable to run in the custom ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
leaq 0x40(%rsp), %r12
movq %rax, 0x120(%rsp)
cmpq $0x40, %rax
jbe 0x1c8794
movq %rdi, %r15
movq (%rbx), %rbx
leaq 0x30(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x... | /JKorbelRA[P]CMake/Source/cmQTWrapCPPCommand.cxx |
cmQTWrapUICommand(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>>>> const&, cmExecutionStatus&) | bool cmQTWrapUICommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 4) {
status.SetError("called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
// Get the uic and moc executables to run in the ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %rsi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
leaq 0x60(%rsp), %r14
movq %rax, 0x170(%rsp)
cmpq $0x60, %rax
jbe 0x1c967b
movq %rdi, %r15
movq (%rbx), %rbx
leaq 0x50(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x... | /JKorbelRA[P]CMake/Source/cmQTWrapUICommand.cxx |
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>>>> cmExpandedLists<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, ... | std::vector<std::string> cmExpandedLists(InputIt first, InputIt last)
{
std::vector<std::string> argsOut;
for (; first != last; ++first) {
cmExpandList(*first, argsOut);
}
return argsOut;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rdx, %rsi
je 0x1c9c87
movq %rdx, %r14
movq %rsi, %r15
movq (%r15), %rsi
movq 0x8(%r15), %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xec0b4
addq $0x20, %r15
cmpq %r14, %r15
jne 0x1c9c6d
movq %rbx, %rax
po... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmReturnCommand(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>>>> const&, cmExecutionStatus&) | bool cmReturnCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (!args.empty()) {
switch (status.GetMakefile().GetPolicyStatus(cmPolicies::CMP0140)) {
case cmPolicies::WARN:
status.GetMakefile().IssueMessage(
MessageType::AUTHOR_WARNING,
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x1c9dd5
movq %rdi, %r15
movq (%r14), %rdi
movl $0x8c, %esi
xorl %edx, %edx
callq 0x9ccf8
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1c9dee
movb $0x1, %bl
testl %eax, %eax
je 0x1c9f3b
cmpl $0x1, %eax
jne 0x1c9e88... | /JKorbelRA[P]CMake/Source/cmReturnCommand.cxx |
cmSearchPath::ExtractWithout(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>> const&, std::se... | void cmSearchPath::ExtractWithout(const std::set<std::string>& ignorePaths,
const std::set<std::string>& ignorePrefixes,
std::vector<std::string>& outPaths,
bool clear) const
{
if (clear) {
outPaths.clear();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
testl %r8d, %r8d
je 0x1ca05b
movq (%rsp), %rdi
movq (%rdi), %rsi
callq 0x9a1e8
movq 0x8(%r13), %r12
movq 0x10(%r13), %r13
cmpq %r13, %r12
je 0x1ca0a7
leaq 0x8(%r15), %rbp
leaq 0... | /JKorbelRA[P]CMake/Source/cmSearchPath.cxx |
cmSearchPath::AddPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmSearchPath::AddPath(const std::string& path)
{
this->AddPathInternal(path, "");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x442db1(%rip), %rdx # 0x60ce89
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x5b4c6
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1ca... | /JKorbelRA[P]CMake/Source/cmSearchPath.cxx |
cmSearchPath::AddPathInternal(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&, char const*) | void cmSearchPath::AddPathInternal(const std::string& path,
const std::string& prefix, const char* base)
{
assert(this->FC != nullptr);
std::string collapsedPath = cmSystemTools::CollapseFullPath(path, base);
if (collapsedPath.empty()) {
return;
}
std::string collapse... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpq $0x0, (%rdi)
je 0x1ca301
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rdx
callq 0x3f9684
cmpq $0x0, 0x8(%r12)
je 0x1ca2d7
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (... | /JKorbelRA[P]CMake/Source/cmSearchPath.cxx |
cmSearchPath::AddUserPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmSearchPath::AddUserPath(const std::string& path)
{
assert(this->FC != nullptr);
std::vector<std::string> outPaths;
cmWindowsRegistry registry(*this->FC->Makefile,
cmWindowsRegistry::SimpleTypes);
auto expandedPaths = registry.ExpandExpression(path, this->FC->RegistryView);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x1ca4e9
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x170(%rax), %rsi
leaq 0x5c50c0(%rip), %rdx # 0x78f470
leaq 0x78(%rsp), %rdi
callq 0... | /JKorbelRA[P]CMake/Source/cmSearchPath.cxx |
cmSearchPath::AddCMakePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmSearchPath::AddCMakePath(const std::string& variable)
{
assert(this->FC != nullptr);
// Get a path from a CMake variable.
if (cmValue value = this->FC->Makefile->GetDefinition(variable)) {
std::vector<std::string> expanded = cmExpandedList(*value);
for (std::string const& p : expanded) {
th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x1ca649
movq %rdi, %rbx
movq 0x170(%rax), %rdi
callq 0x9d080
testq %rax, %rax
je 0x1ca63a
movq (%rax), %rdx
movq 0x8(%rax), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xec293
m... | /JKorbelRA[P]CMake/Source/cmSearchPath.cxx |
cmSearchPath::AddSuffixes(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>>>> const&) | void cmSearchPath::AddSuffixes(const std::vector<std::string>& suffixes)
{
std::vector<PathWithPrefix> inPaths;
inPaths.swap(this->Paths);
this->Paths.reserve(inPaths.size() * (suffixes.size() + 1));
for (PathWithPrefix& inPath : inPaths) {
cmSystemTools::ConvertToUnixSlashes(inPath.Path);
cmSystemTool... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r8
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rdi), %rcx
movq %rcx, 0x28(%rsp)
movq 0x18(%rdi), %rdx
movq %rdx, 0x30(%rsp)
subq %rax, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, ... | /JKorbelRA[P]CMake/Source/cmSearchPath.cxx |
cmSearchPath::PathWithPrefix::operator<(cmSearchPath::PathWithPrefix const&) const | bool operator<(const PathWithPrefix& other) const
{
return this->Path < other.Path ||
(this->Path == other.Path && this->Prefix < other.Prefix);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x392d0
testl %eax, %eax
js 0x1cb7c9
movq 0x8(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x1cb7c5
testq %rdx, %rdx
je 0x1cb7cd
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x3a8a0
testl %eax, %eax
je 0x1cb7cd
xorl %eax, %eax
jmp 0x1cb7e3
movb $0x1, %al
jmp 0... | /JKorbelRA[P]CMake/Source/cmSearchPath.h |
cmSeparateArgumentsCommand(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>>>> const&, cmExecutionStatus&) | bool cmSeparateArgumentsCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("must be given at least one argument.");
return false;
}
std::string const& var = args.front();
if (args.size() == 1) {
// Original... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
cmpq %rax, %r14
je 0x1cba6e
subq %r14, %rax
cmpq $0x20, %rax
jne 0x1cbab9
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x9d080
movb $0x1, %bpl
testq %rax, %rax
j... | /JKorbelRA[P]CMake/Source/cmSeparateArgumentsCommand.cxx |
cmArgumentParser<cmSeparateArgumentsCommand(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>>>> const&, cmExecutionStatus&)::Arguments>& cmArgumentParser<cmSeparateArgumentsCommand(std... | cmArgumentParser& Bind(cm::static_string_view name, T Result::*member)
{
this->Base::Bind(name, [member](Instance& instance) {
instance.Bind(static_cast<Result*>(instance.Result)->*member);
});
return *this;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0xcd(%rip), %rcx # 0x1cc3d8
movq %rcx, 0x18(%rax)
leaq 0xd4(%rip), %rcx # 0x1cc3ea
movq %rcx, 0x10(%rax)
movq %rax, %rcx
callq 0x1442f4
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1cc339
movq %rsp, %rdi... | /JKorbelRA[P]CMake/Source/cmArgumentParser.h |
cmSetCommand(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>>>> const&, cmExecutionStatus&) | bool cmSetCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
// watch for ENV signatures
auto const& variable = args[0]; // VAR is always first
if (cmHasLiteralP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
cmpq 0x8(%rdi), %r15
je 0x1cc56a
movq %rdi, %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
leaq 0x3d12c4(%rip), %r8 # 0x59d712
movl $0x4, %ed... | /JKorbelRA[P]CMake/Source/cmSetCommand.cxx |
cmSetDirectoryPropertiesCommand(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>>>> const&, cmExecutionStatus&) | bool cmSetDirectoryPropertiesCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
// PROPERTIES followed by prop value pairs
if (args.size() % 2 !... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rax
cmpq %rax, %r15
je 0x1ccc9b
movl %eax, %ecx
subl %r15d, %ecx
testb $0x20, %cl
jne 0x1cccf7
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f2bdc(%rip), %rsi # 0x5bf853
leaq 0... | /JKorbelRA[P]CMake/Source/cmSetDirectoryPropertiesCommand.cxx |
SetPropertyCommand::HandleSourceFileDirectoryScopes(cmExecutionStatus&, 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::char_tra... | bool HandleSourceFileDirectoryScopes(
cmExecutionStatus& status, std::vector<std::string>& source_file_directories,
std::vector<std::string>& source_file_target_directories,
std::vector<cmMakefile*>& directory_makefiles)
{
std::unordered_set<cmMakefile*> directory_makefiles_set;
cmMakefile* current_dir_mf = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, 0x58(%rsp)
leaq 0xd0(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq %rdi, 0... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
SetPropertyCommand::HandleSourceFileDirectoryScopeValidation(cmExecutionStatus&, bool, bool, 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_strin... | bool HandleSourceFileDirectoryScopeValidation(
cmExecutionStatus& status, bool source_file_directory_option_enabled,
bool source_file_target_option_enabled,
std::vector<std::string>& source_file_directories,
std::vector<std::string>& source_file_target_directories)
{
// Validate source file directory scopes.
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x1cd2a0
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x1cd2e7
movb $0x1, %al
testb %dl, %dl
je 0x1cd332
movq (%r8), %rcx
cmpq 0x8(%r8), %rcx
jne 0x1cd332
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f270f(%rip), %rsi # 0x5bf9d2
leaq 0x3... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
SetPropertyCommand::MakeSourceFilePathAbsoluteIfNeeded(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string MakeSourceFilePathAbsoluteIfNeeded(
cmExecutionStatus& status, const std::string& source_file_path,
const bool needed)
{
if (!needed) {
return source_file_path;
}
std::string absolute_file_path = cmSystemTools::CollapseFullPath(
source_file_path, status.GetMakefile().GetCurrentSourceDirect... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testl %ecx, %ecx
je 0x1cd3d2
movq (%rsi), %rdi
callq 0x9f030
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3f9728
jmp 0x1cd3eb
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
SetPropertyCommand::MakeSourceFilePathsAbsoluteIfNeeded(cmExecutionStatus&, 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>>>>&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_strin... | void MakeSourceFilePathsAbsoluteIfNeeded(
cmExecutionStatus& status,
std::vector<std::string>& source_files_absolute_paths,
std::vector<std::string>::const_iterator files_it_begin,
std::vector<std::string>::const_iterator files_it_end, const bool needed)
{
// Make the file paths absolute, so that relative so... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rsi
subq %rdx, %rsi
sarq $0x5, %rsi
movq %r15, %rdi
callq 0x5ad16
testl %ebp, %ebp
je 0x1cd489
cmpq %rbx, %r14
je 0x1cd47a
leaq 0x18(%rsp), %rbp
... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
SetPropertyCommand::HandleAndValidateSourceFilePropertyGENERATED(cmSourceFile*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, SetPropertyCommand::PropertyOp) | bool HandleAndValidateSourceFilePropertyGENERATED(
cmSourceFile* sf, std::string const& propertyValue, PropertyOp op)
{
const auto& mf = *sf->GetLocation().GetMakefile();
auto policyStatus = mf.GetPolicyStatus(cmPolicies::CMP0118);
const bool policyWARN = policyStatus == cmPolicies::WARN;
const bool policyNE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd7410
movq (%rax), %r15
movq %r15, %rdi
movl $0x76, %esi
xorl %edx, %edx
callq 0x9ccf8
testl %eax, %eax
je 0x1cd710
cmpl $0x1, %eax
jne 0x1cd760
movq (%r14), %rsi
movq 0x8(%r14), %rdi
callq 0x... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
cmSetPropertyCommand(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>>>> const&, cmExecutionStatus&) | bool cmSetPropertyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
// Get the scope on which to set the property.
std::string const& scopeName = args.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
subq %r14, %rax
cmpq $0x20, %rax
ja 0x1cda87
leaq 0x90(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3e9384(%rip), %rsi # 0x5b6dbf
leaq 0x3e93a6(%rip), %rdx ... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleGlobalMode(cmExecutionStatus&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::all... | bool HandleGlobalMode(cmExecutionStatus& status,
const std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
if (!names.empty()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r12
testq %rsi, %rsi
je 0x1ce39c
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3f1a08(%rip), %rsi # 0x5bfd68
leaq 0x3f1a1e(%rip), %rdx # 0x5bfd85
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5b4c6
... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleDirectoryMode(cmExecutionStatus&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::... | bool HandleDirectoryMode(cmExecutionStatus& status,
const std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
if (names.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
cmpq $0x2, %rdx
jb 0x1ce486
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f1940(%rip), %rsi # 0x5bfd86
leaq 0x3f1965(%rip), %rdx # 0x5bfdb2
leaq 0x8(%rsp), %rdi
callq 0x5b4c6
addq $0x8, %r15
leaq 0x8(%rsp), %... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleTargetMode(cmExecutionStatus&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::all... | bool HandleTargetMode(cmExecutionStatus& status,
const std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
for (std::string const& n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movq %rsi, %r13
movq 0x18(%rsi), %rbp
addq $0x8, %r13
movb $0x1, %al
cmpq %r13, %rbp
je 0x1ce7de
movq %rdx, %r12
movq %rdi, %rbx
movzbl %r8b, %eax
movl %eax, (%rsp)
leaq 0x20(%rbp), %r14
movq (%r... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleSourceMode(cmExecutionStatus&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::all... | bool HandleSourceMode(cmExecutionStatus& status,
const std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove,
const s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x18(%rsi), %rax
leaq 0x8(%rsi), %rdx
leaq 0x50(%rsp), %rdi
leaq 0x88(%rsp), %rcx... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleTestMode(cmExecutionStatus&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | bool HandleTestMode(cmExecutionStatus& status, std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
// Look for tests with all names given.
std::set<std::strin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
movq 0x18(%rsi), %r13
leaq 0x8(%rsi), %rbx
cmpq %rbx, %r13
je 0x1ceb62
movl %r9d, %ebp
movq %rdx, %r12
movzbl %r8b, %eax
movl %eax, 0xc(%rsp)
movq %r13... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
(anonymous namespace)::HandleInstallMode(cmExecutionStatus&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | bool HandleInstallMode(cmExecutionStatus& status,
const std::set<std::string>& names,
const std::string& propertyName,
const std::string& propertyValue, bool appendAsString,
bool appendMode, bool remove)
{
cmake* cm = status.G... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r14d
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x9c6b4
movq %rax, %r13
movq 0x18(%r12), %rbp
addq $0x8, %r12
movb $0x1, %al
cmpq %r12, %rbp
je 0x1cf13b
... | /JKorbelRA[P]CMake/Source/cmSetPropertyCommand.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmStrCat<char [77]>(cmAlphaNum const&, cmAlphaNum const&, char const (&) [77]) | inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movq %rsp, %r15
movups %xmm0, (%r15)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%r15)
movq %rcx, %rdi
callq 0x39d50
movq %rax, 0x20(%r15)
movq %rbx, 0x28(%r15)
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xec4e... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.h |
cmSetSourceFilesPropertiesCommand(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>>>> const&, cmExecutionStatus&) | bool cmSetSourceFilesPropertiesCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
// break the arguments into source file names and propertie... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, 0x28(%rsp)
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rsi
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x20, %rax
ja 0x1cf60a
leaq 0x70(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3e77f7(%rip), %rsi ... | /JKorbelRA[P]CMake/Source/cmSetSourceFilesPropertiesCommand.cxx |
cmSetTargetPropertiesCommand(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>>>> const&, cmExecutionStatus&) | bool cmSetTargetPropertiesCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("called with incorrect number of arguments");
return false;
}
// first identify the properties arguments
auto propsIter = std::fi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x20, %rax
ja 0x1d029a
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3e6b4c(%rip), %rsi # 0x5b6dbf
leaq 0x3e6b6e(%rip),... | /JKorbelRA[P]CMake/Source/cmSetTargetPropertiesCommand.cxx |
checkSingleParameterArgumentPreconditions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::alloc... | static bool checkSingleParameterArgumentPreconditions(
const std::string& argument, const ParsedArguments& parsedArguments,
std::string& errorMsg)
{
auto foundArgument = parsedArguments.find(argument);
if (foundArgument != parsedArguments.end()) {
const std::vector<std::string>& optionArguments = foundArgum... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x1d1e68
movq %rax, %rcx
addq $0x8, %r15
movb $0x1, %al
cmpq %r15, %rcx
je 0x1d1da9
movq 0x40(%rcx), %rdx
movq 0x48(%rcx), %rcx
cmpq %rcx, %rdx
je 0x1d1d01
subq %rdx, %rcx
cmpq $0x21, ... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
cmStringReplaceHelper::cmStringReplaceHelper(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>>, cmMakefile*) | cmStringReplaceHelper::cmStringReplaceHelper(const std::string& regex,
std::string replace_expr,
cmMakefile* makefile)
: RegExString(regex)
, RegularExpression(regex)
, ReplaceExpression(std::move(replace_expr))
, Makefile... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x8(%rsp)
mov... | /JKorbelRA[P]CMake/Source/cmStringReplaceHelper.cxx |
cmStringReplaceHelper::Replace(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>>&) | bool cmStringReplaceHelper::Replace(const std::string& input,
std::string& output)
{
output.clear();
// Scan through the input for all matches.
std::string::size_type base = 0;
while (this->RegularExpression.find(input.c_str() + base)) {
if (this->Makefile != nullptr) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
leaq 0x40(%rdi), %rbp
movq (%rsi), %rsi
movq %rbp, %rdi
movq %rbp, %rdx
callq 0x3f4802
xorl %r13d, %r13d
t... | /JKorbelRA[P]CMake/Source/cmStringReplaceHelper.cxx |
cmStringCommand(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>>>> const&, cmExecutionStatus&) | bool cmStringCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("must be called with at least one argument.");
return false;
}
static cmSubcommandTable const subcommand{
{ "REGEX"_s, HandleRegexCommand },
{ "REPLACE"... | pushq %r14
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rsi, %rbx
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x1d31f5
movq %rdi, %r14
movb 0x5b9f15(%rip), %al # 0x78d0e8
testb %al, %al
je 0x1d3246
movq (%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rsi
leaq 0x5b9ee8(%rip), %rdi # 0x78d0d0
movq %r1... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleRegexCommand(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>>>> const&, cmExecutionStatus&) | bool HandleRegexCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("sub-command REGEX requires a mode to be specified.");
return false;
}
std::string const& mode = args[1];
if (mode == "MATCH") {
if (args.size() <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %r13
movq (%rdi), %r15
movq 0x8(%rdi), %rax
subq %r15, %rax
cmpq $0x20, %rax
ja 0x1d379f
leaq 0xd0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3ecbdc(%rip), %rsi # 0x5c0320
leaq 0x3ecc07(%rip), %rdx ... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleTimestampCommand(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>>>> const&, cmExecutionStatus&) | bool HandleTimestampCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("sub-command TIMESTAMP requires at least one argument.");
return false;
}
if (args.size() > 4) {
status.SetError("sub-command TIMESTAMP take... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
subq %r14, %rax
movq %rax, %rcx
sarq $0x5, %rcx
leaq 0x18(%rsp), %r13
cmpq $0x1, %rcx
ja 0x1d651b
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x3ea554(%rip), %rsi # 0x5c0a50
leaq ... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleGenexStripCommand(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>>>> const&, cmExecutionStatus&) | bool HandleGenexStripCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("sub-command GENEX_STRIP requires two arguments.");
return false;
}
const std::string& input = args[1];
std::string result = cmGeneratorE... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %r12
subq %rsi, %r12
cmpq $0x60, %r12
jne 0x1d6906
movq %rdi, %r14
addq $0x20, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cd9a8
movq (%r14), %rsi
addq $0x40, %rsi
movq (... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleUuidCommand(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>>>> const&, cmExecutionStatus&) | bool HandleUuidCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if !defined(CMAKE_BOOTSTRAP)
unsigned int argsIndex = 1;
if (args.size() < 2) {
status.SetError("UUID sub-command requires an output variable.");
return false;
}
const std::string& outputV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
leaq 0x68(%rsp), %r14
cmpq $0x20, %rax
ja 0x1d69f1
leaq 0x58(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x3ea16b(%rip), %rsi # 0x5c0b21
leaq 0x3ea191(%rip), %rdx # 0x5c... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleJSONCommand(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>>>> const&, cmExecutionStatus&) | bool HandleJSONCommand(std::vector<std::string> const& arguments,
cmExecutionStatus& status)
{
#if !defined(CMAKE_BOOTSTRAP)
auto& makefile = status.GetMakefile();
Args args{ arguments.begin() + 1, arguments.end() };
const std::string* errorVariable = nullptr;
const std::string* outputV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %rbx
movq (%rsi), %rax
movq %rax, 0x30(%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq $0x20, %rax
leaq 0x38(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
leaq 0x3e9ac6(%rip), %rdx # 0x5c0c6... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleToUpperLowerCommand(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>>>> const&, bool, cmExecutionStatus&) | bool HandleToUpperLowerCommand(std::vector<std::string> const& args,
bool toUpper, cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("no output variable specified");
return false;
}
std::string const& outvar = args[2];
std::string output;
if (toUpper)... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rsi, %rbx
subq %rdi, %rbx
cmpq $0x40, %rbx
jbe 0x1d8023
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x20(%rdi), %rsi
testb %dl, %dl
je 0x1d807c
leaq 0x20(%rsp), %rd... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::joinImpl(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>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsig... | bool joinImpl(std::vector<std::string> const& args, std::string const& glue,
const size_t varIdx, cmMakefile& makefile)
{
std::string const& variableName = args[varIdx];
// NOTE Items to concat/join placed right after the variable for
// both `CONCAT` and `JOIN` sub-commands.
std::string value = c... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %r9, %rbx
movq %rdx, %rax
shlq $0x5, %r8
leaq (%rdi,%r8), %r14
addq %r8, %rdi
addq $0x20, %rdi
leaq 0x20(%rsp), %rdx
movq %rdi, (%rdx)
movq %rsi, 0x8(%rdx)
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::json_error::json_error(std::initializer_list<std::basic_string_view<char, std::char_traits<char>>>, std::optional<(anonymous namespace)::Args>) | json_error(std::initializer_list<cm::string_view> message,
cm::optional<Args> errorPath = cm::nullopt)
: std::runtime_error(cmCatViews(message))
, ErrorPath{
std::move(errorPath) // NOLINT(performance-move-const-arg)
}
{
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xec4ec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x397e0
leaq 0x40(%rsp), %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d8280
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x39320
leaq 0x5a00a1(%rip), %rax ... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::ReadJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Json::Value ReadJson(const std::string& jsonstr)
{
Json::CharReaderBuilder builder;
builder["collectComments"] = false;
auto jsonReader = std::unique_ptr<Json::CharReader>(builder.newCharReader());
Json::Value json;
std::string error;
if (!jsonReader->parse(jsonstr.data(), jsonstr.data() + jsonstr.size(),
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x80(%rsp), %rdi
callq 0x459de0
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x45d570
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3e8be1(%rip), %rsi # 0x5c0ee8
leaq 0x3e8be9(%rip), %rdx # 0x5c0ef7
l... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::WriteJson[abi:cxx11](Json::Value const&) | std::string WriteJson(const Json::Value& value)
{
Json::StreamWriterBuilder writer;
writer["indentation"] = " ";
writer["commentStyle"] = "None";
return Json::writeString(writer, value);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %rdi
callq 0x465a04
leaq 0x3de4a6(%rip), %rsi # 0x5b6c77
leaq 0x28(%rsp), %rdi
callq 0x45d264
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3c3ec7(%rip), %rsi # 0x59c6b2
leaq 0x3c3ecb(%rip), %rdx # 0x59c6bd... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::ParseIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::optional<(anonymous namespace)::Args> const&, unsigned int) | int ParseIndex(
const std::string& str, cm::optional<Args> const& progress = cm::nullopt,
Json::ArrayIndex max = std::numeric_limits<Json::ArrayIndex>::max())
{
unsigned long lindex;
if (!cmStrToULong(str, &lindex)) {
throw json_error({ "expected an array index, got: '"_s, str, "'"_s },
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %rsi
callq 0xec677
testb %al, %al
je 0x1d8ac4
movl 0x18(%rsp), %eax
cmpl %ebp, %eax
jae 0x1d8b3d
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %e... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cmJoin<(anonymous namespace)::Args>((anonymous namespace)::Args const&, std::basic_string_view<char, std::char_traits<char>>) | std::string cmJoin(Range const& rng, cm::string_view separator)
{
if (rng.empty()) {
return std::string();
}
std::ostringstream os;
auto it = rng.begin();
auto const end = rng.end();
os << *it;
while (++it != end) {
os << separator << *it;
}
return os.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x1d8c9e
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rsp, %rdi
callq 0x3b3d0
movq (%r12), %rbp
movq 0x8(%r12), %r13
movq (%rbp), %rsi
movq 0x8(... | /JKorbelRA[P]CMake/Source/cmStringAlgorithms.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.