name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
QtMWidgets::NavigationButtonPrivate::init()
|
void
NavigationButtonPrivate::init()
{
q->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
q->setAutoFillBackground( true );
q->setBackgroundRole( QPalette::Base );
baseColor = q->palette().color( QPalette::Highlight );
color = baseColor;
textColor = baseColor;
}
|
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x70000, %esi # imm = 0x70000
callq 0x5c1d0
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x5d130
movq (%rbx), %rdi
pushq $0x9
popq %rsi
callq 0x5d330
movq (%rbx), %rdi
callq 0x5cec0
pushq $0xc
popq %rsi
movq %rax, %rdi
callq 0x5f828
movq (%rax), %rcx
movq 0x6(%rax), %rdx
movq %rcx, 0x1c(%rbx)
movq %rdx, 0x22(%rbx)
movq (%rax), %rcx
movl 0x8(%rax), %edx
movzwl 0xc(%rax), %eax
movw %ax, 0x18(%rbx)
movl %edx, 0x14(%rbx)
movq %rcx, 0xc(%rbx)
movq 0x1c(%rbx), %rax
movq 0x22(%rbx), %rcx
movq %rax, 0x2c(%rbx)
movq %rcx, 0x32(%rbx)
popq %rbx
retq
|
/igormironchik[P]qtmwidgets/src/navigationbutton.cpp
|
QtMWidgets::DateTimePickerPrivate::setRange(QDateTime const&, QDateTime const&)
|
void
DateTimePickerPrivate::setRange( const QDateTime & min, const QDateTime & max )
{
if( minimum != min || maximum != max )
{
minimum = min;
maximum = max;
if( value < minimum )
value = minimum;
else if( value > maximum )
value = maximum;
fillValues();
q->updateGeometry();
q->update();
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x6be43
testb %al, %al
jne 0x6958d
leaq 0x50(%rbx), %rdi
movq %r15, %rsi
callq 0x6be43
testb %al, %al
je 0x695ff
movq %r14, %rdi
movq %r12, %rsi
callq 0x5c370
leaq 0x50(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c370
leaq 0x58(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5c730
testb %al, %al
jne 0x695cc
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c730
movq %r12, %r14
testb %al, %al
je 0x695d7
movq %r15, %rdi
movq %r14, %rsi
callq 0x5c370
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6960c
movq 0x40(%rbx), %rdi
callq 0x5c420
movq 0x40(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5c4d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/igormironchik[P]qtmwidgets/src/datetimepicker.cpp
|
QtMWidgets::DateTimePickerPrivate::normalizeOffset(int)
|
void
DateTimePickerPrivate::normalizeOffset( int section )
{
const int sectionValuesSize = sections.at( section ).values.size();
const int totalItemHeight = itemHeight + itemTopMargin;
while( qAbs( sections.at( section ).offset ) > totalItemHeight / 2 )
{
if( sections.at( section ).offset > 0 )
{
if( sectionValuesSize < itemsMaxCount &&
sections[ section ].currentIndex == 0 )
{
sections[ section ].offset = 0;
break;
}
sections[ section ].offset -= totalItemHeight;
sections[ section ].currentIndex = prevIndex(
sections.at( section ).currentIndex, sectionValuesSize );
}
else
{
if( sectionValuesSize < itemsMaxCount &&
sections[ section ].currentIndex ==
sections[ section ].values.size() - 1 )
{
sections[ section ].offset = 0;
break;
}
sections[ section ].offset += totalItemHeight;
sections[ section ].currentIndex = nextIndex(
sections.at( section ).currentIndex, sectionValuesSize );
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movslq %esi, %r14
movq 0x10(%rdi), %rcx
imulq $0x30, %r14, %r13
movl 0x68(%rdi), %eax
addl 0x64(%rdi), %eax
movl 0x20(%rcx,%r13), %r12d
pushq $0x2
popq %rsi
movl %eax, 0xc(%rsp)
cltd
idivl %esi
movl %eax, 0x14(%rsp)
leal -0x1(%r12), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rcx,%r13), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl 0x14(%rsp), %ecx
jle 0x69b06
movl 0x6c(%r15), %ecx
testl %eax, %eax
jle 0x69a8b
cmpl %r12d, %ecx
jle 0x69a66
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be6a
cmpl $0x0, 0x28(%rax)
je 0x69af7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be6a
movl 0xc(%rsp), %ecx
subl %ecx, 0x2c(%rax)
movq 0x10(%r15), %rax
movl 0x28(%rax,%r13), %ebp
testl %ebp, %ebp
cmovel %r12d, %ebp
decl %ebp
jmp 0x69ae0
cmpl %r12d, %ecx
jle 0x69ab6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be6a
movslq 0x28(%rax), %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be6a
movq 0x20(%rax), %rax
decq %rax
cmpq %rbp, %rax
je 0x69af7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be6a
movl 0xc(%rsp), %ecx
addl %ecx, 0x2c(%rax)
movq 0x10(%r15), %rax
movl 0x28(%rax,%r13), %eax
leal 0x1(%rax), %ebp
cmpl %eax, 0x10(%rsp)
movl $0x0, %eax
cmovel %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be6a
movl %ebp, 0x28(%rax)
movq 0x10(%r15), %rcx
jmp 0x69a2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be6a
andl $0x0, 0x2c(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/igormironchik[P]qtmwidgets/src/datetimepicker.cpp
|
QtMWidgets::ScrollerPrivate::ScrollerPrivate(QtMWidgets::Scroller*, QObject*)
|
ScrollerPrivate( Scroller * parent, QObject * t )
: q( parent )
, target( t )
, minVelocity( 0 )
, maxVelocity( 0 )
, startDragDistance( 0 )
, scrollingCurve( QEasingCurve::OutCirc )
, scrollTime( 3000 )
, xVelocity( 0.0 )
, yVelocity( 0.0 )
, mousePressed( false )
, maxPause( 300 )
, scrollAnimation( 0 )
, distance( 0 )
{
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
andl $0x0, 0x18(%rdi)
addq $0x20, %rdi
pushq $0x1a
popq %rsi
callq 0x5dbb0
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
andl $0x0, 0x38(%rbx)
andl $0x0, 0x3c(%rbx)
movl $0xbb8, 0x40(%rbx) # imm = 0xBB8
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movb $0x0, 0x58(%rbx)
movq $0x12c, 0x60(%rbx) # imm = 0x12C
andq $0x0, 0x68(%rbx)
andl $0x0, 0x70(%rbx)
popq %rbx
retq
nop
|
/igormironchik[P]qtmwidgets/src/scroller.cpp
|
QtMWidgets::FingerGeometry::width()
|
int
FingerGeometry::width()
{
#ifdef Q_OS_ANDROID
static const int w =
qRound( qgetenv( "QT_ANDROID_THEME_DISPLAY_DPI" ).toDouble() *
fingerSize );
return w;
#else
static const int w =
qRound(
(qreal) qMax( QApplication::primaryScreen()->logicalDotsPerInchX(),
QApplication::primaryScreen()->physicalDotsPerInchX() ) *
fingerSize );
return w;
#endif
}
|
pushq %rbx
subq $0x10, %rsp
movb 0x415bd(%rip), %al # 0xae6f8
testb %al, %al
je 0x6d14b
movl 0x415ab(%rip), %eax # 0xae6f0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x415a6(%rip), %rdi # 0xae6f8
callq 0x5d290
testl %eax, %eax
je 0x6d13f
callq 0x5d250
movq %rax, %rdi
callq 0x5cd00
movsd %xmm0, 0x8(%rsp)
callq 0x5d250
movq %rax, %rdi
callq 0x5c330
maxsd 0x8(%rsp), %xmm0
mulsd 0x1e6e7(%rip), %xmm0 # 0x8b870
movapd 0x1a21f(%rip), %xmm1 # 0x873b0
andpd %xmm0, %xmm1
orpd 0x1a223(%rip), %xmm1 # 0x873c0
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x41545(%rip) # 0xae6f0
leaq 0x41546(%rip), %rdi # 0xae6f8
callq 0x5d540
jmp 0x6d13f
jmp 0x6d1bb
movq %rax, %rbx
leaq 0x41533(%rip), %rdi # 0xae6f8
callq 0x5c510
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/fingergeometry.cpp
|
QtMWidgets::TextLabel::paintEvent(QPaintEvent*)
|
void
TextLabel::paintEvent( QPaintEvent * e )
{
QFrame::paintEvent( e );
QPainter p( this );
const QRect cr = contentsRect();
p.setClipRect( cr );
p.setPen( d->color );
int vAlign = d->staticText.textOption().alignment() & Qt::AlignVertical_Mask;
QPoint topLeft = cr.topLeft();
switch( vAlign )
{
case Qt::AlignBottom :
topLeft = QPoint( topLeft.x() + d->margin,
cr.bottomLeft().y() - qRound( d->staticText.size().height() ) -
d->margin );
break;
case Qt::AlignVCenter :
topLeft = QPoint( topLeft.x() + d->margin,
topLeft.y() + cr.height() / 2 -
qRound( d->staticText.size().height() ) / 2 );
break;
default :
{
if( d->margin != 0 )
topLeft += QPoint( d->margin, d->margin );
}
break;
}
p.drawStaticText( topLeft, d->staticText );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x5c980
leaq 0x10(%rbx), %rsi
movq %rsp, %rdi
callq 0x5da00
movq %rbx, %rdi
callq 0x5c970
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rsp, %rdi
pushq $0x1
popq %rdx
callq 0x5dcd0
movq 0x28(%rbx), %rsi
addq $0x14, %rsi
movq %rsp, %rdi
callq 0x5d7c0
movq 0x28(%rbx), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x5c360
movl $0x1e0, %ebp # imm = 0x1E0
leaq 0x8(%rsp), %r14
andl (%r14), %ebp
movq %r14, %rdi
callq 0x5d620
movq 0x20(%rsp), %r15
movq %r15, (%r14)
movq 0x28(%rbx), %rdx
movl 0x10(%rdx), %r14d
cmpl $0x40, %ebp
je 0x6e20d
movq %r15, %r12
shrq $0x20, %r12
cmpl $0x80, %ebp
jne 0x6e255
movl 0x2c(%rsp), %ebp
addq $0x8, %rdx
movq %rdx, %rdi
callq 0x5c080
subl %r12d, %ebp
incl %ebp
pushq $0x2
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %ecx
addl %r12d, %ecx
addl %r15d, %r14d
movapd 0x191d1(%rip), %xmm0 # 0x873b0
andpd %xmm1, %xmm0
orpd 0x191d5(%rip), %xmm0 # 0x873c0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
pushq $-0x2
popq %rsi
cltd
idivl %esi
addl %ecx, %eax
shlq $0x20, %rax
orq %rax, %r14
movq %r14, 0x8(%rsp)
movq 0x28(%rbx), %rdx
jmp 0x6e26a
movl 0x2c(%rsp), %r12d
addq $0x8, %rdx
movq %rdx, %rdi
callq 0x5c080
movapd 0x1918a(%rip), %xmm0 # 0x873b0
andpd %xmm1, %xmm0
orpd 0x1918e(%rip), %xmm0 # 0x873c0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl %r15d, %r14d
movq 0x28(%rbx), %rdx
addl 0x10(%rdx), %eax
subl %eax, %r12d
shlq $0x20, %r12
orq %r12, %r14
movq %r14, 0x8(%rsp)
jmp 0x6e26a
testl %r14d, %r14d
je 0x6e26a
leal (%r14,%r15), %eax
movl %eax, 0x8(%rsp)
addl %r14d, %r12d
movl %r12d, 0xc(%rsp)
addq $0x8, %rdx
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x6e334
movq %rsp, %rdi
callq 0x5cac0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e298
jmp 0x6e298
jmp 0x6e298
jmp 0x6e298
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5cac0
movq %rbx, %rdi
callq 0x5c7f0
nop
|
/igormironchik[P]qtmwidgets/src/textlabel.cpp
|
QtMWidgets::TableViewCellLayout::setGeometry(QRect const&)
|
void
TableViewCellLayout::setGeometry( const QRect & rect )
{
QLayout::setGeometry( rect );
const QMargins m = contentsMargins();
const QRect r = rect.adjusted( m.left(), m.top(), -m.right(), -m.bottom() );
int imageOffset = 0;
const QSize accessorySizeHint = accessoryWidget->sizeHint();
if( imageLabel->pixmap( Qt::ReturnByValue ).isNull() || !imageLabel->text().isEmpty() )
{
if( accessorySizeHint.isEmpty() && textLabel->text().isEmpty() &&
detailedTextLabel->text().isEmpty() )
{
imageLabel->setGeometry( r );
textLabel->setGeometry( r.x(), r.y(), 0, 0 );
detailedTextLabel->setGeometry( r.x(), r.y(), 0, 0 );
accessoryWidget->setGeometry( r.x(), r.y(), 0, 0 );
return;
}
const QSize imageSize = imageLabel->sizeHint();
imageLabel->setGeometry( r.x(), r.y(),
imageSize.width(), imageSize.height() );
imageOffset += imageSize.width() + spacing();
}
else
imageLabel->setGeometry( r.x(), r.y(), 0, 0 );
if( accessorySizeHint.isEmpty() )
{
accessoryWidget->setGeometry( r.x(), r.y(), 0, 0 );
setTextGeometry( r, imageOffset, 0 );
}
else if( textLabel->text().isEmpty() && detailedTextLabel->text().isEmpty() &&
!accessorySizeHint.isEmpty() )
{
textLabel->setGeometry( r.x(), r.y(), 0, 0 );
detailedTextLabel->setGeometry( r.x(), r.y(), 0, 0 );
const int offset = ( accessorySizeHint.height() < r.height() ?
( r.height() - accessorySizeHint.height() ) / 2 : 0 );
accessoryWidget->setGeometry( r.x() + imageOffset, r.y() + offset,
r.width() - imageOffset, r.height() - offset * 2 );
}
else if( ( !textLabel->text().isEmpty() || !detailedTextLabel->text().isEmpty() ) &&
!accessorySizeHint.isEmpty() )
{
const int offset = ( accessorySizeHint.height() < r.height() ?
( r.height() - accessorySizeHint.height() ) / 2 : 0 );
accessoryWidget->setGeometry( r.x() + r.width() -
accessorySizeHint.width(), r.y() + offset,
accessorySizeHint.width(), r.height() - offset * 2 );
setTextGeometry( r, imageOffset, accessorySizeHint.width() );
}
else
{
textLabel->setGeometry( r.x(), r.y(), 0, 0 );
detailedTextLabel->setGeometry( r.x(), r.y(), 0, 0 );
accessoryWidget->setGeometry( r.x(), r.y(), 0, 0 );
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5db20
movq %rbx, %rdi
callq 0x5da80
movq %rdx, %r8
movq %rax, %rdx
shrq $0x20, %rdx
movl %r8d, %ecx
negl %ecx
shrq $0x20, %r8
negl %r8d
movq %r14, %rdi
movl %eax, %esi
callq 0x6fc3c
movq %rax, %r15
movq %rdx, %r12
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, %rbp
movq 0x20(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5d520
movq %r14, %rdi
callq 0x5c8d0
movq %rbp, %r13
shrq $0x20, %r13
movq %r15, (%rsp)
shrq $0x20, %r15
testb %al, %al
je 0x6e610
leaq 0x10(%rsp), %rdi
callq 0x5c720
jmp 0x6e63b
movq 0x20(%rbx), %rsi
leaq 0x30(%rsp), %rdi
callq 0x5d800
leaq 0x30(%rsp), %rdi
movq 0x10(%rdi), %r14
callq 0x5edf4
leaq 0x10(%rsp), %rdi
callq 0x5c720
testq %r14, %r14
je 0x6e671
testl %ebp, %ebp
setle %al
testl %r13d, %r13d
setle %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x6e6ba
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6dc10
cmpq $0x0, 0x10(%r14)
je 0x6e68b
leaq 0x10(%rsp), %rdi
callq 0x5edf4
jmp 0x6e6ba
movq 0x20(%rbx), %rdi
xorl %r14d, %r14d
movq (%rsp), %rsi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
jmp 0x6e6f0
movq 0x30(%rbx), %rsi
leaq 0x30(%rsp), %rdi
callq 0x6dc10
leaq 0x30(%rsp), %rdi
movq 0x10(%rdi), %r14
callq 0x5edf4
leaq 0x10(%rsp), %rdi
callq 0x5edf4
testq %r14, %r14
je 0x6e8a9
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, %r14
movq %rax, %r8
shrq $0x20, %r8
movq 0x20(%rbx), %rdi
movq (%rsp), %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x6fc10
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
addl %r14d, %eax
movl %eax, %r14d
testl %ebp, %ebp
setle %al
testl %r13d, %r13d
setle %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x6e729
movq 0x38(%rbx), %rdi
movq (%rsp), %rsi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
xorl %ecx, %ecx
jmp 0x6e82a
movl %r14d, 0xc(%rsp)
movq %r12, 0x28(%rsp)
movq %r12, %r14
shrq $0x20, %r14
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x6dc10
cmpq $0x0, 0x10(%r12)
je 0x6e75f
leaq 0x10(%rsp), %rdi
callq 0x5edf4
jmp 0x6e78e
movq 0x30(%rbx), %rsi
leaq 0x30(%rsp), %rdi
callq 0x6dc10
leaq 0x30(%rsp), %rdi
movq 0x10(%rdi), %r12
callq 0x5edf4
leaq 0x10(%rsp), %rdi
callq 0x5edf4
testq %r12, %r12
je 0x6e83e
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x6dc10
cmpq $0x0, 0x10(%r12)
je 0x6e7b3
leaq 0x10(%rsp), %rdi
callq 0x5edf4
jmp 0x6e7e2
movq 0x30(%rbx), %rsi
leaq 0x30(%rsp), %rdi
callq 0x6dc10
leaq 0x30(%rsp), %rdi
movq 0x10(%rdi), %r12
callq 0x5edf4
leaq 0x10(%rsp), %rdi
callq 0x5edf4
testq %r12, %r12
je 0x6e8f1
subl %r15d, %r14d
incl %r14d
xorl %eax, %eax
movl %r14d, %ecx
subl %r13d, %ecx
jle 0x6e7fa
pushq $0x2
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
movq 0x38(%rbx), %rdi
movq 0x28(%rsp), %rsi
subl %ebp, %esi
incl %esi
addl %eax, %r15d
addl %eax, %eax
subl %eax, %r14d
movl %r15d, %edx
movl %ebp, %ecx
movl %r14d, %r8d
callq 0x6fc10
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movl 0xc(%rsp), %edx
movl %ebp, %ecx
callq 0x6e3fc
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rbx), %rdi
xorl %ebp, %ebp
movq (%rsp), %r12
movl %r12d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
movq 0x30(%rbx), %rdi
movl %r12d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
subl %r15d, %r14d
incl %r14d
movl %r14d, %eax
subl %r13d, %eax
jle 0x6e882
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
movq 0x38(%rbx), %rdi
movl 0xc(%rsp), %esi
addl (%rsp), %esi
addl %ebp, %r15d
movq 0x28(%rsp), %rcx
subl %esi, %ecx
incl %ecx
addl %ebp, %ebp
subl %ebp, %r14d
movl %r15d, %edx
movl %r14d, %r8d
jmp 0x6e92c
movq 0x20(%rbx), %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rsi
callq 0x5c790
movq 0x28(%rbx), %rdi
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
movq 0x30(%rbx), %rdi
movl (%r14), %esi
movl 0x4(%r14), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
movq 0x38(%rbx), %rdi
movl (%r14), %esi
movl 0x4(%r14), %edx
jmp 0x6e927
movq 0x28(%rbx), %rdi
movq (%rsp), %r14
movl %r14d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
movq 0x30(%rbx), %rdi
movl %r14d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
movq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fc10
jmp 0x6e82f
jmp 0x6e93a
jmp 0x6e93a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5edf4
jmp 0x6e958
jmp 0x6e94b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5c720
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/tableview.cpp
|
non-virtual thunk to QtMWidgets::TableViewCellLayout::heightForWidth(int) const
|
int
TableViewCellLayout::heightForWidth( int w ) const
{
const QSize imageSize = imageLabel->sizeHint();
const QSize accessorySize = accessoryWidget->sizeHint();
const QMargins m = contentsMargins();
const int textWidth = qMax( 10,
w - imageSize.width() - accessorySize.width() );
int height = textLabel->heightForWidth( textWidth ) +
detailedTextLabel->heightForWidth( textWidth ) + m.top() + m.bottom();
height = qMax( height, imageSize.height() + m.top() + m.bottom() );
height = qMax( height, accessorySize.height() + m.top() + m.bottom() );
return height;
}
|
addq $-0x10, %rdi
jmp 0x6e976
nop
|
/igormironchik[P]qtmwidgets/src/tableview.cpp
|
QtMWidgets::TableViewCellLayout::minimumSize() const
|
QSize
TableViewCellLayout::minimumSize() const
{
const QSize imageSize = imageLabel->minimumSizeHint();
int width = imageSize.width();
int height = imageSize.height();
const QSize textSize = textLabel->minimumSizeHint();
const QSize detailedTextSize = detailedTextLabel->minimumSizeHint();
width += qMax( textSize.width(), detailedTextSize.width() );
height = qMax( height,
textSize.height() + detailedTextSize.height() );
const QSize accessorySize = accessoryWidget->minimumSizeHint();
width += accessorySize.width();
height = qMax( height, accessorySize.height() );
return QSize( width + contentsMargins().left() + contentsMargins().right(),
height + contentsMargins().top() + contentsMargins().bottom() );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, (%rsp)
movq %rax, %r13
shrq $0x20, %r13
movq 0x28(%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, %r12
movq %rax, %rbp
shrq $0x20, %rbp
movq 0x30(%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, %rbx
movq %rax, %r14
shrq $0x20, %r14
cmpl %ebx, %r12d
cmovgl %r12d, %ebx
addl %ebp, %r14d
cmpl %r13d, %r14d
cmovlel %r13d, %r14d
movq 0x38(%r15), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq (%rsp), %rcx
leal (%rax,%rcx), %ebp
movq %rax, %r13
shrq $0x20, %r13
cmpl %r13d, %r14d
cmovgl %r14d, %r13d
movq %r15, %rdi
callq 0x5da80
movq %rax, %r12
addl %ebp, %r12d
movq %r15, %rdi
movq %r15, %rbp
callq 0x5da80
movq %rdx, %r15
addl %r12d, %r15d
addl %ebx, %r15d
movq %rbp, %rdi
callq 0x5da80
movq %rax, %r14
shrq $0x20, %r14
movq %rbp, %rdi
callq 0x5da80
shrq $0x20, %rdx
addl %edx, %r14d
addl %r13d, %r14d
shlq $0x20, %r14
orq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/igormironchik[P]qtmwidgets/src/tableview.cpp
|
QtMWidgets::MessageBoxPrivate::adjustSize()
|
void
MessageBoxPrivate::adjustSize()
{
QSize ws = QApplication::primaryScreen()->availableSize();
QSize s = q->size();
QRect wr = QApplication::primaryScreen()->availableGeometry();
if( window )
{
ws = window->size();
wr = window->rect();
}
{
int width = 0;
foreach( QAbstractButton * btn, buttons )
width += btn->sizeHint().width();
if( width > s.width() )
s = QSize( width,
textLabel->heightForWidth( width ) + title->height() +
okButton->height() + h1->height() + h2->height() );
}
qreal factor = (qreal) s.height() / (qreal) s.width();
if( factor > 1.5 )
{
const int width = qRound( (qreal) s.width() * factor );
s = QSize( width,
textLabel->heightForWidth( width ) + title->height() +
okButton->height() + h1->height() + h2->height() );
}
if( s.width() > ws.width() - screenMargin * 2 )
{
const int width = ws.width() - screenMargin * 2;
s = QSize( width,
textLabel->heightForWidth( width ) + title->height() +
okButton->height() + h1->height() + h2->height() );
}
if( s.height() > ws.height() - screenMargin * 2 )
s = QSize( s.width(), ws.height() - screenMargin * 2 );
q->resize( s );
QPoint p = QPoint( wr.x() + ( ws.width() - s.width() ) / 2,
wr.y() + ( ws.height() - s.height() ) / 2 );
if( window )
p = window->mapToGlobal( p );
q->move( p );
vbox->update();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x5d250
movq %rax, %rdi
callq 0x5d420
movq %rax, %r12
movq (%rbx), %rdi
callq 0x6860a
movq %rax, %rbp
movq %rax, (%rsp)
callq 0x5d250
movq %rax, %rdi
callq 0x5c870
movq 0x88(%rbx), %rdi
movq %rbp, %r13
shrq $0x20, %r13
testq %rdi, %rdi
je 0x71c08
callq 0x6860a
movq %rax, %r12
movq 0x88(%rbx), %rdi
callq 0x5ed0a
movq %rax, 0x8(%rsp)
movq %r12, 0x10(%rsp)
shrq $0x20, %r12
leaq 0x68(%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x7365c
xorl %r15d, %r15d
movq 0x18(%r14), %rax
cmpq 0x38(%rsp), %rax
je 0x71c51
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
addl %eax, %r15d
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
jmp 0x71c2e
leaq 0x18(%rsp), %rdi
callq 0x72a46
cmpl %ebp, %r15d
jle 0x71cd0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x80(%rax)
movl %eax, %r13d
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x20(%rax), %rax
movl 0x18(%rax), %edx
movq 0x20(%rcx), %rcx
movq 0x90(%rbx), %rsi
movq 0x20(%rsi), %rsi
movq 0x98(%rbx), %rdi
movq 0x20(%rdi), %rdi
addl 0x20(%rax), %r13d
addl 0x20(%rcx), %r13d
addl 0x20(%rsi), %r13d
addl 0x18(%rcx), %edx
addl 0x20(%rdi), %r13d
addl 0x18(%rsi), %edx
addl 0x18(%rdi), %edx
subl %edx, %r13d
addl $0x4, %r13d
movq %r13, %rax
shlq $0x20, %rax
movl %r15d, %ecx
orq %rax, %rcx
movq %rcx, (%rsp)
movl %r15d, %ebp
cvtsi2sd %r13d, %xmm0
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
ucomisd 0x1998b(%rip), %xmm0 # 0x8b670
jbe 0x71d74
mulsd %xmm1, %xmm0
movapd 0x156b9(%rip), %xmm1 # 0x873b0
andpd %xmm0, %xmm1
orpd 0x156bd(%rip), %xmm1 # 0x873c0
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebp
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x80(%rax)
movl %eax, %r13d
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x20(%rax), %rax
movl 0x18(%rax), %edx
movq 0x20(%rcx), %rcx
movq 0x90(%rbx), %rsi
movq 0x20(%rsi), %rsi
movq 0x98(%rbx), %rdi
movq 0x20(%rdi), %rdi
addl 0x20(%rax), %r13d
addl 0x20(%rcx), %r13d
addl 0x20(%rsi), %r13d
addl 0x18(%rcx), %edx
addl 0x20(%rdi), %r13d
addl 0x18(%rsi), %edx
addl 0x18(%rdi), %edx
subl %edx, %r13d
addl $0x4, %r13d
movq %r13, %rax
shlq $0x20, %rax
addq %rbp, %rax
movq %rax, (%rsp)
movl 0x80(%rbx), %eax
addl %eax, %eax
movq 0x10(%rsp), %rcx
movl %ecx, %r15d
subl %eax, %r15d
cmpl %r15d, %ebp
jle 0x71e04
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x80(%rax)
movl %eax, %r13d
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x20(%rax), %rax
movl 0x18(%rax), %edx
movq 0x20(%rcx), %rcx
movq 0x90(%rbx), %rsi
movq 0x20(%rsi), %rsi
movq 0x98(%rbx), %rdi
movq 0x20(%rdi), %rdi
addl 0x20(%rax), %r13d
addl 0x20(%rcx), %r13d
addl 0x20(%rsi), %r13d
addl 0x18(%rcx), %edx
addl 0x20(%rdi), %r13d
addl 0x18(%rsi), %edx
addl 0x18(%rdi), %edx
subl %edx, %r13d
addl $0x4, %r13d
movq %r13, %rax
shlq $0x20, %rax
movl %r15d, %ecx
orq %rax, %rcx
movq %rcx, (%rsp)
movl 0x80(%rbx), %eax
addl %eax, %eax
movl %r15d, %ebp
movl %r12d, %ecx
subl %eax, %ecx
cmpl %ecx, %r13d
jle 0x71e1b
shlq $0x20, %rcx
movl %ebp, %eax
orq %rcx, %rax
movq %rax, (%rsp)
movq (%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x5dc00
movq 0x10(%rsp), %rax
subl (%r14), %eax
pushq $0x2
popq %rsi
cltd
idivl %esi
movl %eax, %ecx
movq 0x8(%rsp), %rdi
addl %edi, %ecx
shrq $0x20, %rdi
subl 0x4(%r14), %r12d
movl %r12d, %eax
cltd
idivl %esi
addl %edi, %eax
movl %ecx, 0x18(%rsp)
movl %eax, 0x1c(%rsp)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x71e74
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x5c9a0
movq %rax, (%r14)
movq (%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5d350
movq 0x18(%rbx), %rdi
callq 0x5dc80
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x72a46
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/messagebox.cpp
|
QtMWidgets::MessageBox::MessageBox(QString const&, QString const&, QWidget*)
|
MessageBox::MessageBox( const QString & title,
const QString & text, QWidget * parent )
: QDialog( parent, Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint )
, d( new MessageBoxPrivate( title, text, this, parent ) )
{
setAttribute( Qt::WA_MacAlwaysShowToolWindow, true );
connect( d->okButton, &MsgBoxButton::clicked,
this, &MessageBox::_q_clicked );
d->adjustSize();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rsi
movl $0x40800, %edx # imm = 0x40800
callq 0x5cfb0
leaq 0x357fd(%rip), %rax # 0xa76d8
leaq 0x10(%rax), %rcx
movq %rcx, (%rbx)
addq $0x1e8, %rax # imm = 0x1E8
movq %rax, 0x10(%rbx)
movl $0xa0, %edi
callq 0x5d090
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x72556
leaq 0x28(%rbx), %r14
movq %r13, 0x28(%rbx)
pushq $0x60
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x5d870
movq 0x28(%rbx), %rax
movq 0x40(%rax), %rsi
leaq 0x80(%rip), %rax # 0x71fb2
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x39f1b(%rip), %rdx # 0xabe68
leaq 0x18(%rsp), %rdi
xorl %ecx, %ecx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x725d4
leaq 0x18(%rsp), %rdi
callq 0x5c7d0
movq (%r14), %rdi
callq 0x71ba4
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0xa0, %esi
movq %r13, %rdi
callq 0x5c190
jmp 0x71fa1
movq %rax, %r15
jmp 0x71fa1
movq %rax, %r15
movq %r14, %rdi
callq 0x72688
movq %rbx, %rdi
callq 0x5dbc0
movq %r15, %rdi
callq 0x5c7f0
nop
|
/igormironchik[P]qtmwidgets/src/messagebox.cpp
|
QtMWidgets::MessageBox::_q_clicked()
|
void
MessageBox::_q_clicked()
{
d->clickedButton = qobject_cast< QAbstractButton* > ( sender() );
ButtonRole role = d->buttonsMap[ d->clickedButton ];
switch( role )
{
case AcceptRole :
accept();
break;
case RejectRole :
reject();
break;
default :
break;
}
emit buttonClicked( d->clickedButton );
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x5cf40
movq %rax, %rdi
callq 0x727c2
movq 0x28(%rbx), %rdi
leaq 0x60(%rdi), %rsi
movq %rax, 0x60(%rdi)
addq $0x8, %rdi
callq 0x726ca
movl (%rax), %eax
testl %eax, %eax
je 0x71fea
cmpl $0x1, %eax
jne 0x71ff8
movl $0x1c0, %eax # imm = 0x1C0
jmp 0x71fef
movl $0x1b8, %eax # imm = 0x1B8
movq (%rbx), %rcx
movq %rbx, %rdi
callq *(%rcx,%rax)
movq 0x28(%rbx), %rax
movq 0x60(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x607aa
nop
|
/igormironchik[P]qtmwidgets/src/messagebox.cpp
|
QtMWidgets::MessageBox::addButton(QAbstractButton*, QtMWidgets::MessageBox::ButtonRole)
|
void
MessageBox::addButton( QAbstractButton * button, ButtonRole role )
{
if( !d->buttonsMap.contains( button ) )
{
QFrame * line = new QFrame( d->frame );
line->setFrameStyle( QFrame::VLine | QFrame::Sunken );
d->buttonSeparators.append( line );
d->buttonsMap.insert( button, role );
d->buttons.append( button );
d->hbox->addWidget( line );
d->hbox->addWidget( button );
connect( button, &QAbstractButton::clicked,
this, &MessageBox::_q_clicked );
resize( d->vbox->sizeHint() );
d->adjustSize();
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movl %edx, 0x1c(%rsp)
movq 0x28(%rdi), %rdi
addq $0x8, %rdi
movq %rax, %rsi
callq 0x72690
testb %al, %al
jne 0x72187
pushq $0x28
popq %rdi
callq 0x5d090
movq %rax, %r14
movq 0x28(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5cd20
pushq $0x35
popq %rsi
movq %r14, %rdi
callq 0x5dba0
movq 0x28(%rbx), %rdi
addq $0x48, %rdi
movq %r14, %rsi
callq 0x726b8
movq 0x28(%rbx), %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %r15
leaq 0x1c(%rsp), %rdx
movq %r15, %rsi
callq 0x7251a
movq 0x28(%rbx), %rdi
addq $0x68, %rdi
movq (%r15), %rsi
callq 0x72544
movq 0x28(%rbx), %rax
movq 0x20(%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5d0f0
movq 0x28(%rbx), %rax
movq 0x20(%rax), %rdi
movq (%r15), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5d0f0
movq (%r15), %rsi
leaq -0x174(%rip), %rax # 0x71fb2
leaq 0x30(%rsp), %r14
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq 0x39d26(%rip), %rdx # 0xabe68
leaq 0x28(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x725d4
movq %r15, %rdi
callq 0x5c7d0
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0xf0(%rax)
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5dc00
movq 0x28(%rbx), %rdi
callq 0x71ba4
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x5c190
movq %rbx, %rdi
callq 0x5c7f0
nop
|
/igormironchik[P]qtmwidgets/src/messagebox.cpp
|
QtMWidgets::darkerColor(QColor const&, int)
|
QColor
darkerColor( const QColor & c, int b )
{
if( b <= 0 )
return c;
int h = 0;
int s = 0;
int v = 0;
int a = 0;
QColor hsv = c.toHsv();
hsv.getHsv( &h, &s, &v, &a );
v -= b;
if( v < 0 )
v = 0;
hsv.setHsv( h, s, v, a );
return hsv.convertTo( c.spec() );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x744ff
movl %esi, %ebp
leaq 0x8(%rsp), %rax
andl $0x0, (%rax)
leaq 0x14(%rsp), %r12
andl $0x0, (%r12)
leaq 0x10(%rsp), %r14
andl $0x0, (%r14)
leaq 0xc(%rsp), %r13
andl $0x0, (%r13)
movq %rbx, %rdi
callq 0x5c760
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
movl %edx, 0x8(%r15)
shrq $0x20, %rdx
movw %dx, 0xc(%r15)
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x5d600
movl (%r14), %eax
subl %ebp, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, (%r14)
leaq 0x8(%rsp), %rax
movl (%rax), %esi
movl (%r12), %edx
movl (%r13), %r8d
movq %r15, %rdi
callq 0x5cb70
movl (%rbx), %esi
movq %r15, %rdi
callq 0x5cb20
movq %rdx, %rcx
movabsq $0xffffffffffff, %rdx # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
jmp 0x74506
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
|
/igormironchik[P]qtmwidgets/src/color.cpp
|
QtMWidgets::NavigationBar::setMainWidget(QString const&, QWidget*)
|
int
NavigationBar::setMainWidget( const QString & title,
QWidget * widget )
{
const int index = d->stack->addWidget( widget );
d->rootItems.append(
QSharedPointer< NavigationItem > ( new NavigationItem ) );
d->itemsMap[ widget ] = d->rootItems.back();
d->rootItems.back()->title = title;
d->rootItems.back()->self = widget;
d->stack->setCurrentIndex( index );
d->title->setText( title );
return index;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x8(%rsp)
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rdi
movq %rdx, %rsi
callq 0x5ce20
movl %eax, %ebp
movq 0x28(%r14), %r15
addq $0x10, %r15
pushq $0x40
popq %rdi
callq 0x5d090
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x76476
movq %r15, %rdi
movq %r12, %rsi
callq 0x77566
movq 0x18(%rsp), %rdi
callq 0x76b92
movq 0x28(%r14), %rdi
addq $0x10, %rdi
callq 0x77920
leaq -0x10(%rax), %r15
movq 0x28(%r14), %rdi
addq $0x28, %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x76322
movq %rax, %rdi
movq %r15, %rsi
callq 0x7647e
movq 0x28(%r14), %rdi
addq $0x10, %rdi
callq 0x77920
movq -0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x5dd90
movq (%r12), %r15
movq 0x28(%r14), %rdi
addq $0x10, %rdi
callq 0x77920
movq -0x10(%rax), %rax
movq %r15, 0x18(%rax)
movq 0x28(%r14), %rax
movq 0x8(%rax), %rdi
movl %ebp, %esi
callq 0x5d1b0
movq 0x28(%r14), %rax
movq 0x40(%rax), %rdi
movq %rbx, %rsi
callq 0x6db9e
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x76b92
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/navigationbar.cpp
|
QtMWidgets::NavigationBar::addWidget(QWidget*, QString const&, QWidget*)
|
int
NavigationBar::addWidget( QWidget * parent, const QString & title,
QWidget * widget )
{
int index = -1;
if( d->itemsMap.contains( parent ) )
{
index = d->stack->addWidget( widget );
QSharedPointer< NavigationItem > pp = d->itemsMap[ parent ];
QSharedPointer< NavigationItem > item( new NavigationItem );
item->title = title;
item->parent = pp.data();
item->self = widget;
pp->children.append( item );
d->itemsMap[ widget ] = item;
}
return index;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r15
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movq %rcx, 0x8(%rsp)
movq 0x28(%rdi), %rdi
addq $0x28, %rdi
movq %rax, %rsi
callq 0x764aa
testb %al, %al
je 0x75f48
movq 0x28(%r15), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x5ce20
movl %eax, %ebx
movq 0x28(%r15), %rdi
addq $0x28, %rdi
leaq 0x20(%rsp), %rsi
callq 0x76322
movq (%rax), %r13
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x75ebb
lock
incl (%r14)
lock
incl 0x4(%r14)
pushq $0x40
popq %rdi
callq 0x5d090
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x76476
leaq 0x10(%rsp), %rbp
movq (%rbp), %rdi
movq %r12, %rsi
callq 0x5dd90
movq (%rbp), %rax
movq %r13, 0x38(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x77996
movq 0x28(%r15), %rdi
addq $0x28, %rdi
leaq 0x8(%rsp), %rsi
callq 0x76322
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7647e
movq 0x8(%r15), %rdi
callq 0x76b92
movq %r14, %rdi
callq 0x76b92
jmp 0x75f4b
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x76b92
jmp 0x75f6e
movq %rax, %rbx
movq %r14, %rdi
callq 0x76b92
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/navigationbar.cpp
|
QtMWidgets::ToolButton::mouseReleaseEvent(QMouseEvent*)
|
void
ToolButton::mouseReleaseEvent( QMouseEvent * e )
{
if( e->button() == Qt::LeftButton )
{
if( d->leftButtonPressed )
{
d->leftButtonPressed = false;
d->action->trigger();
}
e->accept();
}
else
e->ignore();
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, 0x40(%rsi)
jne 0x79ecc
movq 0x28(%rdi), %rax
movb $0x1, %bpl
cmpb $0x1, 0x18(%rax)
jne 0x79ece
movb $0x0, 0x18(%rax)
movq 0x8(%rax), %rdi
callq 0x7b224
jmp 0x79ece
xorl %ebp, %ebp
movb %bpl, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::ToolBarLayout::spaceNeeded() const
|
int
ToolBarLayout::spaceNeeded() const
{
QSize size( 0, 0 );
foreach( QLayoutItem * item, buttons )
{
size += item->sizeHint();
size += QSize( spacing(), spacing() );
}
if( orient == Qt::Horizontal )
return size.width();
else
return size.height();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x7b370
xorl %r12d, %r12d
movq 0x18(%r14), %rax
xorl %ebp, %ebp
cmpq 0x20(%rsp), %rax
je 0x79fe8
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
movq %r14, %rcx
shrq $0x20, %rcx
addl %r14d, %r12d
addl %ecx, %ebp
addl %r15d, %r12d
addl %eax, %ebp
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x79f9f
movq %rsp, %rdi
callq 0x7b324
cmpl $0x1, 0x48(%rbx)
cmovel %r12d, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a009
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7b324
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::ToolBarLayout::indexOf(QAction*) const
|
int
ToolBarLayout::indexOf( QAction * action ) const
{
for( int i = 0; i < buttons.count(); ++i )
{
ToolButton * b = qobject_cast< ToolButton* >
( buttons.at( i )->widget() );
if( b && b->action() == action )
return i + 1;
}
return -1;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $-0x1
popq %rbx
cmpq %r12, 0x40(%r15)
jle 0x7a068
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
callq 0x7b22b
testq %rax, %rax
je 0x7a060
movq 0x28(%rax), %rax
incq %r12
cmpq %r14, 0x8(%rax)
jne 0x7a030
jmp 0x7a065
incq %r12
jmp 0x7a030
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::ToolBarLayout::setIconSize(QSize const&)
|
void
ToolBarLayout::setIconSize( const QSize & s )
{
foreach( QLayoutItem * item, buttons )
{
ToolButton * b = qobject_cast< ToolButton* >
( item->widget() );
if( b )
b->setIconSize( s );
}
update();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x7b370
movq 0x18(%r15), %rax
cmpq 0x20(%rsp), %rax
je 0x7a1d2
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
callq 0x7b22b
testq %rax, %rax
je 0x7a1c2
movq %rax, %rdi
movq %r14, %rsi
callq 0x79d06
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x7a19a
movq %rsp, %rdi
callq 0x7b324
movq %rbx, %rdi
callq 0x5dc80
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7b324
movq %rbx, %rdi
callq 0x5c7f0
nop
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::ToolBarLayout::setGeometry(QRect const&)
|
void
ToolBarLayout::setGeometry( const QRect & rect )
{
QLayout::setGeometry( rect );
const QMargins m = contentsMargins();
const QRect r = rect.adjusted( m.left(), m.top(), -m.right(), -m.bottom() );
int x = r.x();
int y = r.y();
if( !buttons.isEmpty() && left && right )
{
if( offset < 0 )
offset = 0;
QSize leftSize = left->sizeHint();
const QSize rightSize = right->sizeHint();
if( orient == Qt::Horizontal )
y = r.y() + ( r.height() - leftSize.height() ) / 2;
else
x = r.x() + ( r.width() - leftSize.width() ) / 2;
// Set left arrow geometry.
bool leftArrowShown = false;
if( offset > 0 )
{
leftArrowShown = true;
left->setGeometry( QRect( x, y, leftSize.width(), leftSize.height() ) );
if( orient == Qt::Horizontal )
x += leftSize.width() + spacing();
else
y += leftSize.height() + spacing();
}
else
{
left->setGeometry( QRect( 0, 0, 0, 0 ) );
leftSize = QSize( 0, 0 );
x = r.x();
y = r.y();
}
const QSize buttonSize = buttons.at( 0 )->sizeHint();
const int dim = ( orient == Qt::Horizontal ?
buttonSize.width() : buttonSize.height() ) + spacing();
int i = 0;
int tmpOffset = offset;
// Hide buttons that left on left arrow.
while( tmpOffset >= dim )
{
buttons.at( i )->setGeometry( QRect( 0, 0, 0, 0 ) );
++i;
tmpOffset -= dim;
}
int stop = 0;
// Show visible buttons.
if( orient == Qt::Horizontal )
{
x += offset % dim;
tmpOffset = x;
stop = ( r.width() - leftSize.width() ) / dim * dim;
y = r.y() + ( r.height() - buttonSize.height() ) / 2;
}
else
{
y += offset % dim;
tmpOffset = y;
stop = ( r.height() - leftSize.height() ) / dim * dim;
x = r.x() + ( r.width() - buttonSize.width() ) / 2;
}
int space = spaceNeeded();
if( space < ( orient == Qt::Horizontal ? r.width() : r.height() ) )
{
if( ( ( align & Qt::AlignRight ) && orient == Qt::Horizontal )
| ( ( align & Qt::AlignBottom ) && orient == Qt::Vertical ) )
{
if( orient == Qt::Horizontal )
x += r.width() - space;
else
y += r.height() - space;
}
else if( align & Qt::AlignCenter )
{
if( orient == Qt::Horizontal )
x += ( r.width() - space ) / 2;
else
y += ( r.height() - space ) / 2;
}
}
space = 0;
while( tmpOffset < stop && i < buttons.size() )
{
buttons.at( i )->setGeometry( QRect( x, y,
buttonSize.width(), buttonSize.height() ) );
if( orient == Qt::Horizontal )
{
x += dim;
space = x;
}
else
{
y += dim;
space = y;
}
tmpOffset += dim;
++i;
}
// Set right arrow geometry.
bool rightArrowShown = false;
if( i < buttons.size() )
{
if( orient == Qt::Horizontal )
{
x = r.width() - rightSize.width() + r.x();
y = r.y() + ( r.height() - rightSize.height() ) / 2;
if( tmpOffset > r.width() )
buttons.at( i - 1 )->setGeometry( QRect( 0, 0, 0, 0 ) );
}
else
{
x = r.x() + ( r.width() - rightSize.width() ) / 2;
y = r.height() - rightSize.height() + r.y();
if( tmpOffset > r.height() )
buttons.at( i - 1 )->setGeometry( QRect( 0, 0, 0, 0 ) );
}
right->setGeometry( QRect( x, y,
rightSize.width(), rightSize.height() ) );
right->widget()->raise();
rightArrowShown = true;
}
else
{
right->setGeometry( QRect( 0, 0, 0, 0 ) );
}
// Hide buttons that right on right arrow.
if( i < buttons.size() )
{
for( ; i < buttons.size(); ++i )
buttons.at( i )->setGeometry( QRect( 0, 0, 0, 0 ) );
}
else if( offset > 0 && leftArrowShown &&
!rightArrowShown &&
space + dim / 2 <= ( orient == Qt::Horizontal ? r.width() : r.height() ) )
{
offset = 0;
setGeometry( rect );
}
left->widget()->raise();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x5db20
movq %r15, %rdi
callq 0x5da80
movq %rdx, %r8
movq %rax, %rdx
shrq $0x20, %rdx
movl %r8d, %ecx
negl %ecx
shrq $0x20, %r8
negl %r8d
movq %rbx, %rdi
movl %eax, %esi
callq 0x6fc3c
cmpq $0x0, 0x40(%r15)
je 0x7a81c
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x7a81c
cmpq $0x0, 0x28(%r15)
je 0x7a81c
movq %rax, %r12
movq %rdx, %r14
movq %rbx, 0x80(%rsp)
movq %rax, %rbp
shrq $0x20, %rbp
cmpl $0x0, 0x50(%r15)
jns 0x7a2e4
andl $0x0, 0x50(%r15)
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r13
movq %rax, %rbx
shrq $0x20, %rbx
movq 0x28(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x58(%rsp)
cmpl $0x1, 0x48(%r15)
pushq $0x2
popq %rsi
movq %r14, 0x50(%rsp)
jne 0x7a32c
shrq $0x20, %r14
subl %ebp, %r14d
subl %ebx, %r14d
incl %r14d
movl %r14d, %eax
cltd
idivl %esi
addl %ebp, %eax
movl %r12d, %r14d
jmp 0x7a342
movl %r14d, %eax
subl %r12d, %eax
subl %r13d, %eax
incl %eax
cltd
idivl %esi
movl %eax, %r14d
addl %r12d, %r14d
movl %ebp, %eax
movq 0x58(%rsp), %rcx
shrq $0x20, %rcx
movq %rcx, 0x60(%rsp)
movl 0x50(%r15), %ecx
movq 0x20(%r15), %rdi
movl %ecx, 0x74(%rsp)
testl %ecx, %ecx
movq %r15, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %rbp, 0x20(%rsp)
jle 0x7a3b2
leaq 0x30(%rsp), %rsi
movl %r14d, (%rsi)
movl %eax, 0x4(%rsi)
leal (%r14,%r13), %ecx
decl %ecx
movl %ecx, 0x8(%rsi)
leal -0x1(%rbx,%rax), %ecx
movl %ecx, 0xc(%rsi)
movq (%rdi), %rcx
movq %rax, %r12
callq *0x30(%rcx)
movl 0x48(%r15), %ebp
movq (%r15), %rax
movq %r15, %rdi
callq *0x60(%rax)
cmpl $0x1, %ebp
jne 0x7a3d6
movq %r12, 0x40(%rsp)
addl %r13d, %r14d
addl %eax, %r14d
jmp 0x7a3e1
movaps 0x112c7(%rip), %xmm0 # 0x8b680
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movq (%rdi), %rax
callq *0x30(%rax)
xorl %r13d, %r13d
xorl %ebx, %ebx
movq %rbp, 0x40(%rsp)
movl %r12d, %r14d
jmp 0x7a3e6
addl %ebx, %r12d
addl %eax, %r12d
movq %r12, 0x40(%rsp)
movq 0x10(%rsp), %r15
movq 0x38(%r15), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdx
movq %rax, %rcx
shrq $0x20, %rcx
cmpl $0x1, 0x48(%r15)
movq %rcx, 0x28(%rsp)
movl %ecx, %ebp
movq %rdx, 0x78(%rsp)
cmovel %edx, %ebp
movq (%r15), %rax
movq %r15, %rdi
callq *0x60(%rax)
movl %eax, %esi
addl %ebp, %esi
movl 0x50(%r15), %ebp
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
movq %rsi, 0x68(%rsp)
subl %esi, %ebp
jl 0x7a45f
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax,%r15,8), %rdi
movaps 0x11239(%rip), %xmm0 # 0x8b680
movaps %xmm0, 0x30(%rsp)
movq (%rdi), %rax
movq %r12, %rsi
callq *0x30(%rax)
movq 0x68(%rsp), %rsi
incq %r15
jmp 0x7a42f
movq 0x10(%rsp), %rbp
movl 0x48(%rbp), %ecx
movl 0x50(%rbp), %eax
cltd
idivl %esi
movl %edx, %r12d
cmpl $0x1, %ecx
jne 0x7a4c0
addl %r14d, %r12d
addl 0x18(%rsp), %r13d
movq 0x50(%rsp), %rbx
movl %ebx, %ecx
subl %r13d, %ecx
incl %ecx
movl %ecx, %eax
cltd
idivl %esi
subl %edx, %ecx
movq %rcx, 0x40(%rsp)
movq %rbx, %rax
shrq $0x20, %rax
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rcx
addl %r14d, %ecx
subl %ecx, %eax
incl %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %r13d
addl %r14d, %r13d
movl %r12d, 0xc(%rsp)
jmp 0x7a513
movl %r12d, %r13d
addl 0x40(%rsp), %r13d
movq %rbx, %rax
movq 0x50(%rsp), %rbx
movq %rbx, %rcx
shrq $0x20, %rcx
movq 0x20(%rsp), %r14
addl %r14d, %eax
subl %eax, %ecx
incl %ecx
movl %ecx, %eax
cltd
idivl %esi
subl %edx, %ecx
movq %rcx, 0x40(%rsp)
movq 0x18(%rsp), %rsi
movq 0x78(%rsp), %rax
leal (%rsi,%rax), %ecx
movl %ebx, %eax
subl %ecx, %eax
incl %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %r12d
addl %esi, %r12d
movl %r13d, 0xc(%rsp)
movq %rbp, %rdi
callq 0x79f78
movl 0x48(%rbp), %esi
movq %rbx, %rdi
shrq $0x20, %rdi
cmpl $0x1, %esi
movl %r14d, %ecx
cmovel 0x18(%rsp), %ecx
movq %rdi, %rdx
movq %rdi, 0x48(%rsp)
cmovel %ebx, %edx
subl %ecx, %edx
incl %edx
cmpl %edx, %eax
jge 0x7a5be
cmpl $0x1, %esi
sete %dil
movl 0x4c(%rbp), %ecx
movl %ecx, %r8d
andl $0x2, %r8d
shrl %r8d
cmpl $0x2, %esi
sete %dl
testb %r8b, %dil
jne 0x7a59b
movl %ecx, %edi
andl $0x40, %edi
shrl $0x6, %edi
andb %dil, %dl
jne 0x7a59b
testb $-0x7c, %cl
je 0x7a5be
cmpl $0x1, %esi
movl 0xc(%rsp), %edi
jne 0x7a82e
addl 0x18(%rsp), %eax
movl %ebx, %ecx
subl %eax, %ecx
incl %ecx
movl %ecx, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
addl %r12d, %eax
movl %eax, %r12d
jmp 0x7a5c2
cmpl $0x1, %esi
jne 0x7a5af
addl %ebx, %r12d
addl 0x18(%rsp), %eax
subl %eax, %r12d
incl %r12d
jmp 0x7a5be
addl 0x48(%rsp), %r13d
addl 0x20(%rsp), %eax
subl %eax, %r13d
incl %r13d
movl 0xc(%rsp), %edi
movq 0x78(%rsp), %rax
leal -0x1(%rax), %r14d
movq 0x28(%rsp), %rax
decl %eax
movq %rax, 0x28(%rsp)
xorl %ebx, %ebx
movq 0x40(%rbp), %rbp
cmpl 0x40(%rsp), %edi
jge 0x7a647
cmpq %r15, %rbp
jle 0x7a647
movq 0x10(%rsp), %rbp
movq 0x38(%rbp), %rax
movl %edi, %ebx
movq (%rax,%r15,8), %rdi
movl %r12d, 0x30(%rsp)
movl %r13d, 0x34(%rsp)
leal (%r14,%r12), %eax
movl %eax, 0x38(%rsp)
movq 0x28(%rsp), %rax
addl %r13d, %eax
movl %eax, 0x3c(%rsp)
movq (%rdi), %rax
leaq 0x30(%rsp), %rsi
callq *0x30(%rax)
movl %ebx, %edi
movl 0x48(%rbp), %esi
movq 0x68(%rsp), %rcx
leal (%r12,%rcx), %eax
leal (%rcx,%r13), %ebx
cmpl $0x1, %esi
cmovnel %ebx, %r13d
cmovel %eax, %r12d
cmovel %eax, %ebx
addl %ecx, %edi
incq %r15
jmp 0x7a5d9
movl %r15d, %r12d
cmpq %r12, %rbp
jle 0x7a696
movq %r12, 0x28(%rsp)
movq 0x50(%rsp), %rax
leal 0x1(%rax), %ecx
cmpl $0x1, %esi
jne 0x7a6b9
subl 0x18(%rsp), %ecx
movl %ecx, %r13d
subl 0x58(%rsp), %r13d
movq 0x20(%rsp), %rax
movq 0x60(%rsp), %rdx
addl %eax, %edx
movq 0x48(%rsp), %rax
subl %edx, %eax
incl %eax
cltd
pushq $0x2
popq %rsi
idivl %esi
movl %eax, %r12d
cmpl %ecx, %edi
jg 0x7a6e9
movq 0x10(%rsp), %r14
jmp 0x7a711
movq 0x10(%rsp), %r14
movq 0x28(%r14), %rdi
leaq 0x30(%rsp), %rsi
movaps 0x10fd5(%rip), %xmm0 # 0x8b680
movaps %xmm0, (%rsi)
movq (%rdi), %rax
callq *0x30(%rax)
jmp 0x7a762
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rdx
addl %edx, %eax
subl %eax, %ecx
movl %ecx, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %r13d
movq 0x48(%rsp), %rax
subl 0x20(%rsp), %eax
incl %eax
movl %eax, %r12d
subl 0x60(%rsp), %r12d
cmpl %eax, %edi
jle 0x7a68f
movq 0x10(%rsp), %r14
movq 0x38(%r14), %rax
movq 0x28(%rsp), %rcx
movq -0x8(%rax,%rcx,8), %rdi
leaq 0x30(%rsp), %rsi
movaps 0x10f78(%rip), %xmm0 # 0x8b680
movaps %xmm0, (%rsi)
movq (%rdi), %rax
callq *0x30(%rax)
addl 0x18(%rsp), %r13d
addl 0x20(%rsp), %r12d
movq 0x28(%r14), %rdi
leaq 0x30(%rsp), %rsi
movl %r13d, (%rsi)
movl %r12d, 0x4(%rsi)
movq 0x58(%rsp), %rax
leal -0x1(%rax,%r13), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
addl %r12d, %eax
decl %eax
movl %eax, 0xc(%rsi)
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
callq 0x5c270
movq 0x28(%rsp), %r12
movq 0x40(%r14), %rdx
cmpq %r12, %rdx
pushq $0x2
popq %rcx
movq 0x68(%rsp), %rax
jle 0x7a7ae
leaq 0x30(%rsp), %r14
movq 0x10(%rsp), %r12
cmpq %r15, %rdx
jle 0x7a809
movq 0x38(%r12), %rax
movq (%rax,%r15,8), %rdi
movaps 0x10eea(%rip), %xmm0 # 0x8b680
movaps %xmm0, 0x30(%rsp)
movq (%rdi), %rax
movq %r14, %rsi
callq *0x30(%rax)
incq %r15
movq 0x40(%r12), %rdx
jmp 0x7a77d
cmpq %r12, %rbp
movq 0x10(%rsp), %r12
jg 0x7a809
cmpl $0x0, 0x74(%rsp)
jle 0x7a809
cmpl $0x0, 0x50(%r12)
jle 0x7a809
cltd
idivl %ecx
addl %eax, %ebx
cmpl $0x1, 0x48(%r12)
movq 0x20(%rsp), %rax
cmovel 0x18(%rsp), %eax
movq 0x48(%rsp), %rcx
cmovel 0x50(%rsp), %ecx
subl %eax, %ecx
incl %ecx
cmpl %ecx, %ebx
jg 0x7a809
andl $0x0, 0x50(%r12)
movq (%r12), %rax
movq %r12, %rdi
movq 0x80(%rsp), %rsi
callq *0xa0(%rax)
movq 0x20(%r12), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
callq 0x5c270
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl 0x20(%rsp), %eax
movq 0x48(%rsp), %rcx
subl %eax, %ecx
incl %ecx
movl %ecx, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
addl %r13d, %eax
movl %eax, %r13d
jmp 0x7a5c2
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::ToolBarLayout::takeAt(int)
|
QLayoutItem *
ToolBarLayout::takeAt( int index )
{
if( index >= 0 && index < buttons.size() + 2 )
{
if( index == 0 )
{
QLayoutItem * item = left;
left = 0;
return item;
}
else if( index == buttons.size() + 1 )
{
QLayoutItem * item = right;
right = 0;
return item;
}
else
{
QLayoutItem * item = buttons.takeAt( index - 1 );
return item;
}
}
else
return 0;
}
|
testl %esi, %esi
js 0x7a881
movl %esi, %eax
movq 0x40(%rdi), %rcx
leaq 0x2(%rcx), %rdx
cmpq %rax, %rdx
jle 0x7a881
testl %esi, %esi
je 0x7a884
incq %rcx
cmpq %rax, %rcx
jne 0x7a88e
movq 0x28(%rdi), %rax
andq $0x0, 0x28(%rdi)
retq
xorl %eax, %eax
retq
movq 0x20(%rdi), %rax
andq $0x0, 0x20(%rdi)
retq
addq $0x30, %rdi
decl %esi
jmp 0x7b24c
nop
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
non-virtual thunk to QtMWidgets::ToolBarLayout::minimumSize() const
|
QSize
ToolBarLayout::minimumSize() const
{
int width = 0;
int height = 0;
const QSize arrowSize = left->sizeHint();
QSize buttonSize;
if( !buttons.isEmpty() )
buttonSize = buttons.at( 0 )->sizeHint();
else
buttonSize = QSize( FingerGeometry::width(),
FingerGeometry::height() );
const QMargins m = contentsMargins();
if( orient == Qt::Horizontal )
{
width = arrowSize.width() * 2 + buttonSize.width() * 2 + m.left() +
m.right();
height = qMax( arrowSize.height(), buttonSize.height() ) + m.top() +
m.bottom();
}
else
{
height = arrowSize.height() * 2 + buttonSize.height() * 2 + m.top() +
m.bottom();
width = qMax( arrowSize.width(), buttonSize.width() ) + m.left() +
m.right();
}
return QSize( width, height );
}
|
addq $-0x10, %rdi
jmp 0x7a8a2
nop
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::ToolBar::_q_rightArrowClicked()
|
void
ToolBar::_q_rightArrowClicked()
{
int delta = 0;
if( d->layout->orientation() == Qt::Horizontal )
delta = d->iconSize.width() + d->layout->spacing();
else
delta = d->iconSize.height() + d->layout->spacing();
d->layout->setOffset( delta );
update();
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rdi
xorl %ecx, %ecx
cmpl $0x1, 0x48(%rdi)
setne %cl
movq (%rdi), %rdx
movl 0x8(%rax,%rcx,4), %ebp
callq *0x60(%rdx)
addl %eax, %ebp
movq 0x28(%rbx), %rax
movq 0x10(%rax), %rdi
movl %ebp, %esi
callq 0x7a170
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5c4d0
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::SwitchPrivate::drawText(QPainter*, QStyleOption const&, QColor const&, QColor const&)
|
void
SwitchPrivate::drawText( QPainter * p, const QStyleOption & opt,
const QColor & on, const QColor & off )
{
const QRect r( radius, 0, opt.rect.width() - radius * 2, radius * 2 );
switch( state )
{
case Switch::NotAcceptedCheck :
case Switch::AcceptedCheck :
{
if( !onText.isEmpty() )
{
p->setPen( on );
p->drawText( r,
Qt::AlignLeft | Qt::TextSingleLine | Qt::AlignVCenter,
onText );
}
}
break;
case Switch::NotAcceptedUncheck :
case Switch::AcceptedUncheck :
{
if( !offText.isEmpty() )
{
p->setPen( off );
p->drawText( r,
Qt::AlignRight | Qt::TextSingleLine | Qt::AlignVCenter,
offText );
}
}
break;
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x50(%rdi), %eax
leal (%rax,%rax), %esi
movl 0x18(%rdx), %edi
addl %eax, %edi
addl 0x10(%rdx), %esi
subl %esi, %edi
movl %eax, (%rsp)
andl $0x0, 0x4(%rsp)
movl %edi, 0x8(%rsp)
leal -0x1(,%rax,2), %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rbx), %eax
cmpl $0x2, %eax
jb 0x7bc9a
addl $-0x2, %eax
cmpl $0x1, %eax
ja 0x7bccd
cmpq $0x0, 0x20(%rbx)
je 0x7bccd
movl $0x181, %ebp # imm = 0x181
pushq $0x10
popq %rax
jmp 0x7bcac
cmpq $0x0, 0x38(%rbx)
je 0x7bccd
movl $0x182, %ebp # imm = 0x182
pushq $0x28
popq %rax
movq %r8, %rcx
addq %rax, %rbx
movq %r14, %rdi
movq %rcx, %rsi
callq 0x5d7c0
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x5d270
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/igormironchik[P]qtmwidgets/src/switch.cpp
|
QtMWidgets::PickerPrivate::drawItem(QPainter*, QStyleOption const&, int, QModelIndex const&)
|
void
PickerPrivate::drawItem( QPainter * p, const QStyleOption & opt, int offset,
const QModelIndex & index )
{
if( index.flags() & Qt::ItemIsEnabled )
{
if( index != currentIndex )
p->setPen( opt.palette.color( QPalette::WindowText ) );
else
p->setPen( highlightColor );
}
else
p->setPen( lighterColor( opt.palette.color( QPalette::WindowText ), 75 ) );
const QRect r( opt.rect.x() + itemSideMargin, offset,
opt.rect.width() - itemSideMargin * 2, stringHeight );
const int flags = Qt::AlignLeft | Qt::TextSingleLine;
p->drawText( r, flags,
makeString( itemText( index ), r, flags, opt ) );
if( index.flags() & Qt::ItemIsEnabled && index == currentIndex )
{
const QRect tickRect( opt.rect.x() + itemSideMargin -
opt.fontMetrics.averageCharWidth() -
opt.fontMetrics.averageCharWidth() / 2,
offset,
opt.fontMetrics.averageCharWidth(),
stringHeight );
drawTick( tickRect, p );
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq %r8, %rdi
callq 0x7f0a8
testb $0x20, %al
movq %rbx, 0x8(%rsp)
jne 0x7d27e
leaq 0x28(%r12), %rdi
xorl %esi, %esi
callq 0x5f828
pushq $0x4b
popq %rsi
movq %rax, %rdi
callq 0x74368
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
shrq $0x20, %rdx
movw %dx, 0xc(%rsi)
jmp 0x7d2b6
leaq 0x18(%r15), %rsi
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
callq 0x5d410
movq %r13, %rdi
movq %rbp, %rsi
callq 0x7f09e
testb %al, %al
je 0x7d2b2
leaq 0x28(%r12), %rdi
xorl %esi, %esi
callq 0x5f828
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x7d2b9
leaq 0x6c(%r15), %rsi
movq %rbx, %rdi
callq 0x5d7c0
movl 0x54(%r15), %eax
movl 0x10(%r12), %ecx
addl %eax, %ecx
movl 0x18(%r12), %edx
addl %eax, %edx
movq 0x10(%rsp), %rdi
leal -0x1(%rdi), %r14d
movl 0x58(%r15), %esi
addl %r14d, %esi
leaq 0x48(%rsp), %rbp
movl %ecx, (%rbp)
movl %edi, 0x4(%rbp)
addl %eax, %eax
subl %eax, %edx
movl %edx, 0x8(%rbp)
movl %esi, 0xc(%rbp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x7ceea
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movl $0x101, %ecx # imm = 0x101
movq %r12, %r8
callq 0x86aec
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl $0x101, %edx # imm = 0x101
xorl %r8d, %r8d
callq 0x5d270
leaq 0x18(%rsp), %rdi
callq 0x5edf4
leaq 0x30(%rsp), %rdi
callq 0x5edf4
movq %r13, %rdi
callq 0x7f0a8
testb $0x20, %al
je 0x7d3d5
leaq 0x18(%r15), %rsi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x5d410
movq %r13, %rdi
movq %rbx, %rsi
callq 0x63fb8
testb %al, %al
je 0x7d3d5
movl 0x54(%r15), %ebp
addl 0x10(%r12), %ebp
addq $0x20, %r12
movq %r12, %rdi
callq 0x5cdf0
subl %eax, %ebp
movq %r12, %rdi
callq 0x5cdf0
pushq $-0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebx
addl %ebp, %ebx
movq %r12, %rdi
callq 0x5cdf0
addl 0x58(%r15), %r14d
leaq 0x18(%rsp), %rsi
movl %ebx, (%rsi)
movq 0x10(%rsp), %rcx
movl %ecx, 0x4(%rsi)
leal -0x1(%rax,%rbx), %eax
movl %eax, 0x8(%rsi)
movl %r14d, 0xc(%rsi)
movq 0x8(%rsp), %rdx
callq 0x7d422
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5edf4
jmp 0x7d3f6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5edf4
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/picker.cpp
|
QtMWidgets::Picker::_q_rowsInserted(QModelIndex const&, int, int)
|
void
Picker::_q_rowsInserted( const QModelIndex & parent, int start, int end )
{
if( d->inserting || parent != d->root )
return;
// set current index if picker was previously empty
if( start == 0 && ( end - start + 1 ) == count() &&
!d->currentIndex.isValid() )
{
d->topItemIndex = d->model->index( 0, d->modelColumn, d->root );
setCurrentIndex( 0 );
}
// need to emit changed if model updated index "silently"
else if( d->currentIndex.row() != d->indexBeforeChange )
{
update();
_q_emitCurrentIndexChanged( d->currentIndex );
}
else if( d->isRowsVisible( start, end ) )
update();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq 0x28(%rdi), %rsi
cmpb $0x0, 0x38(%rsi)
jne 0x7df33
movl %ecx, %r14d
movl %edx, %ebp
movq %rdi, %rbx
addq $0x20, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x5d410
movq %r15, %rdi
movq %r12, %rsi
callq 0x7f09e
testb %al, %al
jne 0x7df33
testl %ebp, %ebp
jne 0x7dedf
leal 0x1(%r14), %r15d
movq %rbx, %rdi
callq 0x7d184
cmpl %eax, %r15d
jne 0x7dedf
movq 0x28(%rbx), %rdi
addq $0x18, %rdi
callq 0x5cba0
testb %al, %al
je 0x7df40
movq 0x28(%rbx), %rdi
addq $0x18, %rdi
callq 0x5c410
movq 0x28(%rbx), %rdi
cmpl 0x34(%rdi), %eax
jne 0x7df0d
movl %ebp, %esi
movl %r14d, %edx
callq 0x7d906
testb %al, %al
je 0x7df33
movq %rbx, %rdi
callq 0x5c4d0
jmp 0x7df33
movq %rbx, %rdi
callq 0x5c4d0
movq 0x28(%rbx), %rsi
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x5d410
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ce3e
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rbx), %rsi
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %ebp
addq $0x20, %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x5d410
movq (%r14), %rax
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebp, %ecx
movq %r15, %r8
callq *0x60(%rax)
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movq %r12, %rsi
callq 0x5c890
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7e10a
jmp 0x7df33
|
/igormironchik[P]qtmwidgets/src/picker.cpp
|
QtMWidgets::Picker::insertItem(int, QString const&, QVariant const&)
|
void
Picker::insertItem( int index, const QString & text, const QVariant & userData )
{
int itemCount = count();
index = qBound( 0, index, itemCount );
if( index >= d->maxCount )
return;
// For the common case where we are using the built in QStandardItemModel
// construct a QStandardItem, reducing the number of expensive signals from
// the model
if( QStandardItemModel * m = qobject_cast< QStandardItemModel* > ( d->model ) )
{
QStandardItem * item = new QStandardItem( text );
if( userData.isValid() ) item->setData( userData, Qt::UserRole );
m->insertRow( index, item );
++itemCount;
}
else
{
d->inserting = true;
if( d->model->insertRows( index, 1, d->root ) )
{
QModelIndex item = d->model->index( index, d->modelColumn, d->root );
if( !userData.isValid() )
d->model->setData( item, text, Qt::DisplayRole );
else
{
QMap< int, QVariant > values;
if( !text.isNull() ) values.insert( Qt::DisplayRole, text );
if( userData.isValid() ) values.insert( Qt::UserRole, userData );
if( !values.isEmpty() ) d->model->setItemData( item, values );
}
d->inserting = false;
_q_rowsInserted( d->root, index, index );
++itemCount;
}
else
d->inserting = false;
}
if( itemCount > d->maxCount )
d->model->removeRows( itemCount - 1, itemCount - d->maxCount, d->root );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r13
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
callq 0x7d184
movl %eax, %ebx
cmpl %r15d, %eax
cmovll %eax, %r15d
xorl %ebp, %ebp
testl %r15d, %r15d
cmovgl %r15d, %ebp
movq 0x28(%r14), %rax
cmpl 0x3c(%rax), %ebp
jge 0x7e545
movq %r13, 0x38(%rsp)
movq 0x8(%rax), %rdi
callq 0x7f6c3
testq %rax, %rax
je 0x7e38a
movq %rax, %r13
pushq $0x10
popq %rdi
callq 0x5d090
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x5d260
movq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x7f6d2
testb %al, %al
je 0x7e378
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movl $0x100, %edx # imm = 0x100
callq *0x20(%rax)
movq %r13, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x7f6e8
jmp 0x7e50e
movq 0x28(%r14), %rsi
movb $0x1, 0x38(%rsi)
movq 0x8(%rsi), %r15
addq $0x20, %rsi
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x5d410
movq (%r15), %rax
pushq $0x1
popq %rdx
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rcx
callq *0xf8(%rax)
testb %al, %al
je 0x7e4a4
movq 0x28(%r14), %rsi
movq 0x8(%rsi), %r15
movl 0x10(%rsi), %r13d
addq $0x20, %rsi
leaq 0x18(%rsp), %rdi
callq 0x5d410
movq (%r15), %rax
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r13d, %ecx
leaq 0x18(%rsp), %r8
callq *0x60(%rax)
movq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x7f6d2
testb %al, %al
je 0x7e4ae
andq $0x0, 0x8(%rsp)
cmpq $0x0, 0x8(%r12)
je 0x7e448
andl $0x0, 0x14(%rsp)
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x5d6c0
leaq 0x8(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x7f73a
leaq 0x18(%rsp), %rdi
callq 0x5c680
movq %r15, %rdi
callq 0x7f6d2
testb %al, %al
je 0x7e46c
leaq 0x18(%rsp), %rsi
movl $0x100, (%rsi) # imm = 0x100
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x7f73a
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x7e498
cmpq $0x0, 0x30(%rax)
je 0x7e498
movq 0x28(%r14), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq *0xb8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x7f82a
jmp 0x7e4e6
movq 0x28(%r14), %rax
movb $0x0, 0x38(%rax)
jmp 0x7e510
movq 0x28(%r14), %rax
movq 0x8(%rax), %r15
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x5d6c0
movq (%r15), %rax
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq *0x98(%rax)
leaq 0x18(%rsp), %rdi
callq 0x5c680
movq 0x28(%r14), %rsi
movb $0x0, 0x38(%rsi)
addq $0x20, %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x5d410
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x7de76
incl %ebx
movq 0x28(%r14), %rsi
movl %ebx, %ebp
subl 0x3c(%rsi), %ebp
jle 0x7e545
movq 0x8(%rsi), %r14
decl %ebx
addq $0x20, %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x5d410
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %r15, %rcx
callq *0x108(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7e576
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5c680
jmp 0x7e579
jmp 0x7e576
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5c680
jmp 0x7e593
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7f82a
jmp 0x7e593
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x5c190
movq %rbx, %rdi
callq 0x5c7f0
nop
|
/igormironchik[P]qtmwidgets/src/picker.cpp
|
QtMWidgets::Picker::mouseMoveEvent(QMouseEvent*)
|
void
Picker::mouseMoveEvent( QMouseEvent * event )
{
if( d->leftMouseButtonPressed )
{
d->mouseWasMoved = true;
const int delta = event->pos().y() - d->mousePos.y();
d->mouseMoveDelta += qAbs( delta );
d->drawItemOffset += delta;
d->mousePos = event->pos();
update();
event->accept();
}
else
event->ignore();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %rax
cmpb $0x1, 0x64(%rax)
jne 0x7f04e
movq %rdi, %r14
movb $0x1, 0x65(%rax)
movq %rbx, %rdi
callq 0x5f868
shrq $0x20, %rax
movq 0x28(%r14), %rcx
subl 0x60(%rcx), %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
addl %edx, 0x68(%rcx)
addl %eax, 0x30(%rcx)
movq %rbx, %rdi
callq 0x5f868
movq 0x28(%r14), %rcx
movq %rax, 0x5c(%rcx)
movq %r14, %rdi
callq 0x5c4d0
movb $0x1, %al
jmp 0x7f050
xorl %eax, %eax
movb %al, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/igormironchik[P]qtmwidgets/src/picker.cpp
|
QtMWidgets::PickerPrivate::PickerPrivate(QtMWidgets::Picker*)
|
PickerPrivate( Picker * parent )
: q( parent )
, model( 0 )
, modelColumn( 0 )
, drawItemOffset( 0 )
, indexBeforeChange( -1 )
, inserting( false )
, maxCount( INT_MAX )
, minStringLength( 6 )
, maxStringWidth( 25 )
, stringLength( minStringLength )
, itemsCount( 5 )
, itemTopMargin( 7 )
, itemSideMargin( 0 )
, stringHeight( 0 )
, leftMouseButtonPressed( false )
, mouseWasMoved( false )
, wasPainted( false )
, mouseMoveDelta( 0 )
, scroller( 0 )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
andq $0x0, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x5cce0
leaq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x5cce0
leaq 0x28(%r14), %rdi
callq 0x5cce0
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, 0x30(%r14)
movb $0x0, 0x38(%r14)
movaps 0xc901(%rip), %xmm0 # 0x8ba40
movups %xmm0, 0x3c(%r14)
movabsq $0x700000005, %rax # imm = 0x700000005
movq %rax, 0x4c(%r14)
andq $0x0, 0x68(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x54(%r14)
andl $0x0, 0x63(%r14)
orw $-0x1, 0x70(%r14)
andq $0x0, 0x72(%r14)
andq $0x0, 0x80(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x5d0a0
jmp 0x7f18d
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d0a0
movq %r14, %rdi
callq 0x5c7f0
nop
|
/igormironchik[P]qtmwidgets/src/picker.cpp
|
QtMWidgets::ScrollArea::sizeHint() const
|
QSize
ScrollArea::sizeHint() const
{
const ScrollAreaPrivate * d = d_func();
QSize sz( 0, 0 );
const int h = fontMetrics().height();
if( d->widget )
sz += ( d->resizable ? d->widget->sizeHint() : d->widget->size() );
else
sz += QSize( 12 * h, 8 * h );
const QSize marginsSize = QSize( d->left + d->right, d->top + d->bottom );
const QSize frameSize = QSize( frameWidth() * 2, frameWidth() * 2 );
sz += marginsSize + frameSize;
return sz.boundedTo( QSize( 36 * h, 24 * h ) );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f804
movq %r14, %rdi
callq 0x5dc70
movl %eax, %r14d
leaq 0x8(%rsp), %rdi
callq 0x5c8c0
movq 0xa8(%r12), %rax
testq %rax, %rax
je 0x82630
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0x82630
movq 0xb0(%r12), %rdi
testq %rdi, %rdi
je 0x82630
movl 0x4(%rax), %eax
cmpb $0x1, 0xb8(%r12)
jne 0x8263e
movq (%rdi), %rax
callq *0x70(%rax)
jmp 0x82643
imull $0xc, %r14d, %r15d
leal (,%r14,8), %r13d
jmp 0x8264d
callq 0x6860a
movq %rax, %r15
movq %rax, %r13
shrq $0x20, %r13
addl 0x44(%r12), %r15d
addl 0x40(%r12), %r15d
addl 0x38(%r12), %r13d
addl 0x3c(%r12), %r13d
movq %rbx, %rdi
callq 0x5cf30
movl %eax, %r12d
movq %rbx, %rdi
callq 0x5cf30
leal (%r15,%r12,2), %edx
imull $0x24, %r14d, %ecx
imull $0x18, %r14d, %esi
cmpl %ecx, %edx
cmovll %edx, %ecx
leal (%r13,%rax,2), %eax
cmpl %esi, %eax
cmovll %eax, %esi
shlq $0x20, %rsi
orq %rsi, %rcx
movq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5c8c0
movq %rbx, %rdi
callq 0x5c7f0
|
/igormironchik[P]qtmwidgets/src/scrollarea.cpp
|
ParserTransform_hodgkinHuxleyCellml10_Test::TestBody()
|
TEST(ParserTransform, hodgkinHuxleyCellml10)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/Hodgkin_Huxley_1952_modified.cellml"));
EXPECT_EQ(size_t(7), model->unitsCount());
EXPECT_EQ(size_t(5), model->componentCount());
EXPECT_EQ(size_t(4), parser->issueCount());
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(0), validator->issueCount());
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x22a63(%rip), %rsi # 0x3b67e
leaq 0x22a88(%rip), %rdx # 0x3b6aa
leaq 0x10(%rsp), %rdi
callq 0x1aa4e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18c68
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x18c7f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x7, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xf080
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x22a0a(%rip), %rsi # 0x3b6ab
leaq 0x22a0d(%rip), %rdx # 0x3b6b5
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x18d38
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x18cd7
movq (%rax), %r8
jmp 0x18cde
leaq 0x225d8(%rip), %r8 # 0x3b2b6
leaq 0x224b8(%rip), %rdx # 0x3b19d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x65, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x18d38
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x18d38
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18d38
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq $0x5, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xf0a0
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x22963(%rip), %rsi # 0x3b6c9
leaq 0x22966(%rip), %rdx # 0x3b6d3
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x18dfd
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x18d9c
movq (%rax), %r8
jmp 0x18da3
leaq 0x22513(%rip), %r8 # 0x3b2b6
leaq 0x223f3(%rip), %rdx # 0x3b19d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x66, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x18dfd
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x18dfd
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18dfd
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq $0x4, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0xf690
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x228c0(%rip), %rsi # 0x3b6eb
leaq 0x2248f(%rip), %rdx # 0x3b2c1
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x18ec2
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x18e61
movq (%rax), %r8
jmp 0x18e68
leaq 0x2244e(%rip), %r8 # 0x3b2b6
leaq 0x2232e(%rip), %rdx # 0x3b19d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x67, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x18ec2
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x18ec2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18ec2
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0xf630
movq (%rbx), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf370
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xf690
leaq 0x50(%rsp), %r8
movq %rax, (%r8)
leaq 0x227eb(%rip), %rsi # 0x3b6f5
leaq 0x227ee(%rip), %rdx # 0x3b6ff
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x10(%rsp)
jne 0x18fa1
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x18f40
movq (%rax), %r8
jmp 0x18f47
leaq 0x2236f(%rip), %r8 # 0x3b2b6
leaq 0x2224f(%rip), %rdx # 0x3b19d
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x6c, %ecx
callq 0xf680
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
leaq 0x50(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x18fa1
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x18fa1
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18fa1
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x18fbc
callq 0x1a604
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x18fcb
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x18fda
callq 0x1a604
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x1905b
jmp 0x1905b
jmp 0x1905b
jmp 0x1905b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf340
jmp 0x18ffc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1900b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a380
jmp 0x190a7
jmp 0x19026
jmp 0x19035
jmp 0x19044
jmp 0x19026
jmp 0x19035
jmp 0x19044
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf340
jmp 0x19038
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a36e
jmp 0x19047
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1a380
jmp 0x190bf
jmp 0x1905b
jmp 0x190a4
jmp 0x1905b
jmp 0x1905b
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19086
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x19086
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x190ce
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x190ce
movq %rax, %rbx
jmp 0x190ce
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x190bf
callq 0x1a604
jmp 0x190bf
jmp 0x190bc
jmp 0x190bc
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x190ce
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x190dd
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_annotatedCellMl10Model_Test::TestBody()
|
TEST(ParserTransform, annotatedCellMl10Model)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/annotated_model.cellml"));
EXPECT_EQ(size_t(5), model->unitsCount());
EXPECT_EQ(size_t(2), model->componentCount());
EXPECT_EQ(size_t(78), parser->issueCount());
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(4), validator->issueCount());
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2261f(%rip), %rsi # 0x3b72e
leaq 0x22637(%rip), %rdx # 0x3b74d
leaq 0x10(%rsp), %rdi
callq 0x1aa4e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1915c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x19173
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x5, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xf080
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x22534(%rip), %rsi # 0x3b6c9
leaq 0x22519(%rip), %rdx # 0x3b6b5
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x1922c
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x191cb
movq (%rax), %r8
jmp 0x191d2
leaq 0x220e4(%rip), %r8 # 0x3b2b6
leaq 0x21fc4(%rip), %rdx # 0x3b19d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x74, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x1922c
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1922c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1922c
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq $0x2, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xf0a0
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x224f4(%rip), %rsi # 0x3b74e
leaq 0x22472(%rip), %rdx # 0x3b6d3
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x192f1
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x19290
movq (%rax), %r8
jmp 0x19297
leaq 0x2201f(%rip), %r8 # 0x3b2b6
leaq 0x21eff(%rip), %rdx # 0x3b19d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x75, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x192f1
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x192f1
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x192f1
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq $0x4e, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0xf690
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x22439(%rip), %rsi # 0x3b758
leaq 0x21f9b(%rip), %rdx # 0x3b2c1
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x193b6
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x19355
movq (%rax), %r8
jmp 0x1935c
leaq 0x21f5a(%rip), %r8 # 0x3b2b6
leaq 0x21e3a(%rip), %rdx # 0x3b19d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x76, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x193b6
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x193b6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x193b6
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0xf630
movq (%rbx), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf370
movq $0x4, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xf690
leaq 0x50(%rsp), %r8
movq %rax, (%r8)
leaq 0x222ed(%rip), %rsi # 0x3b6eb
leaq 0x222fa(%rip), %rdx # 0x3b6ff
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x10(%rsp)
jne 0x19495
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x19434
movq (%rax), %r8
jmp 0x1943b
leaq 0x21e7b(%rip), %r8 # 0x3b2b6
leaq 0x21d5b(%rip), %rdx # 0x3b19d
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x7b, %ecx
callq 0xf680
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
leaq 0x50(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x19495
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x19495
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19495
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x194b0
callq 0x1a604
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x194bf
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x194ce
callq 0x1a604
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x1954f
jmp 0x1954f
jmp 0x1954f
jmp 0x1954f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf340
jmp 0x194f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x194ff
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a380
jmp 0x1959b
jmp 0x1951a
jmp 0x19529
jmp 0x19538
jmp 0x1951a
jmp 0x19529
jmp 0x19538
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf340
jmp 0x1952c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a36e
jmp 0x1953b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1a380
jmp 0x195b3
jmp 0x1954f
jmp 0x19598
jmp 0x1954f
jmp 0x1954f
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1957a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1957a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x195c2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x195c2
movq %rax, %rbx
jmp 0x195c2
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x195b3
callq 0x1a604
jmp 0x195b3
jmp 0x195b0
jmp 0x195b0
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x195c2
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x195d1
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_renameNonSiUnits_Test::TestBody()
|
TEST(ParserTransform, renameNonSiUnits)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/non_si_units.cellml"));
EXPECT_EQ(size_t(11), model->unitsCount());
EXPECT_EQ(size_t(2), model->componentCount());
auto unitsMetre = model->units(0);
auto unitsLitre = model->units(1);
EXPECT_EQ("metre", unitsMetre->unitAttributeReference(0));
EXPECT_EQ("litre", unitsLitre->unitAttributeReference(0));
auto v1 = model->component(1)->variable(1);
auto v2 = model->component(1)->variable(3);
EXPECT_EQ("metre", v1->units()->name());
EXPECT_EQ("litre", v2->units()->name());
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x22169(%rip), %rsi # 0x3b774
leaq 0x2217e(%rip), %rdx # 0x3b790
leaq 0x50(%rsp), %rdi
callq 0x1aa4e
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
callq 0xf610
leaq 0x90(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x19657
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x1966e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0xb, 0x50(%rsp)
movq 0x90(%rsp), %rdi
callq 0xf080
leaq 0x40(%rsp), %r8
movq %rax, (%r8)
leaq 0x220fe(%rip), %rsi # 0x3b791
leaq 0x2201b(%rip), %rdx # 0x3b6b5
movq %rsp, %rdi
leaq 0x50(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, (%rsp)
jne 0x19727
leaq 0x50(%rsp), %rdi
callq 0xf2a0
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x196c6
movq (%rax), %r8
jmp 0x196cd
leaq 0x21be9(%rip), %r8 # 0x3b2b6
leaq 0x21ac9(%rip), %rdx # 0x3b19d
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x83, %ecx
callq 0xf680
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf290
leaq 0x40(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x50(%rsp)
je 0x19727
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x19727
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x19727
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq $0x2, 0x50(%rsp)
movq 0x90(%rsp), %rdi
callq 0xf0a0
leaq 0x40(%rsp), %r8
movq %rax, (%r8)
leaq 0x21ff6(%rip), %rsi # 0x3b74e
leaq 0x21f74(%rip), %rdx # 0x3b6d3
movq %rsp, %rdi
leaq 0x50(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, (%rsp)
jne 0x197ec
leaq 0x50(%rsp), %rdi
callq 0xf2a0
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1978b
movq (%rax), %r8
jmp 0x19792
leaq 0x21b24(%rip), %r8 # 0x3b2b6
leaq 0x21a04(%rip), %rdx # 0x3b19d
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x84, %ecx
callq 0xf680
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf290
leaq 0x40(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x50(%rsp)
je 0x197ec
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x197ec
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x197ec
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x90(%rsp), %rsi
leaq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0xf6f0
movq 0x90(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x1, %edx
callq 0xf6f0
movq 0x50(%rsp), %rsi
movq %rsp, %rdi
xorl %edx, %edx
callq 0xf330
leaq 0x21f63(%rip), %rsi # 0x3b79c
leaq 0x21f64(%rip), %rdx # 0x3b7a4
leaq 0x21f83(%rip), %rcx # 0x3b7ca
leaq 0x30(%rsp), %rdi
movq %rsp, %r8
callq 0x1b1f2
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1986a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
cmpb $0x0, 0x30(%rsp)
jne 0x198e5
movq %rsp, %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x19888
movq (%rax), %r8
jmp 0x1988f
leaq 0x21a27(%rip), %r8 # 0x3b2b6
leaq 0x21907(%rip), %rdx # 0x3b19d
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
movl $0x89, %ecx
callq 0xf680
leaq 0x70(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x70(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x198e5
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x198e5
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x198e5
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x40(%rsp), %rsi
movq %rsp, %rdi
xorl %edx, %edx
callq 0xf330
leaq 0x21ec9(%rip), %rsi # 0x3b7d0
leaq 0x21eca(%rip), %rdx # 0x3b7d8
leaq 0x21ee9(%rip), %rcx # 0x3b7fe
leaq 0x30(%rsp), %rdi
movq %rsp, %r8
callq 0x1b1f2
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19938
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
cmpb $0x0, 0x30(%rsp)
jne 0x199b3
movq %rsp, %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x19956
movq (%rax), %r8
jmp 0x1995d
leaq 0x21959(%rip), %r8 # 0x3b2b6
leaq 0x21839(%rip), %rdx # 0x3b19d
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
movl $0x8a, %ecx
callq 0xf680
leaq 0x70(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x70(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x199b3
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x199b3
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x199b3
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x90(%rsp), %rsi
movq %rsp, %rdi
movl $0x1, %edx
callq 0xf030
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0xf4f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x199f6
callq 0x1a604
movq 0x90(%rsp), %rsi
movq %rsp, %rdi
movl $0x1, %edx
callq 0xf030
movq (%rsp), %rsi
leaq 0x70(%rsp), %rdi
movl $0x3, %edx
callq 0xf4f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19a2d
callq 0x1a604
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf300
movq 0x20(%rsp), %rsi
movq %rsp, %rdi
callq 0xf450
leaq 0x21d4c(%rip), %rsi # 0x3b79c
leaq 0x21dad(%rip), %rdx # 0x3b804
leaq 0x21d6c(%rip), %rcx # 0x3b7ca
leaq 0x80(%rsp), %rdi
movq %rsp, %r8
callq 0x1b1f2
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19a84
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x19a93
callq 0x1a604
cmpb $0x0, 0x80(%rsp)
jne 0x19b14
movq %rsp, %rdi
callq 0xf2a0
movq 0x88(%rsp), %rax
testq %rax, %rax
je 0x19ab7
movq (%rax), %r8
jmp 0x19abe
leaq 0x217f8(%rip), %r8 # 0x3b2b6
leaq 0x216d8(%rip), %rdx # 0x3b19d
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x8f, %ecx
callq 0xf680
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x20(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x19b14
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x19b14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x19b14
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x70(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf300
movq 0x20(%rsp), %rsi
movq %rsp, %rdi
callq 0xf450
leaq 0x21c8a(%rip), %rsi # 0x3b7d0
leaq 0x21ccb(%rip), %rdx # 0x3b818
leaq 0x21caa(%rip), %rcx # 0x3b7fe
leaq 0x80(%rsp), %rdi
movq %rsp, %r8
callq 0x1b1f2
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19b7a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x19b89
callq 0x1a604
cmpb $0x0, 0x80(%rsp)
jne 0x19c0a
movq %rsp, %rdi
callq 0xf2a0
movq 0x88(%rsp), %rax
testq %rax, %rax
je 0x19bad
movq (%rax), %r8
jmp 0x19bb4
leaq 0x21702(%rip), %r8 # 0x3b2b6
leaq 0x215e2(%rip), %rdx # 0x3b19d
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x90, %ecx
callq 0xf680
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x20(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x19c0a
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x19c0a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x19c0a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x19c28
callq 0x1a604
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x19c37
callq 0x1a604
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x19c46
callq 0x1a604
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x19c55
callq 0x1a604
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x19c67
callq 0x1a604
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x19c79
callq 0x1a604
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x19e0f
jmp 0x19e0f
jmp 0x19e0f
jmp 0x19e0f
jmp 0x19e0f
jmp 0x19e0f
jmp 0x19caa
jmp 0x19cb9
jmp 0x19cc6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf340
jmp 0x19cbc
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a36e
jmp 0x19cc9
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x1a380
jmp 0x19d85
jmp 0x19ce1
jmp 0x19cf0
jmp 0x19cfd
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf340
jmp 0x19cf3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a36e
jmp 0x19d00
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1a380
jmp 0x19de6
jmp 0x19d15
jmp 0x19d24
jmp 0x19d33
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf340
jmp 0x19d27
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1a36e
jmp 0x19d36
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a380
jmp 0x19e5d
jmp 0x19e0f
jmp 0x19d53
jmp 0x19d6e
jmp 0x19d82
jmp 0x19e0f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19d71
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x19d71
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x19d85
callq 0x1a604
jmp 0x19d85
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x19d94
callq 0x1a604
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x19de6
callq 0x1a604
jmp 0x19de6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x19d8a
movq %rax, %rbx
jmp 0x19d94
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x19d99
jmp 0x19de3
jmp 0x19e0f
jmp 0x19dc8
jmp 0x19de3
jmp 0x19e0f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19de6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x19de6
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x19df5
callq 0x1a604
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x19e5d
callq 0x1a604
jmp 0x19e5d
movq %rax, %rbx
jmp 0x19df5
jmp 0x19e5a
jmp 0x19e0f
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19e3a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x19e3a
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x19e6f
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x19e6f
movq %rax, %rbx
jmp 0x19e6f
jmp 0x19e5a
movq %rax, %rbx
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x19e6f
callq 0x1a604
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x19e81
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_multipleMathInComponent_Test::TestBody()
|
TEST(ParserTransform, multipleMathInComponent)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/cardiac_constant_simplified.cellml"));
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(0), validator->errorCount());
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x21991(%rip), %rsi # 0x3b844
leaq 0x219b5(%rip), %rdx # 0x3b86f
leaq 0x18(%rsp), %rdi
callq 0x1aa4e
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19f00
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x19f17
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0xf630
movq (%rbx), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf370
movq $0x0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf6c0
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x217a2(%rip), %rsi # 0x3b6f5
leaq 0x21916(%rip), %rdx # 0x3b870
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x18(%rsp)
jne 0x19fea
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x19f89
movq (%rax), %r8
jmp 0x19f90
leaq 0x21326(%rip), %r8 # 0x3b2b6
leaq 0x21206(%rip), %rdx # 0x3b19d
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x9c, %ecx
callq 0xf680
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
leaq 0x10(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x19fea
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x19fea
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19fea
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1a005
callq 0x1a604
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1a014
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a023
callq 0x1a604
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x1a05a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf340
jmp 0x1a03f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1a04e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1a380
jmp 0x1a0a8
movq %rax, %rdi
callq 0x1a51f
jmp 0x1a0a5
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a087
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1a087
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a0c6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1a0c6
movq %rax, %rbx
jmp 0x1a0c6
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1a0b7
callq 0x1a604
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1a0c6
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a0d5
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_multipleMathInComponentAlternativeFormulation_Test::TestBody()
|
TEST(ParserTransform, multipleMathInComponentAlternativeFormulation)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/cardiac_constant_simplified_alternative.cellml"));
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(0), validator->errorCount());
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x217af(%rip), %rsi # 0x3b8b6
leaq 0x217df(%rip), %rdx # 0x3b8ed
leaq 0x18(%rsp), %rdi
callq 0x1aa4e
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a154
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a16b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0xf630
movq (%rbx), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf370
movq $0x0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf6c0
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x2154e(%rip), %rsi # 0x3b6f5
leaq 0x216c2(%rip), %rdx # 0x3b870
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x18(%rsp)
jne 0x1a23e
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1a1dd
movq (%rax), %r8
jmp 0x1a1e4
leaq 0x210d2(%rip), %r8 # 0x3b2b6
leaq 0x20fb2(%rip), %rdx # 0x3b19d
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0xa8, %ecx
callq 0xf680
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
leaq 0x10(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x1a23e
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1a23e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a23e
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1a259
callq 0x1a604
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1a268
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a277
callq 0x1a604
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x1a2ae
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf340
jmp 0x1a293
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1a2a2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1a380
jmp 0x1a2fc
movq %rax, %rdi
callq 0x1a51f
jmp 0x1a2f9
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a2db
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1a2db
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a31a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1a31a
movq %rax, %rbx
jmp 0x1a31a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1a30b
callq 0x1a604
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1a31a
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a329
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
testing::Message::~Message()
|
class GTEST_API_ Message {
private:
// The type of basic IO manipulators (endl, ends, and flush) for
// narrow streams.
typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
public:
// Constructs an empty Message.
Message();
// Copy constructor.
Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
}
// Constructs a Message from a C-string.
explicit Message(const char* str) : ss_(new ::std::stringstream) {
*ss_ << str;
}
#if GTEST_OS_SYMBIAN
// Streams a value (either a pointer or not) to this object.
template <typename T>
inline Message& operator <<(const T& value) {
StreamHelper(typename internal::is_pointer<T>::type(), value);
return *this;
}
#else
// Streams a non-pointer value to this object.
template <typename T>
inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator <<;
*ss_ << val;
return *this;
}
// Streams a pointer value to this object.
//
// This function is an overload of the previous one. When you
// stream a pointer to a Message, this definition will be used as it
// is more specialized. (The C++ Standard, section
// [temp.func.order].) If you stream a non-pointer, then the
// previous definition will be used.
//
// The reason for this overload is that streaming a NULL pointer to
// ostream is undefined behavior. Depending on the compiler, you
// may get "0", "(nil)", "(null)", or an access violation. To
// ensure consistent result across compilers, we always treat NULL
// as "(null)".
template <typename T>
inline Message& operator <<(T* const& pointer) { // NOLINT
if (pointer == NULL) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
return *this;
}
#endif // GTEST_OS_SYMBIAN
// Since the basic IO manipulators are overloaded for both narrow
// and wide streams, we have to provide this specialized definition
// of operator <<, even though its body is the same as the
// templatized version above. Without this definition, streaming
// endl or other basic IO manipulators to Message will confuse the
// compiler.
Message& operator <<(BasicNarrowIoManip val) {
*ss_ << val;
return *this;
}
// Instead of 1/0, we want to see true/false for bool values.
Message& operator <<(bool b) {
return *this << (b ? "true" : "false");
}
// These two overloads allow streaming a wide C string to a Message
// using the UTF-8 encoding.
Message& operator <<(const wchar_t* wide_c_str);
Message& operator <<(wchar_t* wide_c_str);
#if GTEST_HAS_STD_WSTRING
// Converts the given wide string to a narrow string using the UTF-8
// encoding, and streams the result to this Message object.
Message& operator <<(const ::std::wstring& wstr);
#endif // GTEST_HAS_STD_WSTRING
#if GTEST_HAS_GLOBAL_WSTRING
// Converts the given wide string to a narrow string using the UTF-8
// encoding, and streams the result to this Message object.
Message& operator <<(const ::wstring& wstr);
#endif // GTEST_HAS_GLOBAL_WSTRING
// Gets the text streamed to this object so far as an std::string.
// Each '\0' character in the buffer is replaced with "\\0".
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
std::string GetString() const;
private:
#if GTEST_OS_SYMBIAN
// These are needed as the Nokia Symbian Compiler cannot decide between
// const T& and const T* in a function template. The Nokia compiler _can_
// decide between class template specializations for T and T*, so a
// tr1::type_traits-like is_pointer works, and we can overload on that.
template <typename T>
inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
if (pointer == NULL) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
}
template <typename T>
inline void StreamHelper(internal::false_type /*is_pointer*/,
const T& value) {
// See the comments in Message& operator <<(const T&) above for why
// we need this using statement.
using ::operator <<;
*ss_ << value;
}
#endif // GTEST_OS_SYMBIAN
// We'll hold the text streamed to this object here.
const internal::scoped_ptr< ::std::stringstream> ss_;
// We declare (but don't implement) this to prevent the compiler
// from implementing the assignment operator.
void operator=(const Message&);
}
|
pushq %rax
xorl %esi, %esi
callq 0x1a57a
popq %rax
retq
movq %rax, %rdi
callq 0x1a51f
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult::~AssertionResult()
|
class GTEST_API_ AssertionResult {
public:
// Copy constructor.
// Used in EXPECT_TRUE/FALSE(assertion_result).
AssertionResult(const AssertionResult& other);
#if defined(_MSC_VER) && _MSC_VER < 1910
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
#endif
// Used in the EXPECT_TRUE/FALSE(bool_expression).
//
// T must be contextually convertible to bool.
//
// The second parameter prevents this overload from being considered if
// the argument is implicitly convertible to AssertionResult. In that case
// we want AssertionResult's copy constructor to be used.
template <typename T>
explicit AssertionResult(
const T& success,
typename internal::EnableIf<
!internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
/*enabler*/ = NULL)
: success_(success) {}
#if defined(_MSC_VER) && _MSC_VER < 1910
GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif
// Assignment operator.
AssertionResult& operator=(AssertionResult other) {
swap(other);
return *this;
}
// Returns true iff the assertion succeeded.
operator bool() const { return success_; } // NOLINT
// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
AssertionResult operator!() const;
// Returns the text streamed into this AssertionResult. Test assertions
// use it when they fail (i.e., the predicate's outcome doesn't match the
// assertion's expectation). When nothing has been streamed into the
// object, returns an empty string.
const char* message() const {
return message_.get() != NULL ? message_->c_str() : "";
}
// FIXME: Remove this after making sure no clients use it.
// Deprecated; please use message() instead.
const char* failure_message() const { return message(); }
// Streams a custom failure message into this object.
template <typename T> AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
// Allows streaming basic output manipulators such as endl or flush into
// this object.
AssertionResult& operator<<(
::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
AppendMessage(Message() << basic_manipulator);
return *this;
}
private:
// Appends the contents of message to message_.
void AppendMessage(const Message& a_message) {
if (message_.get() == NULL)
message_.reset(new ::std::string);
message_->append(a_message.GetString().c_str());
}
|
pushq %rax
addq $0x8, %rdi
xorl %esi, %esi
callq 0x1a5b0
popq %rax
retq
movq %rax, %rdi
callq 0x1a51f
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
ParserTransform_emptyCellml10_Test::~ParserTransform_emptyCellml10_Test()
|
TEST(ParserTransform, emptyCellml10)
{
const std::string e = "Given model is a CellML 1.0 model, the parser will try to represent this model in CellML 2.0.";
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.0#\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ(size_t(1), parser->issueCount());
EXPECT_EQ(libcellml::Issue::Level::MESSAGE, parser->issue(0)->level());
EXPECT_EQ(e, parser->issue(0)->description());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_attemptToParseUnknownXmlModelWithPermissiveParser_Test::~ParserTransform_attemptToParseUnknownXmlModelWithPermissiveParser_Test()
|
TEST(ParserTransform, attemptToParseUnknownXmlModelWithPermissiveParser)
{
const std::string e = "Model element is in an invalid namespace 'http://www.cellml.org/cellml/1.3#'.";
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.3#\" name=\"name\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ("", model->name());
EXPECT_EQ(size_t(1), parser->issueCount());
EXPECT_EQ(libcellml::Issue::Level::ERROR, parser->issue(0)->level());
EXPECT_EQ(e, parser->issue(0)->description());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_attemptToParseUnknownXmlModelWith20Parser_Test::~ParserTransform_attemptToParseUnknownXmlModelWith20Parser_Test()
|
TEST(ParserTransform, attemptToParseUnknownXmlModelWith20Parser)
{
const std::string e = "Model element is in an invalid namespace 'http://www.cellml.org/cellml/1.3#'. A valid CellML root node should be in the namespace 'http://www.cellml.org/cellml/2.0#'.";
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.3#\" name=\"name\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ("", model->name());
EXPECT_EQ(size_t(1), parser->issueCount());
EXPECT_EQ(libcellml::Issue::Level::ERROR, parser->issue(0)->level());
EXPECT_EQ(e, parser->issue(0)->description());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_attemptToParseCellml1XModelWith20Parser_Test::~ParserTransform_attemptToParseCellml1XModelWith20Parser_Test()
|
TEST(ParserTransform, attemptToParseCellml1XModelWith20Parser)
{
const std::string e = "Given model is a CellML 1.1 model but strict parsing mode is on.";
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.1#\" name=\"name\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ("", model->name());
EXPECT_EQ(size_t(1), parser->issueCount());
EXPECT_EQ(libcellml::Issue::Level::ERROR, parser->issue(0)->level());
EXPECT_EQ(e, parser->issue(0)->description());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_parseNamedModelCellml10_Test::~ParserTransform_parseNamedModelCellml10_Test()
|
TEST(ParserTransform, parseNamedModelCellml10)
{
const std::string n = "name";
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.0#\" name=\"name\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
libcellml::ModelPtr model = parser->parseModel(e);
EXPECT_EQ(n, model->name());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_hodgkinHuxleyCellml10_Test::~ParserTransform_hodgkinHuxleyCellml10_Test()
|
TEST(ParserTransform, hodgkinHuxleyCellml10)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/Hodgkin_Huxley_1952_modified.cellml"));
EXPECT_EQ(size_t(7), model->unitsCount());
EXPECT_EQ(size_t(5), model->componentCount());
EXPECT_EQ(size_t(4), parser->issueCount());
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(0), validator->issueCount());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_annotatedCellMl10Model_Test::~ParserTransform_annotatedCellMl10Model_Test()
|
TEST(ParserTransform, annotatedCellMl10Model)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/annotated_model.cellml"));
EXPECT_EQ(size_t(5), model->unitsCount());
EXPECT_EQ(size_t(2), model->componentCount());
EXPECT_EQ(size_t(78), parser->issueCount());
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(4), validator->issueCount());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
ParserTransform_renameNonSiUnits_Test::~ParserTransform_renameNonSiUnits_Test()
|
TEST(ParserTransform, renameNonSiUnits)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/non_si_units.cellml"));
EXPECT_EQ(size_t(11), model->unitsCount());
EXPECT_EQ(size_t(2), model->componentCount());
auto unitsMetre = model->units(0);
auto unitsLitre = model->units(1);
EXPECT_EQ("metre", unitsMetre->unitAttributeReference(0));
EXPECT_EQ("litre", unitsLitre->unitAttributeReference(0));
auto v1 = model->component(1)->variable(1);
auto v2 = model->component(1)->variable(3);
EXPECT_EQ("metre", v1->units()->name());
EXPECT_EQ("litre", v2->units()->name());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_0.cpp
|
testing::internal::scoped_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
|
void reset(T* p = NULL) {
if (p != ptr_) {
if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type.
delete ptr_;
}
ptr_ = p;
}
}
|
cmpq %rsi, (%rdi)
je 0x1a602
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1a5fa
movq (%r14), %r15
testq %r15, %r15
je 0x1a5ed
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x1a5ed
movq (%rax), %rsi
incq %rsi
callq 0xf390
movl $0x20, %esi
movq %r15, %rdi
callq 0xf390
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned long, unsigned long>(char const*, char const*, unsigned long const&, unsigned long const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x1abdd
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1abdd
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab6d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab88
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1abba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1abba
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1abd5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::PrintToString<unsigned long>(unsigned long const&)
|
::std::string PrintToString(const T& value) {
::std::stringstream ss;
internal::UniversalTersePrinter<T>::Print(value, &ss);
return ss.str();
}
|
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xf220
leaq 0x10(%rsp), %rdi
movq (%r14), %rsi
callq 0xf210
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xf580
movq 0x4639a(%rip), %rsi # 0x60fb0
movq %rsp, %rdi
callq 0xf250
leaq 0x80(%rsp), %rdi
callq 0xf0f0
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x4636d(%rip), %rsi # 0x60fb0
movq %rsp, %rdi
callq 0xf250
leaq 0x80(%rsp), %rdi
callq 0xf0f0
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<libcellml::Issue::Level, libcellml::Issue::Level>(char const*, char const*, libcellml::Issue::Level const&, libcellml::Issue::Level const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x1ad59
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1ad59
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ace9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ad04
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ad36
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1ad36
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ad51
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, 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&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%rcx), %rdx
cmpq 0x8(%r8), %rdx
jne 0x1ae17
testq %rdx, %rdx
je 0x1ae2d
movq (%r14), %rsi
movq (%r15), %rdi
callq 0xf3b0
testl %eax, %eax
je 0x1ae2d
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x1ae42
jmp 0x1ae35
movq %rbx, %rdi
callq 0xf070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, 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&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x1af19
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1af19
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1aea9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1aec4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1aef6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1aef6
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1af11
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [1], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [1], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xf0d0
movq %rbx, %rdi
testl %eax, %eax
je 0x1afd9
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x1afeb
jmp 0x1afde
callq 0xf070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [1], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [1], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1b0c7
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1af19
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b057
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b072
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b0a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1b0a4
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b0bf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*)
|
static void Print(const char* str, ::std::ostream* os) {
if (str == NULL) {
*os << "NULL";
} else {
UniversalPrint(std::string(str), os);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1b1b1
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xf150
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1aa4e
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf3c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b1a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20760(%rip), %rsi # 0x3b918
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf410
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b1ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xf0d0
movq %rbx, %rdi
testl %eax, %eax
je 0x1b22f
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x1b241
jmp 0x1b234
callq 0xf070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1b0c7
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1af19
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b2ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b2c8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b2fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1b2fa
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b315
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
nopl (%rax)
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
ParserTransform_cellmlNsCn_Test::TestBody()
|
TEST(ParserTransform, cellmlNsCn)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/cellml_ns_cn.cellml"));
EXPECT_EQ(size_t(2), model->unitsCount());
EXPECT_EQ(size_t(3), model->componentCount());
EXPECT_EQ(size_t(1), parser->issueCount());
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(0), validator->issueCount());
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x201f9(%rip), %rsi # 0x3c69c
leaq 0x2020e(%rip), %rdx # 0x3c6b8
leaq 0x10(%rsp), %rdi
callq 0x1aa4e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c4f0
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1c507
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x2, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xf080
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x1f225(%rip), %rsi # 0x3b74e
leaq 0x1f185(%rip), %rdx # 0x3b6b5
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x1c5c0
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x1c55f
movq (%rax), %r8
jmp 0x1c566
leaq 0x1ed50(%rip), %r8 # 0x3b2b6
leaq 0x1f987(%rip), %rdx # 0x3bef4
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x87, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x1c5c0
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1c5c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c5c0
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq $0x3, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xf0a0
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x200cb(%rip), %rsi # 0x3c6b9
leaq 0x1f0de(%rip), %rdx # 0x3b6d3
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x1c685
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x1c624
movq (%rax), %r8
jmp 0x1c62b
leaq 0x1ec8b(%rip), %r8 # 0x3b2b6
leaq 0x1f8c2(%rip), %rdx # 0x3bef4
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x88, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x1c685
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1c685
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c685
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq $0x1, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0xf690
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x1ec04(%rip), %rsi # 0x3b2b7
leaq 0x1ec07(%rip), %rdx # 0x3b2c1
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x30(%rsp)
jne 0x1c74a
leaq 0x10(%rsp), %rdi
callq 0xf2a0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x1c6e9
movq (%rax), %r8
jmp 0x1c6f0
leaq 0x1ebc6(%rip), %r8 # 0x3b2b6
leaq 0x1f7fd(%rip), %rdx # 0x3bef4
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x89, %ecx
callq 0xf680
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf290
leaq 0x8(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x10(%rsp)
je 0x1c74a
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1c74a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c74a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0xf630
movq (%rbx), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf370
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xf690
leaq 0x50(%rsp), %r8
movq %rax, (%r8)
leaq 0x1ef63(%rip), %rsi # 0x3b6f5
leaq 0x1ef66(%rip), %rdx # 0x3b6ff
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x10(%rsp)
jne 0x1c829
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x1c7c8
movq (%rax), %r8
jmp 0x1c7cf
leaq 0x1eae7(%rip), %r8 # 0x3b2b6
leaq 0x1f71e(%rip), %rdx # 0x3bef4
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x8e, %ecx
callq 0xf680
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
leaq 0x50(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x1c829
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1c829
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c829
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1c844
callq 0x1a604
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1c853
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1c862
callq 0x1a604
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x1c8e3
jmp 0x1c8e3
jmp 0x1c8e3
jmp 0x1c8e3
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf340
jmp 0x1c884
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1c893
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a380
jmp 0x1c92f
jmp 0x1c8ae
jmp 0x1c8bd
jmp 0x1c8cc
jmp 0x1c8ae
jmp 0x1c8bd
jmp 0x1c8cc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf340
jmp 0x1c8c0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1a36e
jmp 0x1c8cf
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1a380
jmp 0x1c947
jmp 0x1c8e3
jmp 0x1c92c
jmp 0x1c8e3
jmp 0x1c8e3
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c90e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1c90e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1c956
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1c956
movq %rax, %rbx
jmp 0x1c956
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1c947
callq 0x1a604
jmp 0x1c947
jmp 0x1c944
jmp 0x1c944
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1c956
callq 0x1a604
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1c965
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_1.cpp
|
ParserTransform_emptyCellml11_Test::~ParserTransform_emptyCellml11_Test()
|
TEST(ParserTransform, emptyCellml11)
{
const std::string e = "Given model is a CellML 1.1 model, the parser will try to represent this model in CellML 2.0.";
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.1#\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ(size_t(1), parser->issueCount());
EXPECT_EQ(libcellml::Issue::Level::MESSAGE, parser->issue(0)->level());
EXPECT_EQ(e, parser->issue(0)->description());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_1.cpp
|
ParserTransform_parseNamedModelCellml11_Test::~ParserTransform_parseNamedModelCellml11_Test()
|
TEST(ParserTransform, parseNamedModelCellml11)
{
const std::string n = "name";
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.1#\" name=\"name\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ(n, model->name());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_1.cpp
|
ParserTransform_parseModelWithCMeta10Id_Test::~ParserTransform_parseModelWithCMeta10Id_Test()
|
TEST(ParserTransform, parseModelWithCMeta10Id)
{
const std::string n = "name";
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/1.1#\" xmlns:cmeta=\"http://www.cellml.org/metadata/1.0#\" name=\"name\" cmeta:id=\"great_id\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ(n, model->name());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_1.cpp
|
ParserTransform_sineCellml11_Test::~ParserTransform_sineCellml11_Test()
|
TEST(ParserTransform, sineCellml11)
{
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"sin\" id=\"sin\">\n"
" <component name=\"sin\" id=\"sin\">\n"
" <variable name=\"x\" units=\"dimensionless\" interface=\"public_and_private\"/>\n"
" <variable name=\"sin\" units=\"dimensionless\" interface=\"public_and_private\" id=\"sin\"/>\n"
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply id=\"actual_sin\">\n"
" <eq/>\n"
" <ci>sin</ci>\n"
" <apply>\n"
" <sin/>\n"
" <ci>x</ci>\n"
" </apply>\n"
" </apply>\n"
" </math>\n"
" </component>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/sin.xml"));
EXPECT_EQ(size_t(2), parser->issueCount());
auto printer = libcellml::Printer::create();
auto a = printer->printModel(model);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_1.cpp
|
ParserTransform_derivedApproxSineCellml11_Test::~ParserTransform_derivedApproxSineCellml11_Test()
|
TEST(ParserTransform, derivedApproxSineCellml11)
{
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"deriv_approx_sin\" id=\"deriv_approx_sin\">\n"
" <component name=\"sin\" id=\"sin\">\n"
" <variable name=\"x\" units=\"dimensionless\" interface=\"public_and_private\" id=\"x\"/>\n"
" <variable name=\"sin\" units=\"dimensionless\" initial_value=\"sin_initial_value\" interface=\"public_and_private\" id=\"sin\"/>\n"
" <variable name=\"sin_initial_value\" units=\"dimensionless\" interface=\"public_and_private\"/>\n"
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply>\n"
" <eq/>\n"
" <apply>\n"
" <diff/>\n"
" <bvar>\n"
" <ci>x</ci>\n"
" </bvar>\n"
" <ci>sin</ci>\n"
" </apply>\n"
" <apply>\n"
" <cos/>\n"
" <ci>x</ci>\n"
" </apply>\n"
" </apply>\n"
" </math>\n"
" </component>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/deriv_approx_sin.xml"));
EXPECT_EQ(size_t(2), parser->issueCount());
auto printer = libcellml::Printer::create();
auto a = printer->printModel(model);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_1.cpp
|
ParserTransform_cellmlNsCn_Test::~ParserTransform_cellmlNsCn_Test()
|
TEST(ParserTransform, cellmlNsCn)
{
libcellml::ParserPtr parser = libcellml::Parser::create(false);
auto model = parser->parseModel(fileContents("cellml1X/cellml_ns_cn.cellml"));
EXPECT_EQ(size_t(2), model->unitsCount());
EXPECT_EQ(size_t(3), model->componentCount());
EXPECT_EQ(size_t(1), parser->issueCount());
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(0), validator->issueCount());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/cellml_1_1.cpp
|
Parser_parseSineModelFromFile_Test::TestBody()
|
TEST(Parser, parseSineModelFromFile)
{
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(fileContents("sine_approximations.xml"));
EXPECT_EQ(size_t(0), p->issueCount());
}
|
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1fe08(%rip), %rsi # 0x3ca14
leaq 0x1fe18(%rip), %rdx # 0x3ca2b
leaq 0x8(%rsp), %rdi
callq 0x1aa4e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1cc4d
callq 0x1a604
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cc68
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1cc7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf690
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x1ea56(%rip), %rsi # 0x3b6f5
leaq 0x1fd86(%rip), %rdx # 0x3ca2c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x28(%rsp)
jne 0x1cd30
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1ccd5
movq (%rax), %r8
jmp 0x1ccdc
leaq 0x1e5da(%rip), %r8 # 0x3b2b6
leaq 0x1fccf(%rip), %rdx # 0x3c9b2
movq %rsp, %rdi
movl $0x1, %esi
movl $0x21, %ecx
callq 0xf680
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
movq %rsp, %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x1cd30
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1cd30
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd30
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd4b
callq 0x1a604
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x1cd80
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf340
jmp 0x1cd65
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1cd74
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1a380
jmp 0x1cdc9
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cdab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1cdab
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1cdc9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1cdc9
jmp 0x1cdc6
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1cdd8
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_parseSineImportsModelFromFile_Test::TestBody()
|
TEST(Parser, parseSineImportsModelFromFile)
{
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(fileContents("sine_approximations_import.xml"));
EXPECT_EQ(size_t(0), p->issueCount());
}
|
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1fc4e(%rip), %rsi # 0x3ca5a
leaq 0x1fc65(%rip), %rdx # 0x3ca78
leaq 0x8(%rsp), %rdi
callq 0x1aa4e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1ce4d
callq 0x1a604
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ce68
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ce7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf690
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x1e856(%rip), %rsi # 0x3b6f5
leaq 0x1fb86(%rip), %rdx # 0x3ca2c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x28(%rsp)
jne 0x1cf30
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1ced5
movq (%rax), %r8
jmp 0x1cedc
leaq 0x1e3da(%rip), %r8 # 0x3b2b6
leaq 0x1facf(%rip), %rdx # 0x3c9b2
movq %rsp, %rdi
movl $0x1, %esi
movl $0x29, %ecx
callq 0xf680
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
movq %rsp, %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x1cf30
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1cf30
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf30
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf4b
callq 0x1a604
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x1cf80
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf340
jmp 0x1cf65
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1cf74
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1a380
jmp 0x1cfc9
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cfab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1cfab
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1cfc9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1cfc9
jmp 0x1cfc6
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1cfd8
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_parseOrdModelFromFile_Test::TestBody()
|
TEST(Parser, parseOrdModelFromFile)
{
libcellml::ParserPtr p = libcellml::Parser::create();
libcellml::ModelPtr model = p->parseModel(fileContents("Ohara_Rudy_2011.cellml"));
EXPECT_EQ(size_t(0), p->issueCount());
// Test some random values.
std::string a = model->component("intracellular_ions")->variable("BSLmax")->initialValue();
EXPECT_EQ("1.124", a);
a = model->component("INa")->variable("mtD2")->initialValue();
EXPECT_EQ("8.552", a);
a = model->component("IK1")->variable("GK1_b")->initialValue();
EXPECT_EQ("0.1908", a);
a = model->component("SERCA")->variable("Jup")->interfaceType();
EXPECT_EQ("public", a);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f8bc(%rip), %rsi # 0x3cb44
leaq 0x1f8cb(%rip), %rdx # 0x3cb5a
leaq 0x20(%rsp), %rdi
callq 0x1aa4e
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xf610
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x90(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x1d2e4
movq 0x90(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d2fb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x0, 0x20(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xf690
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x1e3d7(%rip), %rsi # 0x3b6f5
leaq 0x1f707(%rip), %rdx # 0x3ca2c
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x80(%rsp)
jne 0x1d3b8
leaq 0x20(%rsp), %rdi
callq 0xf2a0
movq 0x88(%rsp), %rax
testq %rax, %rax
je 0x1d35d
movq (%rax), %r8
jmp 0x1d364
leaq 0x1df52(%rip), %r8 # 0x3b2b6
leaq 0x1f647(%rip), %rdx # 0x3c9b2
movq %rsp, %rdi
movl $0x1, %esi
movl $0x3e, %ecx
callq 0xf680
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xf290
movq %rsp, %rdi
callq 0xf340
cmpq $0x0, 0x20(%rsp)
je 0x1d3b8
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1d3b8
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d3b8
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0xa0(%rsp), %rbx
leaq 0x20(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1f77d(%rip), %rsi # 0x3cb5b
leaq 0x1f788(%rip), %rdx # 0x3cb6d
callq 0x1aa4e
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
movl $0x1, %ecx
callq 0xf470
movq 0x60(%rsp), %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1f757(%rip), %rsi # 0x3cb6e
leaq 0x1f756(%rip), %rdx # 0x3cb74
movq %rsp, %rdi
callq 0x1aa4e
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0xf240
movq 0x40(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0xf420
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1d457
callq 0x1a604
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d46d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d47c
callq 0x1a604
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d493
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x1f6db(%rip), %rsi # 0x3cb75
leaq 0x1f6e4(%rip), %rdx # 0x3cb85
leaq 0x1f6d5(%rip), %rcx # 0x3cb7d
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %r8
callq 0x1b1f2
cmpb $0x0, 0x20(%rsp)
jne 0x1d535
movq %rsp, %rdi
callq 0xf2a0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x1d4d8
movq (%rax), %r8
jmp 0x1d4df
leaq 0x1ddd7(%rip), %r8 # 0x3b2b6
leaq 0x1f4cc(%rip), %rdx # 0x3c9b2
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x42, %ecx
callq 0xf680
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x40(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x1d535
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1d535
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d535
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0xa0(%rsp), %rbx
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1f62d(%rip), %rsi # 0x3cb83
leaq 0x1f629(%rip), %rdx # 0x3cb86
callq 0x1aa4e
leaq 0x70(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
movl $0x1, %ecx
callq 0xf470
movq 0x70(%rsp), %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1f5fb(%rip), %rsi # 0x3cb87
leaq 0x1f5f8(%rip), %rdx # 0x3cb8b
leaq 0x40(%rsp), %rdi
callq 0x1aa4e
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %rbx, %rsi
callq 0xf240
movq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf420
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0xf440
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1d5e8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d5f7
callq 0x1a604
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d60e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1d61d
callq 0x1a604
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d633
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x1f552(%rip), %rsi # 0x3cb8c
leaq 0x1f544(%rip), %rdx # 0x3cb85
leaq 0x1f54c(%rip), %rcx # 0x3cb94
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %r8
callq 0x1b1f2
cmpb $0x0, 0x20(%rsp)
jne 0x1d6d5
movq %rsp, %rdi
callq 0xf2a0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x1d678
movq (%rax), %r8
jmp 0x1d67f
leaq 0x1dc37(%rip), %r8 # 0x3b2b6
leaq 0x1f32c(%rip), %rdx # 0x3c9b2
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x45, %ecx
callq 0xf680
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x40(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x1d6d5
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1d6d5
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d6d5
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0xa0(%rsp), %rbx
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1f4a4(%rip), %rsi # 0x3cb9a
leaq 0x1f4a0(%rip), %rdx # 0x3cb9d
callq 0x1aa4e
leaq 0x70(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
movl $0x1, %ecx
callq 0xf470
movq 0x70(%rsp), %rbx
leaq 0x40(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1f473(%rip), %rsi # 0x3cb9e
leaq 0x1f471(%rip), %rdx # 0x3cba3
callq 0x1aa4e
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %rbx, %rsi
callq 0xf240
movq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf420
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0xf440
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1d782
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d791
callq 0x1a604
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d7a8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1d7b7
callq 0x1a604
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d7cd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x1f3d0(%rip), %rsi # 0x3cba4
leaq 0x1f3aa(%rip), %rdx # 0x3cb85
leaq 0x1f3cb(%rip), %rcx # 0x3cbad
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %r8
callq 0x1f4ec
cmpb $0x0, 0x20(%rsp)
jne 0x1d86f
movq %rsp, %rdi
callq 0xf2a0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x1d812
movq (%rax), %r8
jmp 0x1d819
leaq 0x1da9d(%rip), %r8 # 0x3b2b6
leaq 0x1f192(%rip), %rdx # 0x3c9b2
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x48, %ecx
callq 0xf680
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x40(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x1d86f
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1d86f
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d86f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0xa0(%rsp), %rbx
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1f324(%rip), %rsi # 0x3cbb4
leaq 0x1f322(%rip), %rdx # 0x3cbb9
callq 0x1aa4e
leaq 0x70(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
movl $0x1, %ecx
callq 0xf470
movq 0x70(%rsp), %rbx
leaq 0x40(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1f2f5(%rip), %rsi # 0x3cbba
leaq 0x1f2f1(%rip), %rdx # 0x3cbbd
callq 0x1aa4e
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %rbx, %rsi
callq 0xf240
movq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf090
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0xf440
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1d91c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1d92b
callq 0x1a604
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d942
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1d951
callq 0x1a604
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d967
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x1f250(%rip), %rsi # 0x3cbbe
leaq 0x1f210(%rip), %rdx # 0x3cb85
leaq 0x1f24b(%rip), %rcx # 0x3cbc7
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %r8
callq 0x1f4ec
cmpb $0x0, 0x20(%rsp)
jne 0x1da09
movq %rsp, %rdi
callq 0xf2a0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x1d9ac
movq (%rax), %r8
jmp 0x1d9b3
leaq 0x1d903(%rip), %r8 # 0x3b2b6
leaq 0x1eff8(%rip), %rdx # 0x3c9b2
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x4b, %ecx
callq 0xf680
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x40(%rsp), %rdi
callq 0xf340
cmpq $0x0, (%rsp)
je 0x1da09
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1da09
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1da09
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x1da32
movq 0x90(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x1da44
callq 0x1a604
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1da56
callq 0x1a604
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1dc2b
jmp 0x1dc2b
jmp 0x1dc2b
jmp 0x1dc2b
jmp 0x1dc2b
jmp 0x1da92
jmp 0x1daa1
jmp 0x1daae
jmp 0x1da92
jmp 0x1daa1
jmp 0x1daae
jmp 0x1da92
jmp 0x1daa1
jmp 0x1daae
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf340
jmp 0x1daa4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a36e
jmp 0x1dab1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1a380
jmp 0x1db86
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf340
jmp 0x1dad0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1a36e
jmp 0x1dadf
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x1a380
jmp 0x1dba3
jmp 0x1dc2b
jmp 0x1db83
jmp 0x1db1d
jmp 0x1db31
jmp 0x1db4d
jmp 0x1db61
jmp 0x1db83
jmp 0x1dc2b
jmp 0x1db83
jmp 0x1db1d
jmp 0x1db31
jmp 0x1db4d
jmp 0x1db61
jmp 0x1db83
jmp 0x1dc2b
jmp 0x1db83
movq %rax, %rbx
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1db34
callq 0x1a604
jmp 0x1db34
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1db50
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1db50
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1db64
callq 0x1a604
jmp 0x1db64
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1db86
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1db86
jmp 0x1db83
jmp 0x1dc2b
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x1dba3
movq 0x90(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x1dbb5
callq 0x1a604
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1dbc7
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1dbe6
callq 0x1a604
jmp 0x1dbe6
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1dc01
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1dc01
movq %rax, %rbx
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1dc15
callq 0x1a604
jmp 0x1dc15
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dba3
movq 0x30(%rsp), %rsi
jmp 0x1db9b
jmp 0x1dc84
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dc5c
movq 0x90(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1dc5c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dbb5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1dbb5
movq %rax, %rbx
jmp 0x1dbb5
movq %rax, %rbx
jmp 0x1dba3
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_parseComplexEncapsulationModelFromFile_Test::TestBody()
|
TEST(Parser, parseComplexEncapsulationModelFromFile)
{
// This test resulted from https://github.com/cellml/libcellml/issues/170
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(fileContents("complex_encapsulation.xml"));
EXPECT_EQ(size_t(0), p->issueCount());
}
|
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1ef3d(%rip), %rsi # 0x3cbf5
leaq 0x1ef4f(%rip), %rdx # 0x3cc0e
leaq 0x8(%rsp), %rdi
callq 0x1aa4e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf610
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1dcf9
callq 0x1a604
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dd14
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1dd2b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf690
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x1d9aa(%rip), %rsi # 0x3b6f5
leaq 0x1ecda(%rip), %rdx # 0x3ca2c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x28(%rsp)
jne 0x1dddc
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1dd81
movq (%rax), %r8
jmp 0x1dd88
leaq 0x1d52e(%rip), %r8 # 0x3b2b6
leaq 0x1ec23(%rip), %rdx # 0x3c9b2
movq %rsp, %rdi
movl $0x1, %esi
movl $0x54, %ecx
callq 0xf680
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
movq %rsp, %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x1dddc
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1dddc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1dddc
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1ddf7
callq 0x1a604
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x1de2c
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf340
jmp 0x1de11
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1de20
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1a380
jmp 0x1de75
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1de57
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1de57
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1de75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1de75
jmp 0x1de72
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1de84
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_parseModelWithImportedEquivVariables_Test::TestBody()
|
TEST(Parser, parseModelWithImportedEquivVariables)
{
auto parser = libcellml::Parser::create();
auto modelContents = fileContents("importingModel.cellml");
auto model = parser->parseModel(modelContents);
auto printer = libcellml::Printer::create();
auto serialisedModel = printer->printModel(model);
EXPECT_EQ(modelContents, serialisedModel);
}
|
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xf560
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1e7db(%rip), %rsi # 0x3d106
leaq 0x1e7e9(%rip), %rdx # 0x3d11b
leaq 0x18(%rsp), %rdi
callq 0x1aa4e
leaq 0x68(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf610
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1e962
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x58(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0xf3d0
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0xf430
movq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
xorl %ecx, %ecx
callq 0xf4a0
leaq 0x1e77b(%rip), %rsi # 0x3d11c
leaq 0x1e782(%rip), %rdx # 0x3d12a
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0x1ade1
cmpb $0x0, 0x38(%rsp)
jne 0x1ea3d
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x1e9dc
movq (%rax), %r8
jmp 0x1e9e3
leaq 0x1c8d3(%rip), %r8 # 0x3b2b6
leaq 0x1dfc8(%rip), %rdx # 0x3c9b2
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0xa3, %ecx
callq 0xf680
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
leaq 0x10(%rsp), %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x1ea3d
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1ea3d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ea3d
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ea60
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1ea72
callq 0x1a604
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1ea81
callq 0x1a604
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ea9c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1eaab
callq 0x1a604
addq $0x98, %rsp
popq %rbx
popq %r14
retq
jmp 0x1eae5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf340
jmp 0x1eaca
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1ead9
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1a380
jmp 0x1eaf0
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1eb0c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1eb0c
movq %rax, %rbx
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1eb1e
callq 0x1a604
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1eb32
callq 0x1a604
jmp 0x1eb32
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eb66
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1eb66
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1eb66
movq 0x28(%rsp), %rsi
jmp 0x1eb45
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1eb75
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_unitsAreLinkedOnParse_Test::TestBody()
|
TEST(Parser, unitsAreLinkedOnParse)
{
libcellml::ParserPtr p = libcellml::Parser::create();
auto model = p->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
EXPECT_EQ(size_t(0), p->issueCount());
EXPECT_FALSE(model->hasUnlinkedUnits());
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf560
movq (%rbx), %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1e5a4(%rip), %rsi # 0x3d150
leaq 0x1e5d8(%rip), %rdx # 0x3d18b
leaq 0x8(%rsp), %rdi
callq 0x1aa4e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf610
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0xf3d0
leaq 0x38(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x1ebf9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ec10
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
movq $0x0, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0xf690
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x1cac5(%rip), %rsi # 0x3b6f5
leaq 0x1ddf5(%rip), %rdx # 0x3ca2c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x1aae3
cmpb $0x0, 0x28(%rsp)
jne 0x1ecc1
leaq 0x8(%rsp), %rdi
callq 0xf2a0
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1ec66
movq (%rax), %r8
jmp 0x1ec6d
leaq 0x1c649(%rip), %r8 # 0x3b2b6
leaq 0x1dd3e(%rip), %rdx # 0x3c9b2
movq %rsp, %rdi
movl $0x1, %esi
movl $0xab, %ecx
callq 0xf680
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf290
movq %rsp, %rdi
callq 0xf340
cmpq $0x0, 0x8(%rsp)
je 0x1ecc1
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1ecc1
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ecc1
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x50(%rsp), %rdi
callq 0xf6d0
movl %eax, %ecx
xorb $0x1, %cl
movb %cl, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
testb %al, %al
je 0x1ed8f
movq %rsp, %rdi
callq 0xf2a0
leaq 0x1e48c(%rip), %rdx # 0x3d18c
leaq 0x1e49f(%rip), %rcx # 0x3d1a6
leaq 0x1e49d(%rip), %r8 # 0x3d1ab
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf2e0
movq 0x28(%rsp), %r8
leaq 0x1dc89(%rip), %rdx # 0x3c9b2
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
movl $0xad, %ecx
callq 0xf680
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0xf290
leaq 0x48(%rsp), %rdi
callq 0xf340
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ed6b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
cmpq $0x0, (%rsp)
je 0x1ed8f
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x1ed8f
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ed8f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1edaa
callq 0x1a604
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1edb9
callq 0x1a604
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ee38
jmp 0x1ee38
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf340
jmp 0x1edd9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1edf5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1edf5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a36e
jmp 0x1ee02
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x1ee2d
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf340
jmp 0x1ee19
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
jmp 0x1ee28
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1a380
jmp 0x1ee84
jmp 0x1ee38
jmp 0x1ee81
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ee63
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1ee63
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ee93
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1ee93
movq %rax, %rbx
jmp 0x1ee93
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1ee93
callq 0x1a604
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1eea2
callq 0x1a604
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
testing::ScopedTrace::ScopedTrace(char const*, int, char const*)
|
ScopedTrace(const char* file, int line, const char* message) {
PushTrace(file, line, message ? message : "(null)");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
leaq 0x1e29f(%rip), %r12 # 0x3d1b1
cmovneq %rcx, %r12
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %r12, %rdi
callq 0xf150
leaq (%rax,%r12), %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1aa4e
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0xf5d0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ef62
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ef8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
Parser_parseInvalidModelFromFile_Test::~Parser_parseInvalidModelFromFile_Test()
|
TEST(Parser, parseInvalidModelFromFile)
{
const std::vector<std::string> expectedIssues = {
"LibXml2 error: Start tag expected, '<' not found.",
"Could not get a valid XML root node from the provided input.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(fileContents("invalid_cellml_2.0.xml"));
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_parseOrdModelFromFile_Test::~Parser_parseOrdModelFromFile_Test()
|
TEST(Parser, parseOrdModelFromFile)
{
libcellml::ParserPtr p = libcellml::Parser::create();
libcellml::ModelPtr model = p->parseModel(fileContents("Ohara_Rudy_2011.cellml"));
EXPECT_EQ(size_t(0), p->issueCount());
// Test some random values.
std::string a = model->component("intracellular_ions")->variable("BSLmax")->initialValue();
EXPECT_EQ("1.124", a);
a = model->component("INa")->variable("mtD2")->initialValue();
EXPECT_EQ("8.552", a);
a = model->component("IK1")->variable("GK1_b")->initialValue();
EXPECT_EQ("0.1908", a);
a = model->component("SERCA")->variable("Jup")->interfaceType();
EXPECT_EQ("public", a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_parseModelWithComponentsWithMultipleMathElements_Test::~Parser_parseModelWithComponentsWithMultipleMathElements_Test()
|
TEST(Parser, parseModelWithComponentsWithMultipleMathElements)
{
// This test resulted from https://github.com/cellml/libcellml/issues/183
const std::string e1 =
"<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
"\t\t\t<apply><eq/>\n"
"\t\t\t\t<ci>a1</ci>\n"
"\t\t\t\t<apply><plus/>\n"
"\t\t\t\t\t<ci>b1</ci>\n"
"\t\t\t\t\t<ci>c1</ci>\n"
"\t\t\t\t</apply>\n"
"\t\t\t</apply>\n"
"\t\t</math>\n";
const std::string e2 =
"<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
"\t\t\t<apply><eq/>\n"
"\t\t\t\t<ci>b2</ci>\n"
"\t\t\t\t<apply><times/>\n"
"\t\t\t\t\t<cn xmlns:cellml=\"http://www.cellml.org/cellml/2.0#\" cellml:units=\"dimensionless\">2.0</cn>\n"
"\t\t\t\t\t<ci>d</ci>\n"
"\t\t\t\t</apply>\n"
"\t\t\t</apply>\n"
"\t\t</math>\n"
"<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
"\t\t\t<apply><eq/>\n"
"\t\t\t\t<ci>d</ci>\n"
"\t\t\t\t<cn xmlns:cellml=\"http://www.cellml.org/cellml/2.0#\" cellml:units=\"dimensionless\" type=\"e-notation\">0.5<sep/>1</cn>\n"
"\t\t\t</apply>\n"
"\t\t</math>\n";
libcellml::ParserPtr p = libcellml::Parser::create();
libcellml::ModelPtr model = p->parseModel(fileContents("a_plus_b.cellml"));
EXPECT_EQ(size_t(0), p->issueCount());
std::string a = model->component("c1")->math();
EXPECT_EQ(e1, a);
a = model->component("c2")->math();
EXPECT_EQ(e2, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_simpleGeneratorModel_Test::~Parser_simpleGeneratorModel_Test()
|
TEST(Parser, simpleGeneratorModel)
{
const std::string e =
"<math xmlns=\"http://www.w3.org/1998/Math/MathML\" xmlns:cellml=\"http://www.cellml.org/cellml/2.0#\">\n"
" <apply>\n"
" <eq/>\n"
" <apply>\n"
" <diff/>\n"
" <bvar>\n"
" <ci>time</ci>\n"
" </bvar>\n"
" <ci>x</ci>\n"
" </apply>\n"
" <cn cellml:units=\"per_second\">1</cn>\n"
" </apply>\n"
" </math>\n";
libcellml::ParserPtr p = libcellml::Parser::create();
libcellml::ModelPtr model = p->parseModel(fileContents("analyser/initialised_variable_of_integration.cellml"));
EXPECT_EQ(size_t(0), p->issueCount());
std::string a = model->component("my_component")->math();
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
Parser_parseModelWithImportedEquivVariables_Test::~Parser_parseModelWithImportedEquivVariables_Test()
|
TEST(Parser, parseModelWithImportedEquivVariables)
{
auto parser = libcellml::Parser::create();
auto modelContents = fileContents("importingModel.cellml");
auto model = parser->parseModel(modelContents);
auto printer = libcellml::Printer::create();
auto serialisedModel = printer->printModel(model);
EXPECT_EQ(modelContents, serialisedModel);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/file_parser.cpp
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xf0d0
movq %rbx, %rdi
testl %eax, %eax
je 0x1f529
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x1f53b
jmp 0x1f52e
callq 0xf070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1b0c7
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1af19
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f5a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f5c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f5f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1f5f4
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f60f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
nop
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
Parser_parseValidXmlDirectlyUsingLibxml_Test::~Parser_parseValidXmlDirectlyUsingLibxml_Test()
|
TEST(Parser, parseValidXmlDirectlyUsingLibxml)
{
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\"/>\n";
// parse the string using libcellml
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(e);
libcellml::PrinterPtr printer = libcellml::Printer::create();
const std::string a = printer->printModel(model);
EXPECT_EQ(e, a);
// and now parse directly using libxml2
xmlInitParser();
xmlParserCtxtPtr context = xmlNewParserCtxt();
xmlSetStructuredErrorFunc(context, structuredErrorCallback);
xmlDocPtr doc = xmlCtxtReadDoc(context, reinterpret_cast<const xmlChar *>(e.c_str()), "/", nullptr, 0);
xmlFreeParserCtxt(context);
EXPECT_NE(nullptr, doc);
xmlFreeDoc(doc);
xmlSetStructuredErrorFunc(nullptr, nullptr);
xmlCleanupParser();
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/libxml_user.cpp
|
testing::AssertionResult testing::internal::CmpHelperOpFailure<std::nullptr_t, _xmlDoc*>(char const*, char const*, std::nullptr_t const&, _xmlDoc* const&, char const*)
|
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << FormatForComparisonFailureMessage(val1, val2)
<< " vs " << FormatForComparisonFailureMessage(val2, val1);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0xf040
leaq 0x1da09(%rip), %rsi # 0x3d7d3
movq %r12, %rdi
callq 0x1ff2a
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1ffc0
leaq 0x1d9f9(%rip), %rsi # 0x3d7df
movq %rax, %rdi
callq 0x20066
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1ffc0
leaq 0x1d9dc(%rip), %rsi # 0x3d7dc
movq %rax, %rdi
callq 0x20066
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1ffc0
leaq 0x1d9c6(%rip), %rsi # 0x3d7e2
movq %rax, %rdi
callq 0x1ff2a
movq %rax, %r12
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x202c9
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
callq 0x200fc
leaq 0x1d9a6(%rip), %rsi # 0x3d7ee
movq %rax, %rdi
callq 0x20188
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x20354
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x200fc
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf540
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fe93
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1feae
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x1a5b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1a51f
jmp 0x1fef5
jmp 0x1ff15
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fef8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1fef8
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ff18
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x1ff18
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1a380
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [5]>(char const (&) [5])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf2a0
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xf150
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf410
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2021e
cmpq $0x0, 0x8(%rsp)
je 0x201f4
movl $0x1, %edi
callq 0xf200
testb %al, %al
je 0x201f4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x201f4
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1a51f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a36e
movq %rbx, %rdi
callq 0xf640
|
/cellml[P]libcellml/tests/gtest/include/gtest/gtest.h
|
Parser_invalidXMLElements_Test::~Parser_invalidXMLElements_Test()
|
TEST(Parser, invalidXMLElements)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<fellowship>\n"
" <Dwarf bearded>Gimli</ShortGuy>\n"
" <Hobbit>Frodo</EvenShorterGuy>\n"
" <Wizard>Gandalf</SomeGuyWithAStaff>\n"
" <Elf>\n"
"</fellows>\n";
// Depending on the libXML2 version the error messages differ.
const std::vector<std::string> expectedIssues_2_2 = {
"LibXml2 error: Specification mandate value for attribute bearded.",
"LibXml2 error: Opening and ending tag mismatch: Dwarf line 3 and ShortGuy.",
"LibXml2 error: Opening and ending tag mismatch: Hobbit line 4 and EvenShorterGuy.",
"LibXml2 error: Opening and ending tag mismatch: Wizard line 5 and SomeGuyWithAStaff.",
"LibXml2 error: Opening and ending tag mismatch: Elf line 6 and fellows.",
"LibXml2 error: Premature end of data in tag fellowship line 2.",
"Could not get a valid XML root node from the provided input.",
};
const std::vector<std::string> expectedIssues_2_9_10 = {
"LibXml2 error: Specification mandates value for attribute bearded.",
"LibXml2 error: Opening and ending tag mismatch: Dwarf line 2 and ShortGuy.",
"LibXml2 error: Opening and ending tag mismatch: Hobbit line 2 and EvenShorterGuy.",
"LibXml2 error: Opening and ending tag mismatch: Wizard line 2 and SomeGuyWithAStaff.",
"LibXml2 error: Opening and ending tag mismatch: Elf line 2 and fellows.",
"LibXml2 error: EndTag: '</' not found.",
"Could not get a valid XML root node from the provided input.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in);
EXPECT_EQ(expectedIssues_2_2.size(), p->issueCount());
for (size_t i = 0; i < p->issueCount(); ++i) {
auto message = p->issue(i)->description();
EXPECT_TRUE((expectedIssues_2_2.at(i) == message) || (expectedIssues_2_9_10.at(i) == message));
}
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_parse_Test::~Parser_parse_Test()
|
TEST(Parser, parse)
{
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\"/>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(e);
libcellml::PrinterPtr printer = libcellml::Printer::create();
const std::string a = printer->printModel(model);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_nonXmlString_Test::~Parser_nonXmlString_Test()
|
TEST(Parser, nonXmlString)
{
const std::string in = "Not an xml string.";
const std::vector<std::string> expectedIssues = {
"LibXml2 error: Start tag expected, '<' not found.",
"Could not get a valid XML root node from the provided input.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_noModelNamespace_Test::~Parser_noModelNamespace_Test()
|
TEST(Parser, noModelNamespace)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model/>\n";
const std::vector<std::string> expectedIssues = {
"Model element is in an invalid namespace 'null'. A valid CellML root node should be in the namespace 'http://www.cellml.org/cellml/2.0#'.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_invalidModelElement_Test::~Parser_invalidModelElement_Test()
|
TEST(Parser, invalidModelElement)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <uknits/>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Model 'model_name' has an invalid child element 'uknits'.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_parseNamedModelWithNamedComponent_Test::~Parser_parseNamedModelWithNamedComponent_Test()
|
TEST(Parser, parseNamedModelWithNamedComponent)
{
const std::string mName = "modelName";
const std::string cName = "componentName";
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"modelName\">\n"
" <component name=\"componentName\"/>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(e);
EXPECT_EQ(mName, model->name());
libcellml::ComponentPtr c = model->component(cName);
EXPECT_EQ(cName, c->name());
libcellml::PrinterPtr printer = libcellml::Printer::create();
const std::string a = printer->printModel(model);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_componentAttributeIssues_Test::~Parser_componentAttributeIssues_Test()
|
TEST(Parser, componentAttributeIssues)
{
const std::string in1 =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <component lame=\"randy\"/>\n"
"</model>\n";
const std::vector<std::string> expectedIssues1 = {
"Component '' has an invalid attribute 'lame'.",
"Component does not specify a name attribute.",
};
const std::string in2 =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <component name=\"randy\" son=\"stan\"/>\n"
"</model>\n";
const std::vector<std::string> expectedIssues2 = {
"Component 'randy' has an invalid attribute 'son'.",
};
const std::string in3 =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <component son=\"stan\" name=\"randy\"/>\n"
"</model>\n";
const std::vector<std::string> expectedIssues3 = {
"Component 'randy' has an invalid attribute 'son'.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in1);
EXPECT_EQ_ISSUES(expectedIssues1, p);
p->parseModel(in2);
EXPECT_EQ_ISSUES(expectedIssues2, p);
p->parseModel(in3);
EXPECT_EQ_ISSUES(expectedIssues3, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_parseModelWithComponentHierarchyWaterfall_Test::~Parser_parseModelWithComponentHierarchyWaterfall_Test()
|
TEST(Parser, parseModelWithComponentHierarchyWaterfall)
{
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <component name=\"dave\"/>\n"
" <component name=\"bob\"/>\n"
" <component name=\"angus\"/>\n"
" <encapsulation>\n"
" <component_ref component=\"dave\">\n"
" <component_ref component=\"bob\">\n"
" <component_ref component=\"angus\"/>\n"
" </component_ref>\n"
" </component_ref>\n"
" </encapsulation>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(e);
libcellml::PrinterPtr printer = libcellml::Printer::create();
const std::string a = printer->printModel(model);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_modelWithInvalidUnits_Test::~Parser_modelWithInvalidUnits_Test()
|
TEST(Parser, modelWithInvalidUnits)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <units name=\"fahrenheitish\" temperature=\"451\">\n"
" <unit multiplier=\"Z\" exponent=\"35.0E+310\" units=\"kelvin\" bill=\"murray\">\n"
" <degrees/>\n"
" </unit>\n"
" <unit multiplier=\"-35.0E+310\" units=\"kelvin\"/>\n"
" <bobshouse address=\"34 Rich Lane\"/>\n"
" <unit GUnit=\"50c\"/>\n"
" </units>\n"
" <units name=\"dimensionless\"/>\n"
" <units jerry=\"seinfeld\">\n"
" <unit units=\"friends\" neighbor=\"kramer\"/>\n"
" <unit george=\"friends\"/>\n"
" </units>\n"
"</model>\n";
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <units name=\"fahrenheitish\">\n"
" <unit units=\"kelvin\"/>\n"
" <unit units=\"kelvin\"/>\n"
" <unit units=\"\"/>\n"
" </units>\n"
" <units>\n"
" <unit units=\"friends\"/>\n"
" <unit units=\"\"/>\n"
" </units>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Units 'fahrenheitish' has an invalid attribute 'temperature'.",
"Unit referencing 'kelvin' in units 'fahrenheitish' has an invalid child element 'degrees'.",
"Unit referencing 'kelvin' in units 'fahrenheitish' has a multiplier with the value 'Z' that is not a representation of a CellML real valued number.",
"Unit referencing 'kelvin' in units 'fahrenheitish' has an exponent with the value '35.0E+310' that is a representation of a CellML real valued number, but out of range of the 'double' type.",
"Unit referencing 'kelvin' in units 'fahrenheitish' has an invalid attribute 'bill'.",
"Unit referencing 'kelvin' in units 'fahrenheitish' has a multiplier with the value '-35.0E+310' that is a representation of a CellML real valued number, but out of range of the 'double' type.",
"Units 'fahrenheitish' has an invalid child element 'bobshouse'.",
"Unit referencing '' in units 'fahrenheitish' has an invalid attribute 'GUnit'.",
"Unit does not specify a units attribute.",
"Units '' has an invalid attribute 'jerry'.",
"Units does not specify a name attribute.",
"Unit referencing 'friends' in units '' has an invalid attribute 'neighbor'.",
"Unit referencing '' in units '' has an invalid attribute 'george'.",
"Unit does not specify a units attribute.",
};
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, parser);
libcellml::PrinterPtr printer = libcellml::Printer::create();
const std::string a = printer->printModel(model);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_encapsulationWithCycleDefined_Test::~Parser_encapsulationWithCycleDefined_Test()
|
TEST(Parser, encapsulationWithCycleDefined)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <component name=\"bob\"/>\n"
" <component name=\"jim\"/>\n"
" <component name=\"dave\"/>\n"
" <component name=\"bob\"/>\n"
" <encapsulation>\n"
" <component_ref component=\"bob\">\n"
" <component_ref component=\"jim\">\n"
" <component_ref component=\"dave\">\n"
" <component_ref component=\"bob\"/>\n"
" </component_ref>\n"
" </component_ref>\n"
" </component_ref>\n"
" </encapsulation>\n"
"</model>\n";
const std::vector<std::string> expectedIssuesParser = {
"Encapsulation in model 'model_name' specifies 'bob' as a component in a component_ref but it is not unique.",
};
const std::vector<std::string> expectedIssuesValidator = {
"Model 'model_name' contains multiple components with the name 'bob'. Valid component names must be unique to their model.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
auto m = p->parseModel(in);
EXPECT_EQ(size_t(1), p->issueCount());
EXPECT_EQ_ISSUES(expectedIssuesParser, p);
libcellml::PrinterPtr printer = libcellml::Printer::create();
auto output = printer->printModel(m);
EXPECT_EQ(output, in);
libcellml::ValidatorPtr v = libcellml::Validator::create();
v->validateModel(m);
EXPECT_EQ_ISSUES(expectedIssuesValidator, v);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_encapsulationNoChildComponentRef_Test::~Parser_encapsulationNoChildComponentRef_Test()
|
TEST(Parser, encapsulationNoChildComponentRef)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <component name=\"bob\"/>\n"
" <encapsulation>\n"
" <component_ref component=\"bob\">\n"
" <component_free/>\n"
" </component_ref>\n"
" </encapsulation>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Encapsulation in model 'model_name' has an invalid child element 'component_free'.",
"Encapsulation in model 'model_name' specifies 'bob' as a parent component_ref but it does not have any children.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_invalidVariableAttributesAndGetVariableIssue_Test::~Parser_invalidVariableAttributesAndGetVariableIssue_Test()
|
TEST(Parser, invalidVariableAttributesAndGetVariableIssue)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"\">\n"
" <component name=\"componentA\">\n"
" <variable name=\"quixote\" don=\"true\"/>\n"
" <variable name=\"\" units=\"\" windmill=\"tilted\"/>\n"
" <variable units=\"bobs\"/>\n"
" </component>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Variable 'quixote' has an invalid attribute 'don'.",
"Variable 'quixote' does not specify a units attribute.",
"Variable '' has an invalid attribute 'windmill'.",
"Variable with units 'bobs' does not specify a name attribute.",
"Model does not contain the units '' required by variable '' in component 'componentA'.",
"Model does not contain the units 'bobs' required by variable '' in component 'componentA'.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
libcellml::ModelPtr model = p->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, p);
libcellml::VariablePtr variableExpected = model->component("componentA")->variable("quixote");
// Get variable from issue and check.
EXPECT_EQ(variableExpected, p->issue(0)->item()->variable());
// Get const variable from issue and check.
libcellml::IssuePtr issue = p->issue(0);
libcellml::Issue *rawIssue = issue.get();
const libcellml::VariablePtr variableFromIssue = rawIssue->item()->variable();
EXPECT_EQ(variableExpected, variableFromIssue);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_emptyConnectionWithId_Test::~Parser_emptyConnectionWithId_Test()
|
TEST(Parser, emptyConnectionWithId)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <connection id=\"myId\"/>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Connection in model 'model_name' does not specify a component_1 in a connection element.",
"Connection in model 'model_name' does not specify a component_2 in a connection element.",
"Connection in model 'model_name' has an identifier of 'myId' but does not contain any 'map_variables' elements. The connection will be disregarded and the associated identifier will be lost.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_importedComponent2Connection_Test::~Parser_importedComponent2Connection_Test()
|
TEST(Parser, importedComponent2Connection)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model name=\"\" xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <import xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href=\"some-other-model.xml\">\n"
" <component component_ref=\"component_in_that_model\" name=\"component_in_this_model\"/>\n"
" </import>\n"
" <component name=\"component_bob\">\n"
" <variable name=\"variable_bob\" units=\"dimensionless\"/>\n"
" </component>\n"
" <connection component_2=\"component_in_this_model\" component_1=\"component_bob\">\n"
" <map_variables variable_2=\"variable_import\" variable_1=\"variable_bob\"/>\n"
" </connection>\n"
"</model>\n";
// Parse
libcellml::ParserPtr parser = libcellml::Parser::create();
parser->parseModel(in);
EXPECT_EQ(size_t(0), parser->issueCount());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_component2ConnectionVariableMissing_Test::~Parser_component2ConnectionVariableMissing_Test()
|
TEST(Parser, component2ConnectionVariableMissing)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model name=\"\" xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <component name=\"component_bob\">\n"
" <variable name=\"variable_bob\" units=\"dimensionless\"/>\n"
" </component>\n"
" <component name=\"component_dave\">\n"
" <variable name=\"variable_dave\" units=\"dimensionless\"/>\n"
" </component>\n"
" <connection component_2=\"component_dave\" component_1=\"component_bob\">\n"
" <map_variables variable_2=\"variable_angus\" variable_1=\"variable_bob\"/>\n"
" </connection>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Variable 'variable_angus' is specified as variable_2 in a connection but it does not exist in component_2 component 'component_dave' of model ''.",
};
// Parse
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(in);
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_connectionVariable1Missing_Test::~Parser_connectionVariable1Missing_Test()
|
TEST(Parser, connectionVariable1Missing)
{
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model name=\"\" xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <component name=\"component_bob\">\n"
" <variable name=\"variable_bob\" units=\"scrat\"/>\n"
" </component>\n"
" <component name=\"component_dave\">\n"
" <variable name=\"variable_dave\" units=\"gone\"/>\n"
" </component>\n"
" <connection component_2=\"component_dave\" component_1=\"component_bob\">\n"
" <map_variables variable_2=\"variable_dave\"/>\n"
" </connection>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Connection in model '' does not specify a variable_1 in a map_variables element.",
"Model does not contain the units 'scrat' required by variable 'variable_bob' in component 'component_bob'.",
"Model does not contain the units 'gone' required by variable 'variable_dave' in component 'component_dave'.",
};
// Parse
libcellml::ParserPtr p = libcellml::Parser::create();
p->parseModel(e);
EXPECT_EQ_ISSUES(expectedIssues, p);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_parseIdsOnEntities_Test::~Parser_parseIdsOnEntities_Test()
|
TEST(Parser, parseIdsOnEntities)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"everything\" id=\"mid\">\n"
" <import xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href=\"some-other-model.xml\" id=\"i1id\">\n"
" <component component_ref=\"a_component_in_that_model\" name=\"component1\" id=\"c1id\"/>\n"
" </import>\n"
" <import xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href=\"some-other-model.xml\" id=\"i2id\">\n"
" <units units_ref=\"a_units_in_that_model\" name=\"units1\" id=\"u1id\"/>\n"
" </import>\n"
" <units name=\"units2\" id=\"u2id\">\n"
" <unit units=\"second\" id=\"unit1id\"/>\n"
" </units>\n"
" <units name=\"units3\" id=\"u3id\"/>\n"
" <units name=\"blob\"/>\n"
" <component name=\"component2\" id=\"c2id\">\n"
" <variable name=\"variable1\" units=\"blob\" interface=\"private\" id=\"v1id\"/>\n"
" <variable name=\"variable2\" units=\"blob\" id=\"v2id\"/>\n"
" <reset variable=\"variable1\" test_variable=\"variable2\" order=\"1\" id=\"r1id\">\n"
" <test_value id=\"tv1id\">\n"
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\" id=\"math1when1\">\n"
" <apply>\n"
" <eq/>\n"
" <ci>variable1</ci>\n"
" <cn>3.4</cn>\n"
" </apply>\n"
" </math>\n"
" </test_value>\n"
" <reset_value id=\"rv1id\">\n"
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\" id=\"math2when1\">\n"
" <apply>\n"
" <eq/>\n"
" <ci>variable1</ci>\n"
" <cn>9.0</cn>\n"
" </apply>\n"
" </math>\n"
" </reset_value>\n"
" </reset>\n"
" </component>\n"
" <component name=\"component3\" id=\"c3id\">\n"
" <variable name=\"variable2\" units=\"ampere\" interface=\"public\" id=\"c3v2id\"/>\n"
" </component>\n"
" <connection component_1=\"component2\" component_2=\"component3\" id=\"con1id\">\n"
" <map_variables variable_1=\"variable1\" variable_2=\"variable2\" id=\"map1id\"/>\n"
" </connection>\n"
" <encapsulation id=\"encap1id\">\n"
" <component_ref component=\"component2\" id=\"cref1id\">\n"
" <component_ref component=\"component3\" id=\"crefchild1id\"/>\n"
" </component_ref>\n"
" </encapsulation>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(in);
EXPECT_EQ(size_t(0), parser->issueCount());
EXPECT_EQ("mid", model->id());
EXPECT_EQ("c1id", model->component("component1")->id());
EXPECT_EQ("i1id", model->component("component1")->importSource()->id());
EXPECT_EQ("u1id", model->units("units1")->id());
EXPECT_EQ("i2id", model->units("units1")->importSource()->id());
EXPECT_EQ("u2id", model->units("units2")->id());
EXPECT_EQ("c2id", model->component("component2")->id());
EXPECT_EQ("u3id", model->units("units3")->id());
EXPECT_EQ("v1id", model->component("component2")->variable("variable1")->id());
EXPECT_EQ("r1id", model->component("component2")->reset(0)->id());
EXPECT_EQ("tv1id", model->component("component2")->reset(0)->testValueId());
EXPECT_EQ("rv1id", model->component("component2")->reset(0)->resetValueId());
libcellml::PrinterPtr printer = libcellml::Printer::create();
EXPECT_EQ(in, printer->printModel(model));
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_parseResetsWithIssues_Test::~Parser_parseResetsWithIssues_Test()
|
TEST(Parser, parseResetsWithIssues)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model name=\"\" xmlns=\"http://www.cellml.org/cellml/2.0#\" id=\"mid\">\n"
" <component name=\"component1\">\n"
" <variable name=\"variable1\" id=\"vid\" units=\"dimensionless\"/>\n" // reset variable not in the same component
" </component>\n"
" <component name=\"component2\" id=\"c2id\">\n"
" <variable name=\"variable2\" id=\"vid2\" units=\"dimensionless\"/>\n"
" <variable name=\"variable4\" id=\"vid4\" units=\"dimensionless\"/>\n"
// variable1 does not exist in this component, variable3 does not exist at all
" <reset order=\"33\" variable=\"variable3\" test_variable=\"variable1\">\n"
" <test_value one_invalid_attribute=\"apples\">\n" // invalid attribute
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply>\n"
" <eq/>\n"
" <ci>C1</ci>\n"
" <apply>\n"
" <plus/>\n"
" <ci>A1</ci>\n"
" <ci>B1</ci>\n"
" </apply>\n"
" </apply>\n"
" </math>\n"
" </test_value>\n"
" <test_value>\n" // duplicated test_value block inside reset
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply />\n"
" </math>\n"
" </test_value>\n"
" <reset_value another_invalid_attribute=\"bananas\">\n" // invalid attribute
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply />\n"
" </math>\n"
" </reset_value>\n"
" <test_value>\n" // duplicated test_value block inside reset
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply />\n"
" </math>\n"
" </test_value>\n"
" <reset_value>\n"
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply />\n"
" </math>\n"
" </reset_value>\n" // duplicated reset_value block inside reset
" </reset>\n"
// order not specified
" <reset variable=\"variable2\" test_variable=\"variable4\">\n"
" lost text here\n"
" <test_value>\n"
" <some_invalid_tag/>\n" // test_value should only contain MathML
" </test_value>\n"
" <reset_value>\n"
" <some_other_invalid_tag/>\n" // reset_value should only contain MathML
" </reset_value>\n"
" </reset>\n"
// order not specified, unknown attribute
" <reset variable=\"variable2\" test_variable=\"variable4\" i_dont_belong_here=\"yep_really_i_dont\">\n"
// test_value missing
// reset_value missing
" </reset>\n"
" </component>\n"
"</model>\n";
const std::vector<std::string> expectedIssues = {
"Reset referencing variable 'variable3' is not a valid reference for a variable in component 'component2'.",
"Reset referencing test_variable 'variable1' is not a valid reference for a variable in component 'component2'.",
"Reset in component 'component2' referencing variable '' and test_variable '' has an unexpected attribute in the test_value block of 'one_invalid_attribute'.",
"Reset in component 'component2' referencing variable '' and test_variable '' has an unexpected attribute in the reset_value block of 'another_invalid_attribute'.",
"Reset in component 'component2' referencing variable '' and test_variable '' has 3 test_value blocks.",
"Reset in component 'component2' referencing variable '' and test_variable '' has 2 reset_value blocks.",
"Reset in component 'component2' does not have its order set.",
"Reset has an invalid non-whitespace child text element '\n lost text here\n '. Either a test_value block or a reset_value block is expected.",
"The test_value in the reset in component 'component2' referencing variable 'variable2' and test_variable 'variable4' should have a MathML block as a child.",
"The reset_value in the reset in component 'component2' referencing variable 'variable2' and test_variable 'variable4' should have a MathML block as a child.",
"Reset in component 'component2' has an invalid attribute 'i_dont_belong_here'.",
"Reset in component 'component2' does not have its order set.",
"Reset in component 'component2' referencing variable 'variable2' and test_variable 'variable4' does not have a test_value block defined.",
"Reset in component 'component2' referencing variable 'variable2' and test_variable 'variable4' does not have a reset_value block defined.",
};
libcellml::ParserPtr p = libcellml::Parser::create();
libcellml::ModelPtr model = p->parseModel(in);
libcellml::ResetPtr resetExpected = model->component(1)->reset(0);
EXPECT_EQ_ISSUES(expectedIssues, p);
EXPECT_EQ(resetExpected, p->issue(0)->item()->reset());
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Parser_unitsWithCellMLRealVariations_Test::~Parser_unitsWithCellMLRealVariations_Test()
|
TEST(Parser, unitsWithCellMLRealVariations)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <units name=\"fahrenheitish\">\n"
" <unit multiplier=\"1.8\" exponent=\"-0.23E-13\" units=\"kelvin\"/>\n"
" </units>\n"
" <units name=\"units_invalid_reals\">\n"
" <unit multiplier=\"1.8.0\" exponent=\"4.87f87\" units=\"kelvin\"/>\n"
" <unit multiplier=\"+9.87\" exponent=\"4.87e+16\" units=\"oranges\"/>\n"
" <unit multiplier=\"AB8e34\" exponent=\"4.87ee32\" units=\"apples\"/>\n"
" <unit multiplier=\"AB8\" exponent=\"4.87eE32\" units=\"bananas\"/>\n"
" <unit multiplier=\"e7\" exponent=\"4.87e\" units=\"mangoes\"/>\n"
" <unit multiplier=\"3.4e7.8\" units=\"fruit\"/>\n"
" <unit exponent=\"\" units=\"strawberries\"/>\n"
" </units>\n"
"</model>\n";
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <units name=\"fahrenheitish\">\n"
" <unit exponent=\"-2.3e-14\" multiplier=\"1.8\" units=\"kelvin\"/>\n"
" </units>\n"
" <units name=\"units_invalid_reals\">\n"
" <unit units=\"kelvin\"/>\n"
" <unit exponent=\"4.87e+16\" units=\"oranges\"/>\n"
" <unit units=\"apples\"/>\n"
" <unit units=\"bananas\"/>\n"
" <unit units=\"mangoes\"/>\n"
" <unit units=\"fruit\"/>\n"
" <unit units=\"strawberries\"/>\n"
" </units>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::ModelPtr model = parser->parseModel(in);
libcellml::PrinterPtr printer = libcellml::Printer::create();
const std::string a = printer->printModel(model);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
|
/cellml[P]libcellml/tests/parser/parser.cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.