name string | code string | asm string | file string |
|---|---|---|---|
antlr::NoViableAltException::NoViableAltException(antlr::TokenRefCount<antlr::Token>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | NoViableAltException::NoViableAltException(
RefToken t,
const ANTLR_USE_NAMESPACE(std)string& fileName_
) : RecognitionException("NoViableAlt",fileName_,t->getLine(),t->getColumn()),
token(t), node(nullASTptr)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x74879(%rip), %rsi # 0xc8c1b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1a8b4
movq (%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%r14), %rax
movq (%rax... | /OpenMD[P]OpenMD/src/antlr/NoViableAltException.cpp |
antlr::Parser::reportWarning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Parser::reportWarning(const ANTLR_USE_NAMESPACE(std)string& s)
{
if ( getFilename()=="" )
ANTLR_USE_NAMESPACE(std)cerr << "warning: " << s.c_str() << ANTLR_USE_NAMESPACE(std)endl;
else
ANTLR_USE_NAMESPACE(std)cerr << getFilename().c_str() << ": warning: " << s.c_str() << ANTLR_USE_NAMESPACE(std)endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x40(%rax)
leaq 0x7c63c(%rip), %rsi # 0xd0eea
movq %r15, %rdi
callq 0x2251c
movl %eax, %ebp
movq %r15, %rdi
callq 0x13a98
testb %bpl, %bpl
je 0x5... | /OpenMD[P]OpenMD/src/antlr/Parser.cpp |
antlr::Parser::traceIn(char const*) | void Parser::traceIn(const char* rname)
{
traceDepth++;
for( int i = 0; i < traceDepth; i++ )
ANTLR_USE_NAMESPACE(std)cout << " ";
ANTLR_USE_NAMESPACE(std)cout << "> " << rname
<< "; LA(1)==" << LT(1)->getText().c_str()
<< ((inputState->guessing>0)?" [guessing]":"")
<< ANTLR_USE_NAMESPACE(std)endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rdi), %eax
incl %eax
movl %eax, 0x18(%rdi)
xorl %ebp, %ebp
movq 0xc95f9(%rip), %r15 # 0x11dfb0
leaq 0x7565f(%rip), %r12 # 0xca01d
cmpl %eax, %ebp
jge 0x549d4
movq %r15, %rdi
movq %r12, %rsi
callq 0... | /OpenMD[P]OpenMD/src/antlr/Parser.cpp |
antlr::RecognitionException::RecognitionException() | RecognitionException::RecognitionException()
: ANTLRException("parsing error")
, line(-1)
, column(-1)
{
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x74140(%rip), %rsi # 0xc8d09
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1a8b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3239a
leaq 0x8(%rsp), %rdi
callq 0x13a98
leaq 0xc6031(%rip), %rax # 0x11ac28
movq %rax, (%rbx)
leaq 0x38(%rbx)... | /OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp |
antlr::RecognitionException::RecognitionException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | RecognitionException::RecognitionException(const ANTLR_USE_NAMESPACE(std)string& s)
: ANTLRException(s)
, line(-1)
, column(-1)
{
} | pushq %rbx
movq %rdi, %rbx
callq 0x3239a
leaq 0xc5fea(%rip), %rax # 0x11ac28
movq %rax, (%rbx)
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movb $0x0, 0x38(%rbx)
orq $-0x1, 0x48(%rbx)
popq %rbx
retq
nop
| /OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp |
antlr::RecognitionException::getFileLineColumnString[abi:cxx11]() const | string RecognitionException::getFileLineColumnString() const
{
ANTLR_USE_NAMESPACE(std)string fileLineColumnString;
if ( fileName.length() > 0 )
fileLineColumnString = fileName + ":";
if ( line != -1 )
{
if ( fileName.length() == 0 )
fileLineColumnString = fileLineColumnString + "line ";
fileLineColumnS... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
cmpq $0x0, 0x30(%rsi)
je 0x54cfd
leaq 0x28(%r14), %rsi
leaq 0x75312(%rip), %rdx # 0xc9ff1
movq %rsp, %rdi
callq 0x1a87c
movq %rsp, %r15
movq %rbx, %rdi... | /OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp |
antlr::RecognitionException::toString[abi:cxx11]() const | string RecognitionException::toString() const
{
return getFileLineColumnString()+getMessage();
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *0x38(%rax)
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x18(%rax)
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1aa36
leaq 0x8(%rsp), %rdi
callq 0x13a98
leaq 0x28(... | /OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp |
antlr::charName[abi:cxx11](int) | string charName(int ch)
{
if (ch == EOF)
return "EOF";
else
{
ANTLR_USE_NAMESPACE(std)string s;
// when you think you've seen it all.. an isprint that crashes...
ch = ch & 0xFF;
#ifdef ANTLR_CCTYPE_NEEDS_STD
if( ANTLR_USE_NAMESPACE(std)isprint( ch ) )
#else
if( isprint( ch ) )
#endif
{
s.append("'"... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x54fad
movl %esi, %r14d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzbl %r14b, %ebp
movl %ebp, %edi
callq 0x13970
testl %eax, %eax
je 0x54fc3
leaq 0x73b65(%rip), %rsi # 0xc8aed
movq %rbx,... | /OpenMD[P]OpenMD/src/antlr/String.cpp |
antlr::Token::toString[abi:cxx11]() const | string Token::toString() const
{
return "[\""+getText()+"\",<"+type+">]";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq *0x20(%rax)
leaq 0x7390b(%rip), %rsi # 0xc89b0
movq %rsp, %rdi
movq %r15, %rdx
callq 0x52329
leaq 0x738fc(%rip), %rdx # 0xc89b3
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
ca... | /OpenMD[P]OpenMD/src/antlr/Token.cpp |
antlr::TreeParser::reportError(antlr::RecognitionException const&) | void TreeParser::reportError(const RecognitionException& ex)
{
ANTLR_USE_NAMESPACE(std)cerr << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl;
} | pushq %rbx
subq $0x20, %rsp
movq (%rsi), %rax
movq %rsp, %rbx
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rbx), %rsi
movq 0xc8df1(%rip), %rdi # 0x11dfd8
callq 0x134b0
movq %rax, %rdi
callq 0x13250
movq %rsp, %rdi
callq 0x13a98
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13a98
movq %rbx, %rd... | /OpenMD[P]OpenMD/src/antlr/TreeParser.cpp |
OpenMD::ForceField::ForceField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | ForceField::ForceField(std::string ffName) : wildCardAtomTypeName_("X") {
char* tempPath;
tempPath = getenv("FORCE_PARAM_PATH");
if (tempPath == NULL) {
// convert a macro from compiler to a string in c++
STR_DEFINE(ffPath_, FRC_PATH);
} else {
ffPath_ = tempPath;
}
setForceF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xc590c(%rip), %rax # 0x11adc0
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rax
andl $0x0, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
andl $0x0,... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ForceField::parse(const std::string& filename) {
ifstrstream* ffStream;
ffStream = openForceFieldFile(filename);
spMan_.parse(*ffStream, *this);
ForceField::AtomTypeContainer::MapTypeIterator i;
AtomType* at;
for (at = atomTypeCont_.beginType(i); at != NULL;
at = atomTypeCont_.... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x55b92
movq %rax, %r14
leaq 0x838(%rbx), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x8d91e
movq 0x28(%rbx), %rax
movq %rax, (%rsp)
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x55af3
movq 0x40(%rax), %rsi
jmp 0x55af5
xorl %esi,... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getBendType(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BendType* ForceField::getBendType(const std::string& at1,
const std::string& at2,
const std::string& at3) {
std::vector<std::string> keys;
keys.push_back(at1);
keys.push_back(at2);
keys.push_back(at3);
// try exact match first
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x580... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getTorsionType(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_stri... | TorsionType* ForceField::getTorsionType(const std::string& at1,
const std::string& at2,
const std::string& at3,
const std::string& at4) {
std::vector<std::string> keys;
keys.push_back(at... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
leaq 0x90(%rsp), %rdi
movq %... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getInversionType(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_st... | InversionType* ForceField::getInversionType(const std::string& at1,
const std::string& at2,
const std::string& at3,
const std::string& at4) {
std::vector<std::string> keys;
k... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
leaq 0x90(%rsp), %rdi
movq %... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getNonBondedInteractionType(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&) | NonBondedInteractionType* ForceField::getNonBondedInteractionType(
const std::string& at1, const std::string& at2) {
std::vector<std::string> keys;
keys.push_back(at1);
keys.push_back(at2);
// try exact match first
NonBondedInteractionType* nbiType =
nonBondedInteractionTypeCont_.find... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x5801e
leaq 0x120(%rbx), %rdi
leaq 0x50(%rsp),... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getExactBendType(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BendType* ForceField::getExactBendType(const std::string& at1,
const std::string& at2,
const std::string& at3) {
std::vector<std::string> keys;
keys.push_back(at1);
keys.push_back(at2);
keys.push_back(at3);
return bend... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
movq %rsp, %rdi
movq %r15, %rsi
callq 0x5801e
movq %rsp, %rdi
movq %r14, %rsi
callq 0x5801e
addq $0x78, %rbx
movq %rsp, %rsi
movq ... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getExactInversionType(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::bas... | InversionType* ForceField::getExactInversionType(const std::string& at1,
const std::string& at2,
const std::string& at3,
const std::string& at4) {
std::vector<std:... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
movq %rsp, %rdi
movq %r12, %rsi
callq 0x5801e
movq %rsp, %rdi
movq %r15, %rsi
callq 0x5801e
movq %rsp, %... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::replaceAtomType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, OpenMD::AtomType*) | bool ForceField::replaceAtomType(const std::string& at, AtomType* atomType) {
std::vector<std::string> keys;
keys.push_back(at);
atypeIdentToName[atomType->getIdent()] = at;
return atomTypeCont_.replace(keys, atomType);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
movq %rbx, %rdi
callq 0x9ca92
leaq 0x808(%r14), %rdi
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
callq 0x58f02
movq %rax, %rdi
mo... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::addTorsionType(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_stri... | bool ForceField::addTorsionType(const std::string& at1,
const std::string& at2,
const std::string& at3,
const std::string& at4,
TorsionType* torsionType) {
std::vector<std::string>... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
movq %rsp, %rdi
movq %r13, %rsi
callq 0x5801e
movq %rsp, %rdi
movq %r12, %rsi
... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::addInversionType(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_st... | bool ForceField::addInversionType(const std::string& at1,
const std::string& at2,
const std::string& at3,
const std::string& at4,
InversionType* inversionType) {
std::vecto... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5801e
movq %rsp, %rdi
movq %r13, %rsi
callq 0x5801e
movq %rsp, %rdi
movq %r12, %rsi
... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getRcutFromAtomType(OpenMD::AtomType*) | RealType ForceField::getRcutFromAtomType(AtomType* at) {
RealType rcut(0.0);
LennardJonesAdapter lja = LennardJonesAdapter(at);
if (lja.isLennardJones()) { rcut = 2.5 * lja.getSigma(); }
EAMAdapter ea = EAMAdapter(at);
if (ea.isEAM()) {
switch (ea.getEAMType()) {
case eamFuncfl:
... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
leaq 0x30(%rsp), %rdi
movq %rsi, (%rdi)
callq 0xad744
xorpd %xmm0, %xmm0
testb %al, %al
je 0x57cc9
leaq 0x30(%rsp), %rdi
callq 0xad8e4
mulsd 0x710c7(%rip), %xmm0 # 0xc8d90
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
callq 0xa2094
testb %al, %al
j... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::TypeContainer<OpenMD::AtomType, 1>::find(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>>>>&) | ElemPtr find(KeyType& keys) {
assert(keys.size() == SIZE);
MapTypeIterator i;
i = data_.find(keys);
if (i != data_.end()) { return (i->second).second; }
KeyType reversedKeys = keys;
std::reverse(reversedKeys.begin(), reversedKeys.end());
i = data_.find(reversedKeys);
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x59b24
movq %rax, %rbx
addq $0x10, %r12
cmpq %r12, %rax
je 0x58079
movq 0x40(%rbx), %rbx
jmp 0x580b5
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5816a
movq (%r12), %rdi
mo... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::TypeContainer<OpenMD::BondType, 2>::find(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>>>>&) | ElemPtr find(KeyType& keys) {
assert(keys.size() == SIZE);
MapTypeIterator i;
i = data_.find(keys);
if (i != data_.end()) { return (i->second).second; }
KeyType reversedKeys = keys;
std::reverse(reversedKeys.begin(), reversedKeys.end());
i = data_.find(reversedKeys);
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x59c9c
movq %rax, %rbx
addq $0x10, %r12
cmpq %r12, %rax
je 0x58109
movq 0x40(%rbx), %rbx
jmp 0x58145
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5816a
movq (%r12), %rdi
mo... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::TypeContainer<OpenMD::BondType, 2>::find(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> co... | ElemPtr find(KeyType& keys, const std::string& wildCard) {
assert(keys.size() == SIZE);
std::vector<KeyTypeIterator> iterCont;
KeyType replacedKey;
MapTypeIterator i;
std::vector<ValueType> foundTypes;
while (replaceWithWildCard(iterCont, keys, replacedKey, wildCard)) {
i =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
leaq 0x60(%rsp), %rbp
andq $0x0, 0x10(%rbp)
leaq 0x10(%rsp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%r... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::TypeContainer<OpenMD::BendType, 3>::find(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>>>>&) | ElemPtr find(KeyType& keys) {
assert(keys.size() == SIZE);
MapTypeIterator i;
i = data_.find(keys);
if (i != data_.end()) { return (i->second).second; }
KeyType reversedKeys = keys;
std::reverse(reversedKeys.begin(), reversedKeys.end());
i = data_.find(reversedKeys);
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x5acb2
movq %rax, %rbx
addq $0x10, %r12
cmpq %r12, %rax
je 0x5841d
movq 0x40(%rbx), %rbx
jmp 0x58459
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5816a
movq (%r12), %rdi
mo... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint,... | inline OrParamConstraint<Cons1T, Cons2T> operator||(
const ParamConstraintFacade<Cons1T>& cons1,
const ParamConstraintFacade<Cons2T>& cons2) {
return OrParamConstraint<Cons1T, Cons2T>(
*static_cast<const Cons1T*>(&cons1),
*static_cast<const Cons2T*>(&cons2));
} | pushq %r14
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x87516
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x71656
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x87570
leaq 0x8(%rsp), %rdi
callq 0x70cc6
leaq 0x48(%rsp), %rdi
callq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
Parameter<unsigned long>::setData(unsigned long) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | movb $0x0, 0x2a(%rdi)
movq %rsi, 0x30(%rdi)
movb $0x1, %al
retq
nop
| /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
ParameterTraits<std::pair<int, int>>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<int, int>&) | static bool convert(std::string v, RepType& r) {
OpenMD::StringTokenizer tokenizer(v, " ;,\t\n\r");
if (tokenizer.countTokens() == 2) {
int atom1 = tokenizer.nextTokenAsInt();
int atom2 = tokenizer.nextTokenAsInt();
r = std::make_pair(atom1, atom2);
return true;
} else {
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x46337(%rip), %rsi # 0xcc9dd
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1a8b4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0xb9030
leaq 0x8(%rsp), %rdi
callq 0x13a98
leaq 0x28(%rsp), %rdi
callq 0xb912e... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x13700
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x86916
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0x13a98
testb %bpl, %bpl
je 0x868e3
movb $0x0, 0x2a(%rbx)
addq $0x30, %... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<int>(int) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x1b586
xorl %eax, %eax
addq $0x18, %rsp
retq
| /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<double>(double) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x1b586
xorl %eax, %eax
addq $0x18, %rsp
retq
| /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<std::pair<int, int>>(std::pair<int, int>) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x1b586
xorl %eax, %eax
addq $0x18, %rsp
retq
| /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4a99a
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x4b5ae
leaq 0x18(%rsp), %rdi
callq 0x1b586
movb $0x0, 0x2a(%rbx)
addq $0x30, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4b5ae
movq ... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCa... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r12
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x86ce2
leaq 0x240(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x716... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseCo... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r12
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x87372
leaq 0x3c0(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x716... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::Polynomial<double>::evaluateDerivative(double const&) | Real evaluateDerivative(const Real& x) {
Real result = Real();
ExponentType exponent;
CoefficientType coefficient;
for (iterator i = polyPairMap_.begin(); i != polyPairMap_.end(); ++i) {
exponent = i->first;
coefficient = i->second;
result += fastpow(x, exponent - 1) ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpq %r14, %r15
je 0x9f48c
movl 0x20(%r15), %r12d
movsd 0x28(%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rbx), %xmm0
leal -0x1(%r12), %edi
callq 0... | /OpenMD[P]OpenMD/src/math/Polynomial.hpp |
OpenMD::ShiftedMieBondType::~ShiftedMieBondType() | ShiftedMieBondType(RealType mySigma, RealType myEpsilon, int myNrep,
int myMatt) :
BondType(0.0) {
sigma = mySigma;
epsilon = myEpsilon;
n = myNrep;
m = myMatt;
rS_ = exp(log(pow(sigma, m - n) * RealType(m) / n));
nmScale_ = n * pow(Real... | pushq $0x40
popq %rsi
jmp 0x134e0
| /OpenMD[P]OpenMD/src/types/ShiftedMieBondType.hpp |
OpenMD::BondStamp::BondStamp() | BondStamp::BondStamp() : hasOverride_(false) {
DefineOptionalParameterWithDefaultValue(BondOrder, "bondOrder", 1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x4b318
leaq 0x7cf86(%rip), %rax # 0x11cbe0
movq %rax, (%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
xorl %eax, %eax
movb %al, 0x80(%rbx)
andw $0x0, 0x90(%rbx)
movb $0x1, 0x92(%rbx)
leaq 0x7ba9d(%rip), %rcx... | /OpenMD[P]OpenMD/src/types/BondStamp.cpp |
OpenMD::BondTypeParser::BondTypeParser() | BondTypeParser::BondTypeParser() {
stringToEnumMap_["Fixed"] = btFixed;
stringToEnumMap_["Harmonic"] = btHarmonic;
stringToEnumMap_["Cubic"] = btCubic;
stringToEnumMap_["Quartic"] = btQuartic;
stringToEnumMap_["Polynomial"] = btPolynomial;
stringToEnumMap_["Morse"] = btMorse;... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x27a58(%rip), %rsi # 0xc7aa5
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1a8b4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
cal... | /OpenMD[P]OpenMD/src/types/BondTypeParser.cpp |
OpenMD::BondTypeParser::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double) | BondType* BondTypeParser::parseLine(const std::string& line,
RealType kScale) {
StringTokenizer tokenizer(line);
BondType* bondType = NULL;
int nTokens = tokenizer.countTokens();
if (nTokens < 1) {
throw OpenMDException("BondTypeParser: Not enough toke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x24db5(%rip), %rsi # 0xc5085
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1a8b4
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movq %rbx, %rsi
callq 0xb9030
leaq 0x18(%rsp), %rdi
c... | /OpenMD[P]OpenMD/src/types/BondTypeParser.cpp |
OpenMD::QuarticBondType::calcForce(double, double&, double&) | virtual void calcForce(RealType r, RealType& V, RealType& dVdr) {
RealType dr = r - r0;
RealType dr2 = dr * dr;
RealType dr3 = dr2 * dr;
RealType dr4 = dr3 * dr;
V = k0_ + k1_ * dr + k2_ * dr2 + k3_ * dr3 + k4_ * dr4;
dVdr = k1_ + 2.0 * k2_ * dr + 3.0 * k3_ * dr2 + 4.0 * k4_ * d... | subsd 0x8(%rdi), %xmm0
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm0, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm0, %xmm3
movsd 0x28(%rdi), %xmm4
mulsd %xmm0, %xmm4
addsd 0x30(%rdi), %xmm4
mulsd %xmm1, %xmm3
movsd 0x20(%rdi), %xmm5
mulsd %xmm2, %xmm5
addsd %xmm4, %xmm5
movsd 0x18(%rdi), %xmm4
mulsd %xmm1, %xmm4
mulsd 0x... | /OpenMD[P]OpenMD/src/types/QuarticBondType.hpp |
OpenMD::MorseBondType::calcForce(double, double&, double&) | virtual void calcForce(RealType r, RealType& V, RealType& dVdr) {
RealType dr, eterm, eterm2;
dr = r - r0;
eterm = exp(-beta * dr);
eterm2 = eterm * eterm;
V = De * (1 - 2.0 * eterm + eterm2);
dVdr = 2.0 * De * beta * (eterm - eterm2);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
subsd 0x8(%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
xorpd 0x25e80(%rip), %xmm1 # 0xc6b40
mulsd %xmm1, %xmm0
callq 0x13980
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
movsd 0x2433f(%rip), %xmm3 # 0xc5020
s... | /OpenMD[P]OpenMD/src/types/MorseBondType.hpp |
OpenMD::Component::Component() | Component::Component() : moleculeStamp_(NULL) {
DefineParameter(Type, "type");
DefineParameter(NMol, "nMol");
DefineParameter(Region, "region");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x4b318
leaq 0x7bc33(%rip), %rax # 0x11cd48
movq %rax, (%rbx)
leaq 0x68(%rbx), %r14
movq %r14, %rdi
callq 0x70946
leaq 0xd0(%rbx), %rax
movq %rax, 0xc0(%rbx)
andq $0x0, 0xc8(%rbx)
xorl %eax, %eax
movb %al, 0xd0(... | /OpenMD[P]OpenMD/src/types/Component.cpp |
OpenMD::Component::validate() | void Component::validate() {
CheckParameter(Type, isNotEmpty());
CheckParameter(NMol, isPositive());
CheckParameter(Region, isNonNegative());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x92(%rdi)
movabsq $0x100000001, %r13 # imm = 0x100000001
jne 0xa154d
leaq 0x28(%rsp), %rdi
callq 0x8d130
leaq 0x98(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x13700
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %r14
... | /OpenMD[P]OpenMD/src/types/Component.cpp |
OpenMD::Component::findMoleculeStamp(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, OpenMD::MoleculeStamp*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char... | bool Component::findMoleculeStamp(
const std::map<std::string, MoleculeStamp*>& molStamps) {
bool ret = false;
std::map<std::string, MoleculeStamp*>::const_iterator i;
i = molStamps.find(getType());
if (i != molStamps.end()) {
moleculeStamp_ = i->second;
ret = true;
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x98(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x13700
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa1714
movq %rax, %r15
movq %rsp, %rdi
callq 0x13a98
addq $0x8, %rbx
cmpq %rbx, %r15
je 0xa16f1
movq 0x40(%r15), %rax
movq %rax, 0x... | /OpenMD[P]OpenMD/src/types/Component.cpp |
OpenMD::ConstraintStamp::ConstraintStamp() | ConstraintStamp::ConstraintStamp() {
DefineParameter(ConstrainedDistance, "constrainedDistance");
DefineOptionalParameterWithDefaultValue(PrintConstraintForce,
"printConstraintForce", false);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x4b318
leaq 0x7b5df(%rip), %rax # 0x11cd88
movq %rax, (%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
leaq 0x68(%rbx), %r14
xorl %eax, %eax
movb %al, 0x80(%rbx)
andw $0x0, 0x90(%rbx)
mo... | /OpenMD[P]OpenMD/src/types/ConstraintStamp.cpp |
OpenMD::ConstraintStamp::validate() | void ConstraintStamp::validate() {
DataHolder::validate();
CheckParameter(ConstrainedDistance, isNonNegative());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x4b392
cmpb $0x0, 0x92(%rbx)
jne 0xa1af3
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x8d18d
movsd 0x98(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x13a98
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0xa1af3
mo... | /OpenMD[P]OpenMD/src/types/ConstraintStamp.cpp |
OpenMD::DirectionalAdapter::makeDirectional(OpenMD::SquareMatrix3<double>) | void DirectionalAdapter::makeDirectional(Mat3x3d I) {
if (isDirectional()) { at_->removeProperty(DirectionalTypeID); }
DirectionalAtypeParameters directionalParam {};
directionalParam.I = I;
at_->addProperty(std::make_shared<DirectionalAtypeData>(DirectionalTypeID,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa1bd8
testb %al, %al
je 0xa1dcb
movq (%rbx), %rdi
leaq 0x81722(%rip), %rsi # 0x1234e8
callq 0x9c8dc
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1e636
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e688
movq (%rbx), %r12... | /OpenMD[P]OpenMD/src/types/DirectionalAdapter.cpp |
OpenMD::EAMAdapter::getEAMParam() | EAMParameters EAMAdapter::getEAMParam() {
if (!isEAM()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"EAMAdapter::getEAMParam was passed an atomType (%s)\n"
"\tthat does not appear to be an EAM atom.\n",
at_->getName().c_str());
painCave.severity = O... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xa2094
movabsq $0x100000001, %r13 # imm = 0x100000001
testb %al, %al
jne 0xa2112
movq (%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9caa0
movq (%r15), %rcx
leaq 0x7cfbd(%rip),... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::getFuncflParam() | FuncflParameters EAMAdapter::getFuncflParam() {
if (!isEAM()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"EAMAdapter::getFuncflParam was passed an atomType (%s)\n"
"\tthat does not appear to be an EAM atom.\n",
at_->getName().c_str());
painCave.sev... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xa2094
movabsq $0x100000001, %r13 # imm = 0x100000001
testb %al, %al
jne 0xa22a0
movq (%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9caa0
movq (%r15), %rcx
leaq 0x7ce2f(%rip),... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::getZhouParam() | ZhouParameters EAMAdapter::getZhouParam() {
if (!isEAM()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"EAMAdapter::getZhouParam was passed an atomType (%s)\n"
"\tthat does not appear to be an EAM atom.\n",
at_->getName().c_str());
painCave.severity ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xa2094
movabsq $0x100000001, %r13 # imm = 0x100000001
testb %al, %al
jne 0xa242e
movq (%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9caa0
movq (%r15), %rcx
leaq 0x7cca1(%rip),... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::makeFuncfl(double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double, int, double, double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>) | void EAMAdapter::makeFuncfl(RealType latticeConstant, std::string latticeType,
int nrho, RealType drho, int nr, RealType dr,
RealType rcut, vector<RealType> Z,
vector<RealType> rho, vector<RealType> F) {
if (isEAM()) {
a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %r15
movq %r8, %r12
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movl %ecx, %ebp
movsd %xmm1, 0x10(%rsp)
movl %edx, %r13d
movq %rsi, %rbx
movsd %xmm0, 0x28(%rsp)
movq %rdi, %r14
callq 0xa2094
testb ... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::makeZhou2004(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double, double, double, double, double, double, double, double, double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, double, double, double, double) | void EAMAdapter::makeZhou2004(std::string latticeType, RealType re,
RealType fe, RealType rhoe, RealType rhos,
RealType alpha, RealType beta, RealType A,
RealType B, RealType kappa, RealType lambda,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, %r15
movq %rdx, %r12
movsd %xmm7, 0x48(%rsp)
movsd %xmm6, 0x40(%rsp)
movsd %xmm5, 0x38(%rsp)
movsd %xmm4, 0x30(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm0... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::EAMAdapter::makeZhou2005Oxygen(double, double, double, double, double, double, double, double, double, double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<doub... | void EAMAdapter::makeZhou2005Oxygen(RealType re, RealType fe, RealType alpha,
RealType beta, RealType A, RealType B,
RealType kappa, RealType lambda,
RealType gamma, RealType nu,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movsd %xmm7, 0x58(%rsp)
movsd %xmm6, 0x50(%rsp)
movsd %xmm5, 0x48(%rsp)
movsd %xmm4, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, ... | /OpenMD[P]OpenMD/src/types/EAMAdapter.cpp |
OpenMD::FixedChargeAdapter::getFixedChargeParam() | FixedChargeAtypeParameters FixedChargeAdapter::getFixedChargeParam() {
if (!isFixedCharge()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"FixedChargeAdapter::getFixedChargeParam was passed an atomType "
"(%s)\n"
"\tthat does not appear to be a fixed charg... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0xa50c4
movabsq $0x100000001, %r12 # imm = 0x100000001
testb %al, %al
jne 0xa5139
movq (%rbx), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x9caa0
movq (%r14), %rcx
leaq 0x79f95(%rip), %r15 # 0x11f0a4
leaq 0x2a1cf(%rip), %r... | /OpenMD[P]OpenMD/src/types/FixedChargeAdapter.cpp |
OpenMD::FixedChargeAdapter::makeFixedCharge(double) | void FixedChargeAdapter::makeFixedCharge(RealType charge) {
if (isFixedCharge()) { at_->removeProperty(FCtypeID); }
FixedChargeAtypeParameters fcParam {};
fcParam.charge = charge;
at_->addProperty(std::make_shared<FixedChargeAtypeData>(FCtypeID, fcParam));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xa50c4
testb %al, %al
je 0xa5288
movq (%rbx), %rdi
leaq 0x7e305(%rip), %rsi # 0x123588
callq 0x9c8dc
leaq 0x38(%rsp), %rdx
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rdx)
movq (%rbx), %r15
leaq 0x7e2e7(%rip), %rsi # 0x123... | /OpenMD[P]OpenMD/src/types/FixedChargeAdapter.cpp |
OpenMD::FluctuatingChargeAdapter::getFluctuatingChargeParam() | FluctuatingAtypeParameters
FluctuatingChargeAdapter::getFluctuatingChargeParam() {
if (!isFluctuatingCharge()) {
snprintf(
painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"FluctuatingChargeAdapter::getFluctuatingChargeParam was passed an "
"atomType "
"(%s)\n"
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xa5534
movabsq $0x100000001, %r13 # imm = 0x100000001
testb %al, %al
jne 0xa55b2
movq (%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9caa0
movq (%r15), %rcx
leaq 0x79b1d(%rip),... | /OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp |
OpenMD::FluctuatingChargeAdapter::makeFluctuatingCharge(double, double, double, int, double) | void FluctuatingChargeAdapter::makeFluctuatingCharge(
RealType chargeMass, RealType electronegativity, RealType hardness,
int slaterN, RealType slaterZeta) {
if (isFluctuatingCharge()) { at_->removeProperty(FQtypeID); }
FluctuatingAtypeParameters fqParam {};
fqParam.chargeMass = c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movsd %xmm3, 0x20(%rsp)
movl %esi, %ebp
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %r14
movsd %xmm1, 0x18(%rsp)
movsd %xmm1, 0x28(%rsp)
callq 0xa5534
testb %al, %al
je 0xa5946
movq (%r14), %rdi
leaq 0x7dc6f(%rip), %rsi # 0x1235b0... | /OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp |
OpenMD::FluctuatingChargeAdapter::makeFluctuatingCharge(double, double, OpenMD::Polynomial<double>) | void FluctuatingChargeAdapter::makeFluctuatingCharge(RealType chargeMass,
RealType nValence,
DoublePolynomial vs) {
if (isFluctuatingCharge()) { at_->removeProperty(FQtypeID); }
FluctuatingAtypeParamet... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %r14
callq 0xa5534
testb %al, %al
je 0xa5aab
movq (%r14), %rdi
leaq 0x7db0a(%rip), %rsi # 0x1235b0
callq 0x9c8dc
leaq 0x78(%rsp), %rbx
andq $0x0, -0x8(%rbx)
leaq 0x80(%rsp), %rax
andl $... | /OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp |
OpenMD::FluctuatingChargeAdapter::makeFluctuatingCharge(double, double, double, OpenMD::Polynomial<double>) | void FluctuatingChargeAdapter::makeFluctuatingCharge(RealType chargeMass,
RealType nValence,
RealType nMobile,
DoublePolynomial vs) {
if (isFluctuating... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
callq 0xa5534
testb %al, %al
je 0xa5bda
movq (%r14), %rdi
leaq 0x7d9db(%rip), %rsi # 0x1235b0
callq 0x9c8dc
leaq 0x88(%rsp), %rbx
andq $0x0, -0x8(%rbx)
... | /OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp |
OpenMD::InversionTypeParser::parseTypeAndPars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>) | InversionType* InversionTypeParser::parseTypeAndPars(
const std::string& type, std::vector<RealType> pars) {
std::string line(type);
std::vector<RealType>::iterator it;
for (it = pars.begin(); it != pars.end(); ++it) {
line.append("\t");
line.append(std::to_string(*it));
}
return... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x13700
movq (%r14), %rbp
leaq 0x243a4(%rip), %r12 # 0xd0ee9
leaq 0x28(%rsp), %r13
cmpq 0x8(%r14), %rbp
je 0xacb81
movq %r15, %rdi
movq %r12, %rsi
callq 0x13a... | /OpenMD[P]OpenMD/src/types/InversionTypeParser.cpp |
OpenMD::InversionTypeParser::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | InversionType* InversionTypeParser::parseLine(const std::string& line) {
StringTokenizer tokenizer(line);
InversionType* inversionType = NULL;
int nTokens = tokenizer.countTokens();
if (nTokens < 1) {
throw OpenMDException("InversionTypeParser: Not enough tokens");
}
InversionTypeEnum i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18493(%rip), %rsi # 0xc5085
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
callq 0x1a8b4
leaq 0x48(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0xb9030
movq %rsp, %rdi
callq 0x13a98
leaq 0x48(%rsp), %rdi
callq... | /OpenMD[P]OpenMD/src/types/InversionTypeParser.cpp |
OpenMD::AmberImproperTorsionType::AmberImproperTorsionType(double) | AmberImproperTorsionType(RealType v2) : PolynomialInversionType(), v2_(v2) {
// convert AmberImproper Torsion Type to Polynomial Inversion type
RealType c0 = v2;
RealType c2 = -v2;
setCoefficient(0, c0);
setCoefficient(2, c2);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x701f1(%rip), %rax # 0x11d290
movq %rax, (%rdi)
movsd %xmm0, 0x38(%rdi)
xorl %esi, %esi
movaps %xmm0, (%rsp)
callq 0xad0e4
... | /OpenMD[P]OpenMD/src/types/AmberImproperTorsionType.hpp |
OpenMD::MoleculeStamp::~MoleculeStamp() | MoleculeStamp::~MoleculeStamp() {
Utils::deletePointers(atomStamps_);
Utils::deletePointers(bondStamps_);
Utils::deletePointers(bendStamps_);
Utils::deletePointers(torsionStamps_);
Utils::deletePointers(inversionStamps_);
Utils::deletePointers(rigidBodyStamps_);
Utils::deletePointers(cutoffG... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x6f2fc(%rip), %rax # 0x11d400
movq %rax, (%rdi)
addq $0xe8, %rdi
movq %rdi, 0x20(%rsp)
callq 0xa9c7a
leaq 0x118(%rbx), %rdi
movq %rdi, 0x18(%rsp)
callq 0xa9ca6
leaq 0x130(%rbx), %rdi
movq %rdi, 0x10(%rsp)
callq ... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::validate() | void MoleculeStamp::validate() {
DataHolder::validate();
atom2Rigidbody.resize(getNAtoms());
// A negative number means the atom is a free atom, and does not
// belong to rigidbody. Every element in atom2Rigidbody has unique
// negative number at the very beginning
for (unsigned int i = 0; i ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x4b392
leaq 0x1d8(%rbx), %r14
movq 0xf0(%rbx), %rsi
subq 0xe8(%rbx), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x27cda
movq 0x1d8(%rbx), %rax
movq 0x1e0(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
xorl %esi, %esi
pushq $-0x1
popq %rdx
... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkAtoms() | void MoleculeStamp::checkAtoms() {
std::vector<AtomStamp*>::iterator ai = std::find(
atomStamps_.begin(), atomStamps_.end(), static_cast<AtomStamp*>(NULL));
if (ai != atomStamps_.end()) {
std::ostringstream oss;
oss << "Error in Molecule " << getName() << ": atom["
<< ai - atomStam... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movq 0xe8(%rdi), %rdi
movq 0xf0(%rbx), %rsi
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
callq 0xab22f
cmpq 0xf0(%rbx), %rax
jne 0xae705
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
re... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkBonds() | void MoleculeStamp::checkBonds() {
std::ostringstream oss;
// make sure index is not out of range
int natoms = static_cast<int>(getNAtoms());
for (std::size_t i = 0; i < getNBonds(); ++i) {
BondStamp* bondStamp = getBondStamp(i);
if (bondStamp->getA() > natoms - 1 || bondStamp->getA() < 0 ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
movabsq $0x100000000, %r13 # imm = 0x100000000
leaq 0x60(%rsp), %rdi
callq 0x136e0
movq 0xf0(%rbx), %rdx
subq 0xe8(%rbx), %rdx
movq 0x118(%rbx), %rax
shrq $0x3, %rdx
movq %rbx, (%rsp)
movq 0... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::fillBondInfo() | void MoleculeStamp::fillBondInfo() {
for (std::size_t i = 0; i < getNBonds(); ++i) {
BondStamp* bondStamp = getBondStamp(i);
int a = bondStamp->getA();
int b = bondStamp->getB();
AtomStamp* atomA = getAtomStamp(a);
AtomStamp* atomB = getAtomStamp(b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rdi, (%rsp)
movq 0x118(%rdi), %rax
movq 0x120(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jae 0xaed83
movq %rbx, %rcx
sarq $0x1d, %rcx
movq (%rax,%rcx), %rax
movslq 0xa0(%rax), %r15
movsl... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkTorsions() | void MoleculeStamp::checkTorsions() {
std::ostringstream oss;
for (std::size_t i = 0; i < getNTorsions(); ++i) {
TorsionStamp* torsionStamp = getTorsionStamp(i);
std::vector<int> torsionAtoms = torsionStamp->getMembers();
std::vector<int>::iterator j =
std::find_if(torsionAtoms.be... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rdi, %r12
leaq 0xd0(%rsp), %rdi
callq 0x136e0
xorl %r13d, %r13d
leaq 0x58(%rsp), %rbx
leaq 0xc0(%rsp), %r14
leaq 0xb8(%rsp), %r15
xorl %ebp, %ebp
movq %r12, (%rsp)
movq 0x148(%r12), %rax
movq 0x150(%r12), ... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkInversions() | void MoleculeStamp::checkInversions() {
std::ostringstream oss;
// first we automatically find the other three atoms that
// are satellites of an inversion center:
for (std::size_t i = 0; i < getNInversions(); ++i) {
InversionStamp* inversionStamp = getInversionStamp(i);
int center ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdi, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x136e0
xorl %r15d, %r15d
movq %rsp, %r14
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r15
jae 0xb05f1
mov... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkCutoffGroups() | void MoleculeStamp::checkCutoffGroups() {
std::vector<AtomStamp*>::iterator ai;
std::vector<int>::iterator fai;
// add all atoms into freeAtoms_ set
for (ai = atomStamps_.begin(); ai != atomStamps_.end(); ++ai) {
freeAtoms_.push_back((*ai)->getIndex());
}
for (std::size_t i = 0; i < getN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
movq 0xe8(%rdi), %r12
leaq 0x100(%rdi), %r14
leaq 0x50(%rsp), %r15
cmpq 0xf0(%rbx), %r12
je 0xb13f1
movq (%r12), %rax
movl 0xf4(%rax), %eax
movl %eax, 0x50(%rsp)
movq %r14, %rdi
movq %r15, %rsi
c... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkFragments() | void MoleculeStamp::checkFragments() {
std::vector<FragmentStamp*>::iterator fi =
std::find(fragmentStamps_.begin(), fragmentStamps_.end(),
static_cast<FragmentStamp*>(NULL));
if (fi != fragmentStamps_.end()) {
std::ostringstream oss;
oss << "Error in Molecule " << getName(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movq 0x1a8(%rdi), %rdi
movq 0x1b0(%rbx), %rsi
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
callq 0xb22ff
cmpq 0x1b0(%rbx), %rax
jne 0xb1609
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::checkConstraints() | void MoleculeStamp::checkConstraints() {
std::ostringstream oss;
// make sure index is not out of range
int natoms = getNAtoms();
for (std::size_t i = 0; i < getNConstraints(); ++i) {
ConstraintStamp* constraintStamp = getConstraintStamp(i);
if (constraintStamp->getA() > natoms - 1 || constr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
movabsq $0x100000000, %r13 # imm = 0x100000000
leaq 0x60(%rsp), %rdi
callq 0x136e0
movq 0xf0(%rbx), %rdx
subq 0xe8(%rbx), %rdx
movq 0x1c0(%rbx), %rax
shrq $0x3, %rdx
movq %rbx, (%rsp)
movq 0... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::isBondInSameRigidBody(OpenMD::BondStamp*) | bool MoleculeStamp::isBondInSameRigidBody(BondStamp* bond) {
int rbA;
int rbB;
int consAtomA;
int consAtomB;
if (!isAtomInRigidBody(bond->getA(), rbA, consAtomA)) return false;
if (!isAtomInRigidBody(bond->getB(), rbB, consAtomB)) return false;
if (rbB == rbA)
return true;
else
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xa0(%rsi), %esi
leaq 0xc(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq 0xb1c46
testb %al, %al
je 0xb1c3c
movl 0xa4(%r14), %esi
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0xb1c46
testb %al, %al
je 0xb1c3c
movl 0x8(%rsp), %eax
cm... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
OpenMD::MoleculeStamp::isAtomInRigidBody(int, int&, int&) | bool MoleculeStamp::isAtomInRigidBody(int atomIndex, int& whichRigidBody,
int& consAtomIndex) {
whichRigidBody = -1;
consAtomIndex = -1;
if (atom2Rigidbody[atomIndex] >= 0) {
whichRigidBody = atom2Rigidbody[atomIndex];
RigidBodyStamp* rbStamp = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
orl $-0x1, (%rdx)
orl $-0x1, (%rcx)
movslq %esi, %rax
movq 0x1d8(%rdi), %rcx
movslq (%rcx,%rax,4), %rax
xorl %ebx, %ebx
testq %rax, %rax
js 0xb1cae
movl %esi, %ebp
movl %eax, (%rdx)
movq 0x178(%rdi), %rcx
movq (%rcx,%rax,8), %r15
movq 0x78(%r15), %r... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp |
bool OpenMD::MoleculeStamp::addIndexSensitiveStamp<std::vector<OpenMD::AtomStamp*, std::allocator<OpenMD::AtomStamp*>>, OpenMD::AtomStamp>(std::vector<OpenMD::AtomStamp*, std::allocator<OpenMD::AtomStamp*>>&, OpenMD::AtomStamp*) | bool addIndexSensitiveStamp(Cont& cont, T* stamp) {
// typename Cont::iterator i;
unsigned int index = stamp->getIndex();
bool ret = false;
size_t size = cont.size();
if (size >= index + 1) {
if (cont[index] != NULL) {
ret = false;
} else {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl 0xf4(%rdx), %r15d
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
leal 0x1(%r15), %edx
cmpq %rdx, %rcx
jae 0xb1e3c
negq %rcx
leaq (%r15,%rcx), %rdx
incq %rdx
leaq 0x8(%rsp), %rcx
andq $0x0, (%rc... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.hpp |
bool OpenMD::MoleculeStamp::addIndexSensitiveStamp<std::vector<OpenMD::RigidBodyStamp*, std::allocator<OpenMD::RigidBodyStamp*>>, OpenMD::RigidBodyStamp>(std::vector<OpenMD::RigidBodyStamp*, std::allocator<OpenMD::RigidBodyStamp*>>&, OpenMD::RigidBodyStamp*) | bool addIndexSensitiveStamp(Cont& cont, T* stamp) {
// typename Cont::iterator i;
unsigned int index = stamp->getIndex();
bool ret = false;
size_t size = cont.size();
if (size >= index + 1) {
if (cont[index] != NULL) {
ret = false;
} else {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl 0x68(%rdx), %r15d
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
leal 0x1(%r15), %edx
cmpq %rdx, %rcx
jae 0xb1eab
negq %rcx
leaq (%r15,%rcx), %rdx
incq %rdx
leaq 0x8(%rsp), %rcx
andq $0x0, (%rc... | /OpenMD[P]OpenMD/src/types/MoleculeStamp.hpp |
OpenMD::TorsionStamp::setMembers(std::tuple<int, int, int, int> const&) | void setMembers(const std::tuple<int, int, int, int>& tuple) {
auto [first, second, third, fourth] = tuple;
members_.push_back(first);
members_.push_back(second);
members_.push_back(third);
members_.push_back(fourth);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
leaq 0xc(%rsp), %rsi
movaps %xmm0, -0xc(%rsi)
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
addq $0x98, %rbx
movq %rbx, %rdi
callq 0x27f56
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27f56
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27f56
movq %... | /OpenMD[P]OpenMD/src/types/TorsionStamp.hpp |
OpenMD::MultipoleAdapter::getMultipoleParam() | MultipoleAtypeParameters MultipoleAdapter::getMultipoleParam() {
if (!isMultipole()) {
snprintf(
painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"MultipoleAdapter::getMultipoleParam was passed an atomType (%s)\n"
"\tthat does not appear to be a Multipole atom.\n",
at_->getNa... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb238c
movabsq $0x100000001, %r13 # imm = 0x100000001
testb %al, %al
jne 0xb240a
movq (%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9caa0
movq (%r15), %rcx
leaq 0x6ccc5(%rip),... | /OpenMD[P]OpenMD/src/types/MultipoleAdapter.cpp |
OpenMD::MultipoleAdapter::makeMultipole(OpenMD::Vector3<double>, OpenMD::SquareMatrix3<double>, bool, bool) | void MultipoleAdapter::makeMultipole(Vector3d dipole, Mat3x3d quadrupole,
bool isDipole, bool isQuadrupole) {
if (isMultipole()) { at_->removeProperty(MultipoleTypeID); }
MultipoleAtypeParameters multipoleParam {};
multipoleParam.dipole = dipole;
multipolePar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0xb238c
testb %al, %al
je 0xb2615
movq (%r14), %rdi
leaq 0x71218(%rip), %rsi # 0x123828
callq 0x9c8dc
leaq 0x38(%rsp), %r13
andw $0x0, -0x8(%r... | /OpenMD[P]OpenMD/src/types/MultipoleAdapter.cpp |
OpenMD::QuarticTorsionType::calcForce(double, double&, double&) | virtual void calcForce(RealType cosPhi, RealType& V, RealType& dVdcosPhi) {
RealType cosPhi2 = cosPhi * cosPhi;
RealType cosPhi3 = cosPhi2 * cosPhi;
RealType cosPhi4 = cosPhi3 * cosPhi;
V = k0_ + k1_ * cosPhi + k2_ * cosPhi2 + k3_ * cosPhi3 + k4_ * cosPhi4;
dVdcosPhi =
k1_ + 2.0... | movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm3
movsd 0x20(%rdi), %xmm4
mulsd %xmm0, %xmm4
addsd 0x28(%rdi), %xmm4
mulsd %xmm0, %xmm3
movsd 0x18(%rdi), %xmm5
mulsd %xmm2, %xmm5
addsd %xmm4, %xmm5
movsd 0x10(%rdi), %xmm4
mulsd %xmm1, %xmm4
mulsd 0x8(%rdi), %xmm3
addsd %x... | /OpenMD[P]OpenMD/src/types/QuarticTorsionType.hpp |
OpenMD::OplsTorsionType::~OplsTorsionType() | OplsTorsionType(RealType v1, RealType v2, RealType v3, bool trans180) :
PolynomialTorsionType(), v1_(v1), v2_(v2), v3_(v3) {
// convert OPLS Torsion Type to Polynomial Torsion type
RealType c0 = v2 + 0.5 * (v1 + v3);
RealType c1 = 0.5 * (v1 - 3.0 * v3);
RealType c2 = -v2;
RealType ... | pushq %rbx
movq %rdi, %rbx
callq 0xb66ee
pushq $0x50
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x134e0
nop
| /OpenMD[P]OpenMD/src/types/OplsTorsionType.hpp |
OpenMD::HarmonicTorsionType::calcForce(double, double&, double&) | virtual void calcForce(RealType cosPhi, RealType& V, RealType& dVdCosPhi) {
// check roundoff
if (cosPhi > 1.0) {
cosPhi = 1.0;
} else if (cosPhi < -1.0) {
cosPhi = -1.0;
}
RealType phi = acos(cosPhi);
RealType sinPhi = sqrt(1.0 - cosPhi * cosPhi);
// trick... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movsd 0xe8e4(%rip), %xmm2 # 0xc5020
ucomisd %xmm2, %xmm0
ja 0xb6758
movsd 0x1041e(%rip), %xmm1 # 0xc6b68
ucomisd %xmm0, %xmm1
movapd %xmm0, %xmm2
jbe 0xb6758
movapd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movapd %xmm2, ... | /OpenMD[P]OpenMD/src/types/HarmonicTorsionType.hpp |
OpenMD::UFFAdapter::getUFFParam() | UFFAtypeParameters UFFAdapter::getUFFParam() {
if (!isUFF()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"UFFAdapter::getUFFParam was passed an atomType (%s)\n"
"\tthat does not appear to be a UFF atom.\n",
at_->getName().c_str());
painCave.severity... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb6db0
movabsq $0x100000001, %r13 # imm = 0x100000001
testb %al, %al
jne 0xb6e2e
movq (%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9caa0
movq (%r15), %rcx
leaq 0x682a1(%rip),... | /OpenMD[P]OpenMD/src/types/UFFAdapter.cpp |
OpenMD::UFFAdapter::makeUFF(double, double, double, double, double, double, double, double, double, double, double) | void UFFAdapter::makeUFF(RealType r1, RealType theta0, RealType x1,
RealType D1, RealType zeta, RealType Z1, RealType Vi,
RealType Uj, RealType Xi, RealType Hard,
RealType Radius) {
if (isUFF()) { at_->removeProperty(UFFtypeID); }
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movsd %xmm7, 0x38(%rsp)
movsd %xmm6, 0x30(%rsp)
movsd %xmm5, 0x28(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xb6db0
testb %al, %al
je 0xb7104
movq (%rbx), %rdi
leaq 0x6c... | /OpenMD[P]OpenMD/src/types/UFFAdapter.cpp |
OpenMD::ZConsStamp::ZConsStamp() | ZConsStamp::ZConsStamp() {
DefineParameter(MolIndex, "molIndex");
DefineOptionalParameter(Zpos, "zPos");
DefineOptionalParameter(Kratio, "kRatio");
DefineOptionalParameter(CantVel, "cantVel");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x4b318
leaq 0x66513(%rip), %rax # 0x11d978
movq %rax, (%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
leaq 0x68(%rbx), %rax
movq %rax, 0x60(%rsp)
xorl %eax, %eax
movb %al, 0x80(%rbx)
an... | /OpenMD[P]OpenMD/src/types/ZconsStamp.cpp |
OpenMD::ElementsTable::~ElementsTable() | ElementsTable::~ElementsTable() {
std::vector<Element*>::iterator i;
for (i = elements_.begin(); i != elements_.end(); ++i)
delete *i;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x88(%rdi), %r14
movq 0x88(%rdi), %r12
cmpq 0x90(%rbx), %r12
je 0xb7a7e
movq (%r12), %r15
testq %r15, %r15
je 0xb7a6b
movq %r15, %rdi
callq 0xb85c6
movl $0xa0, %esi
movq %r15, %rdi
callq 0x134e0
addq $0x8, %r12
jmp 0xb7a51
movq %r14, %rdi
callq... | /OpenMD[P]OpenMD/src/utils/ElementsTable.cpp |
OpenMD::ElementsTable::GetName[abi:cxx11](int) | std::string ElementsTable::GetName(int atomicnum) {
if (!init_) Init();
if (atomicnum < 0 || atomicnum >= static_cast<int>(elements_.size()))
return ("Unknown");
return (elements_[atomicnum]->GetName());
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, (%rsi)
jne 0xb8215
movq %r14, %rdi
callq 0xb7d28
testl %ebp, %ebp
js 0xb8246
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebp, %ecx
jle 0xb8246
movl %ebp, %ecx
movq (%rax,%rc... | /OpenMD[P]OpenMD/src/utils/ElementsTable.cpp |
OpenMD::PropertyMap::removeProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool PropertyMap::removeProperty(const std::string& propName) {
std::map<std::string, std::shared_ptr<GenericData>>::iterator iter;
iter = propMap_.find(propName);
if (iter != propMap_.end()) {
propMap_.erase(iter);
return true;
} else {
// logger.warn("Can not find property with nam... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0xb8bda
movq %rax, %r15
addq $0x10, %rbx
cmpq %rbx, %rax
je 0xb8a3d
movq %r14, %rdi
movq %r15, %rsi
callq 0xb8e4e
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
| /OpenMD[P]OpenMD/src/utils/PropertyMap.cpp |
OpenMD::PropertyMap::getPropertyByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::shared_ptr<GenericData> PropertyMap::getPropertyByName(
const std::string& propName) {
std::map<std::string, std::shared_ptr<GenericData>>::iterator iter;
iter = propMap_.find(propName);
if (iter != propMap_.end())
return iter->second;
else
return NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0xb8bda
addq $0x10, %r14
cmpq %r14, %rax
je 0xb8b44
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28880
jmp 0xb8b4a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
pop... | /OpenMD[P]OpenMD/src/utils/PropertyMap.cpp |
OpenMD::StringTokenizer::StringTokenizer(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&) | StringTokenizer::StringTokenizer(const std::string& str,
const std::string& delim) :
tokenString_(str),
delim_(delim), returnTokens_(false), currentPos_(tokenString_.begin()),
end_(tokenString_.end()) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x13700
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x13700
movb $0x0, 0x40(%rbx)
movq (%rbx), %rax
movq %rax, 0x48(%rbx)
addq 0x8(%rbx), %rax
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x13a... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::StringTokenizer(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, std::__cxx11::basic_string<char... | StringTokenizer::StringTokenizer(std::string::const_iterator& first,
std::string::const_iterator& last,
const std::string& delim) :
tokenString_(first, last),
delim_(delim), returnTokens_(false), currentPos_(tokenString_.begin()),
e... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq (%rdx), %rdx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
callq 0xb9678
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x13700
movb $0x0, 0x40(%rbx)
movq (%rbx), %rax
movq %rax, 0x48(%rbx)
addq 0x8(%rbx), %rax
movq %rax, 0x50(%rbx)
addq $0x... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::StringTokenizer(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) | StringTokenizer::StringTokenizer(const std::string& str,
const std::string& delim,
bool returnTokens) :
tokenString_(str),
delim_(delim), returnTokens_(returnTokens),
currentPos_(tokenString_.begin()), end_(tokenString_.end()) {} | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x13700
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x13700
movb %bpl, 0x40(%rbx)
movq (%rbx), %rax
movq %rax, 0x48(%rbx)
addq 0x8(%rbx), %rax
movq %rax, 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
c... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::countTokens() | int StringTokenizer::countTokens() {
std::string::const_iterator tmpIter = currentPos_;
int numToken = 0;
while (true) {
// skip delimiter first
while (tmpIter != end_ && isDelimiter(*tmpIter)) {
++tmpIter;
if (returnTokens_) {
// if delimiter i... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
xorl %ebp, %ebp
pushq $0x1
popq %r15
movq %r14, %rax
cmpq 0x50(%rbx), %r14
je 0xb9168
movsbl (%r14), %esi
movq %rbx, %rdi
callq 0xb9118
testb %al, %al
je 0xb9164
incq %r14
movzbl 0x40(%rbx), %eax
jmp 0xb918e
movq 0x50(%rbx), %r... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::nextToken[abi:cxx11]() | std::string StringTokenizer::nextToken() {
std::string result;
if (currentPos_ != end_) {
std::insert_iterator<std::string> insertIter(result, result.begin());
while (currentPos_ != end_ && isDelimiter(*currentPos_)) {
if (returnTokens_) {
*insertIter++ = *currentPos_++;
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x48(%rsi), %rax
movq 0x50(%rsi), %rcx
cmpq %rcx, %rax
je 0xb928a
movq %rsi, %r14
movq %rbx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpq %rcx, %rax
je 0xb9274
movsbl (%rax), %esi
movq ... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::nextTokenAsBool() | bool StringTokenizer::nextTokenAsBool() {
std::string token = nextToken();
std::istringstream iss(token);
bool result;
if (iss >> result) {
return result;
} else {
std::cerr << "unable to convert " << token << " to a bool" << std::endl;
return false;
}
} | pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xb91ec
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x138c0
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x13430
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::StringTokenizer::peekNextToken[abi:cxx11]() | std::string StringTokenizer::peekNextToken() {
std::string result;
std::string::const_iterator tmpIter = currentPos_;
if (tmpIter != end_) {
std::insert_iterator<std::string> insertIter(result, result.begin());
while (tmpIter != end_ && isDelimiter(*tmpIter)) {
if (returnTokens_) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r15
movq 0x50(%rsi), %rax
cmpq %r15, %rax
je 0xb954c
movq %rsi, %r14
movq %rbx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
cmpq %rax, %r15
je 0xb9537
mov... | /OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp |
OpenMD::isEndLine(char*) | int isEndLine(char* line) {
char* working_line;
char* foo;
working_line = strdup(line);
foo = strtok(working_line, " ,;\t");
if (foo != NULL) {
if (!strcasecmp(foo, "end")) {
free(working_line);
return 1;
}
}
free(working_line);
return 0;
} | pushq %rbp
pushq %rbx
pushq %rax
callq 0x139a0
movq %rax, %rbx
leaq 0x175b1(%rip), %rsi # 0xd0ee6
movq %rax, %rdi
callq 0x137e0
testq %rax, %rax
je 0xb9955
leaq 0xe13a(%rip), %rsi # 0xc7a83
movq %rax, %rdi
callq 0x13540
testl %eax, %eax
je 0xb9959
xorl %ebp, %ebp
jmp 0xb995c
pushq $0x1
popq %rbp
movq %rbx, %rd... | /OpenMD[P]OpenMD/src/utils/StringUtils.cpp |
OpenMD::RNEMD::RNEMDParameters::requiresElectricField() | bool RNEMDParameters::requiresElectricField() {
static bool wasParsed {false};
if (!wasParsed) {
StringTokenizer tokenizer(getOutputFields(), " ,;|\t\n\r");
while (tokenizer.hasMoreTokens()) {
std::string token(tokenizer.nextToken());
toUpper(token);
if (token == "ELECTRIC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x6517d(%rip) # 0x123c40
jne 0xbebad
leaq 0x6d8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x13700
leaq 0x12682(%rip), %rsi # 0xd1163
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1a8b4
leaq 0x50(%rsp... | /OpenMD[P]OpenMD/src/rnemd/RNEMDParameters.cpp |
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.