name string | code string | asm string | file string |
|---|---|---|---|
ON_SHA1::set_final_hash() | void ON_SHA1::set_final_hash()
{
ON__UINT32 i;
ON__UINT32 bit_count;
ON__UINT8 pbFinalCount[8];
bit_count = m_bit_count[1];
for (i = 0; i < 4; ++i)
pbFinalCount[i] = static_cast<ON__UINT8>((bit_count >> ((3 - (i & 3)) * 8)) & 0xFF); // Endian independent
bit_count = m_bit_count[0];
for (i = 4; i < 8; ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x54(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0x73d3f5
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %edx
andl $0x3, %edx
movl $0x3, %ecx
subl %edx, %ecx
shll $0x3, %ec... | /mcneel[P]opennurbs/opennurbs_sha1.cpp |
ON_SHA1::AccumulateBoundingBox(ON_BoundingBox const&) | void ON_SHA1::AccumulateBoundingBox(
const class ON_BoundingBox& bbox
)
{
if (bbox.IsSet())
{
Accumulate3dPoint(bbox.m_min);
Accumulate3dPoint(bbox.m_max);
}
else
{
Accumulate3dPoint(ON_BoundingBox::UnsetBoundingBox.m_min);
Accumulate3dPoint(ON_BoundingBox::UnsetBoundingBox.m_max);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3089d0
testb $0x1, %al
jne 0x73e207
jmp 0x73e227
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x327fe0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi... | /mcneel[P]opennurbs/opennurbs_sha1.cpp |
ON_SleepLock::GetLockOrReturnFalse() | bool ON_SleepLock::GetLockOrReturnFalse()
{
// returns true if the value of the m_locked changed from 0 to 1.
// returns false if the value of m_locked was 1 and was not changed.
// In all cases, the final value of m_locked = 1.
#if defined(ON_SLEEPLOCK_USES_STD_ATOMIC_FLAG)
// std::atomic_flag.test_and_set
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x4, %eax
ja 0x73f5e3
movq -0x28(%rbp), %rax
leaq 0x1c906a(%rip), %rcx # 0x908... | /mcneel[P]opennurbs/opennurbs_sleeplock.cpp |
ON_qsort(void*, unsigned long, unsigned long, int (*)(void const*, void const*)) | void
ON_qsort( void *base, size_t nel, size_t width, int (*compar)(const void *, const void *))
{
#if defined(ON__HAVE_RELIABLE_SYSTEM_QSORT)
// The call here must be a thread safe system qsort
// that is faster than the alternative code in this function.
// In particular, if it uses a random number generator to... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x31dc70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_sort.cpp |
ON_hsort_double(double*, unsigned long) | void
ON_HSORT_FNAME( ON_SORT_TEMPLATE_TYPE* base, size_t nel )
{
size_t i_end,k,i,j;
ON_SORT_TEMPLATE_TYPE* e_end;
ON_SORT_TEMPLATE_TYPE* e_i;
ON_SORT_TEMPLATE_TYPE* e_j;
ON_SORT_TEMPLATE_TYPE tmp;
if (0 == base || nel < 2)
return;
k = nel >> 1;
i_end = nel-1;
e_end = base + i_end;
for (;;)
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x74006b
cmpq $0x2, -0x10(%rbp)
jae 0x740070
jmp 0x7401f1
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x1... | /mcneel[P]opennurbs/opennurbs_hsort_template.h |
ON_qsort_double_decreasing(double*, unsigned long) | void
ON_QSORT_FNAME (
ON_SORT_TEMPLATE_TYPE *base,
size_t num
)
{
ON_SORT_TEMPLATE_TYPE *lo; /* start of sub-array currently sorting */
ON_SORT_TEMPLATE_TYPE *hi; /* end of sub-array currently sorting */
ON_SORT_TEMPLATE_TYPE *mid; /* points to mid... | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x740712
cmpq $0x2, -0x10(%rbp)
jae 0x740717
jmp 0x740b77
movl $0x0, -0x42c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp... | /mcneel[P]opennurbs/opennurbs_qsort_template.h |
ON_hsort_uint(unsigned int*, unsigned long) | void
ON_HSORT_FNAME( ON_SORT_TEMPLATE_TYPE* base, size_t nel )
{
size_t i_end,k,i,j;
ON_SORT_TEMPLATE_TYPE* e_end;
ON_SORT_TEMPLATE_TYPE* e_i;
ON_SORT_TEMPLATE_TYPE* e_j;
ON_SORT_TEMPLATE_TYPE tmp;
if (0 == base || nel < 2)
return;
k = nel >> 1;
i_end = nel-1;
e_end = base + i_end;
for (;;)
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x74184b
cmpq $0x2, -0x10(%rbp)
jae 0x741850
jmp 0x7419b1
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x1... | /mcneel[P]opennurbs/opennurbs_hsort_template.h |
ON__shortsort_double_decreasing(double*, double*) | static void ON_QSORT_SHORT_SORT_FNAME(ON_SORT_TEMPLATE_TYPE *lo, ON_SORT_TEMPLATE_TYPE *hi)
{
ON_SORT_TEMPLATE_TYPE *p;
ON_SORT_TEMPLATE_TYPE *max;
ON_SORT_TEMPLATE_TYPE tmp;
/* Note: in assertions below, i and j are always inside original bound of
array to sort. */
while (hi > lo)
{
/* A[i] <= ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0x742561
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x742526
movq -0x18(%rbp), %rax
mov... | /mcneel[P]opennurbs/opennurbs_qsort_template.h |
ON__shortsort_double_decreasing(int*, int*) | static void ON_QSORT_SHORT_SORT_FNAME(ON_SORT_TEMPLATE_TYPE *lo, ON_SORT_TEMPLATE_TYPE *hi)
{
ON_SORT_TEMPLATE_TYPE *p;
ON_SORT_TEMPLATE_TYPE *max;
ON_SORT_TEMPLATE_TYPE tmp;
/* Note: in assertions below, i and j are always inside original bound of
array to sort. */
while (hi > lo)
{
/* A[i] <= ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0x742696
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x74266a
movq -0x18(%rbp), %rax
mov... | /mcneel[P]opennurbs/opennurbs_qsort_template.h |
ON_Sphere::BoundingBox() const | ON_BoundingBox ON_Sphere::BoundingBox() const
{
ON_BoundingBox bbox;
double r = Radius();
bbox.m_min = Center();
bbox.m_max = bbox.m_min;
bbox.m_min.x -= r;
bbox.m_min.y -= r;
bbox.m_min.z -= r;
bbox.m_max.x += r;
bbox.m_max.y += r;
bbox.m_max.z += r;
return bbox;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x32fb70
movq -0x40(%rbp), %rdi
callq 0x335e40
movq -0x40(%rbp), %rsi
movsd %xmm0, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x339440
movq -0x... | /mcneel[P]opennurbs/opennurbs_sphere.cpp |
ON_Sphere::Transform(ON_Xform const&) | bool ON_Sphere::Transform( const ON_Xform& xform )
{
ON_Circle xc(plane,radius);
bool rc = xc.Transform(xform);
if (rc)
{
plane = xc.plane;
radius = xc.radius;
}
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
movsd 0x80(%rsi), %xmm0
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x309c90
movq -0xb8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x334a30
movb %al, -0xad(%rbp)
jmp 0x743351
movb ... | /mcneel[P]opennurbs/opennurbs_sphere.cpp |
ON_Sphere::GetNurbForm(ON_NurbsSurface&) const | int ON_Sphere::GetNurbForm( ON_NurbsSurface& s ) const
{
int rc = 0;
if ( IsValid() ) {
s.Create(3,true,3,3,9,5);
s.m_knot[0][0] = s.m_knot[0][1] = 0.0;
s.m_knot[0][2] = s.m_knot[0][3] = 0.5*ON_PI;
s.m_knot[0][4] = s.m_knot[0][5] = ON_PI;
s.m_knot[0][6] = s.m_knot[0][7] = 1.5*ON_PI;
s.m_knot... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x260(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x31c8b0
testb $0x1, %al
jne 0x743423
jmp 0x743dbe
movq -0x10(%rbp), %rdi
movl $0x3, %r8d
movl $0x1, %edx
movl $0x9, %r9d
movl %r8... | /mcneel[P]opennurbs/opennurbs_sphere.cpp |
ON_MemoryAllocationTracking::~ON_MemoryAllocationTracking() | ON_MemoryAllocationTracking::~ON_MemoryAllocationTracking()
{
#if defined(ON_DEBUG_MEMORY_MSC_WIN)
// Dale Lear - Dec 2017
// Not thread safe but good enough for now and won't crash or assert.
// Relax, it's just a debugging tool based on ancient Microsoft debug heap tools.
if (ON_MemoryAllocationTracking::... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_statics.cpp |
ON_DBL::CompareValue(double, double) | int ON_DBL::CompareValue(double lhs, double rhs)
{
if (lhs < rhs)
return -1;
if (lhs > rhs)
return 1;
if (lhs == rhs)
return 0;
// At least one of lhs or rhs is a nan. Sort nans to end
return (ON_IS_NAN(lhs) ? 1 : 0) - (ON_IS_NAN(rhs) ? 1 : 0);
} | pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7446e7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x744760
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x7446fc
movl $0x1, -0x4(%rbp)
jmp 0x74476... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
ON_DBL::Compare(double const*, double const*) | int ON_DBL::Compare(const double* lhs, const double* rhs)
{
// sort nullptr to the end
if (lhs == rhs)
return 0;
if (nullptr == lhs)
return 1;
if (nullptr == rhs)
return -1;
return ON_DBL::CompareValue(*lhs, *rhs);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x744793
movl $0x0, -0x4(%rbp)
jmp 0x7447cd
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x7447a4
movl $0x1, -0x4(%rbp)
jmp 0x7447cd
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x7447... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_ON__fltinithelper(int) | static float Internal_ON__fltinithelper(int i)
{
// called twice - performance is not important
union
{
float x;
unsigned char b[4];
} u;
unsigned int i3, i2;
// different bytes on
u.x = 2.0f; // sign = 0; mantissa = 0; exponent = 1000 0000
if (0x40 == u.b[3] && 0 == u.b[0] && 0 == u.b[1] && 0 ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movss 0x1bf711(%rip), %xmm0 # 0x903f04
movss %xmm0, -0x8(%rbp)
movzbl -0x5(%rbp), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jne 0x744833
movzbl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x744833
movzbl -0x7(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx,... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_ON_Xform_Init(double, bool) | static ON_Xform Internal_ON_Xform_Init(double x, bool bDiagonal)
{
ON_Xform xform;
memset(&xform, 0, sizeof(xform));
if (bDiagonal)
{
xform.m_xform[0][0] = x;
xform.m_xform[1][1] = x;
xform.m_xform[2][2] = x;
xform.m_xform[3][3] = 1.0;
}
else
{
double* p = &xform.m_xform[0][0];
dou... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movsd %xmm0, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x31d180
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x308880
testb $0x1, -0x9(%rbp)
je 0x744b0b
movq -0x28(%rbp), ... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_BoundingBoxInit(double) | static ON_BoundingBox Internal_BoundingBoxInit(double x)
{
ON_BoundingBox bbox;
bbox.m_min.x = x;
bbox.m_min.y = x;
bbox.m_min.z = x;
bbox.m_max.x = x;
bbox.m_max.y = x;
bbox.m_max.z = x;
return bbox;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
callq 0x32fb70
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd -0x8(%rbp), %xmm0
movsd %xmm0, (%rdi)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_ON_PickPoint_UnsetInit() | static ON_PickPoint Internal_ON_PickPoint_UnsetInit()
{
ON_PickPoint unset_pick_point;
double* p = unset_pick_point.m_t;
double* p1 = p + sizeof(unset_pick_point.m_t) / sizeof(unset_pick_point.m_t[0]);
while (p < p1)
*p++ = ON_UNSET_VALUE;
return unset_pick_point;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x3298c0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x744e47
movq -0x8(%rbp), ... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_ON_Plane_NanPlane() | static ON_Plane Internal_ON_Plane_NanPlane()
{
ON_Plane nan_plane;
nan_plane.xaxis = ON_3dVector::NanVector;
nan_plane.yaxis = ON_3dVector::NanVector;
nan_plane.zaxis = ON_3dVector::NanVector;
nan_plane.origin = ON_3dPoint::NanPoint;
nan_plane.plane_equation = ON_PlaneEquation::NanPlaneEquation;
return na... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x306060
movq -0x18(%rbp), %rdi
movq 0x339775(%rip), %rax # 0xa7e6e0
movq (%rax), %rcx
movq %rcx, 0x18(%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rdi)
movq 0x10... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
ON_Font::DefaultFamilyName() | const wchar_t* ON_Font::DefaultFamilyName()
{
const wchar_t* s;
#if defined(ON_RUNTIME_WIN)
s = L"Arial";
#elif defined(ON_RUNTIME_APPLE)
s = L"Helvetica Neue";
#else
s = L"Arial";
#endif
return s;
} | pushq %rbp
movq %rsp, %rbp
leaq 0x1a6abd(%rip), %rax # 0x8ec2a8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_statics.cpp |
ON_Font::DefaultPostScriptName() | const wchar_t* ON_Font::DefaultPostScriptName()
{
const wchar_t* s;
#if defined(ON_RUNTIME_WIN)
s = L"ArialMT";
#elif defined(ON_RUNTIME_APPLE)
s = L"HelveticaNeue";
#else
s = L"ArialMT";
#endif
return s;
} | pushq %rbp
movq %rsp, %rbp
leaq 0x1adf4d(%rip), %rax # 0x8f3778
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_SystemMaterialInit(int) | static ON_Material Internal_SystemMaterialInit(int index)
{
ON_Material m;
switch (index)
{
case -1: // Default
{
// {CF2BE1DE-B81C-4D69-9418-DDE91D266086}
const ON_UUID id =
{ 0xcf2be1de, 0xb81c, 0x4d69, { 0x94, 0x18, 0xdd, 0xe9, 0x1d, 0x26, 0x60, 0x86 } };
Internal_SystemModelCompo... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x325d00
movl -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
subl $-0x2, %eax
je 0x7459a0
jmp 0x745933
movl -0x64(%rbp), %eax
subl $-0x1, %eax
jne 0x... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_BuiltInLinePattern(int) | static ON_Linetype Internal_BuiltInLinePattern( int index )
{
ON_Linetype line_pattern;
ON_SimpleArray<double> segments(8);
switch (index)
{
case -1: // Continuous
{
const ON_UUID line_pattern_id =
{ 0x3999bed5, 0x78ee, 0x4d73,{ 0xa0, 0x59, 0x3, 0x22, 0x24, 0xc6, 0xfd, 0x55 } };
Interna... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x228(%rbp)
movq %rdi, %rax
movq %rax, -0x220(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x322a20
leaq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x300d90
jmp 0x745afc
movl -0xc(%rbp), %eax
addl $0x9, %eax
... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_ON_Layer_Default() | static ON_Layer Internal_ON_Layer_Default()
{
// {061DF99E-2EF8-4A3F-8F2D-4B123A166089}
const ON_UUID id = { 0x61df99e, 0x2ef8, 0x4a3f,{ 0x8f, 0x2d, 0x4b, 0x12, 0x3a, 0x16, 0x60, 0x89 } };
ON_Layer layer;
layer.SetParentId(ON_nil_uuid);
Internal_SystemModelComponentInit(id, -1, L"Default", layer);
return la... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c25e2(%rip), %xmm0 # 0x908820
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x32d050
movq -0x58(%rbp), %rdi
movq 0x33665a(%rip), %rsi # 0xa7c8b0
callq 0x300f10
jmp 0x74... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DefaultTextStyle() | static ON_TextStyle Internal_DefaultTextStyle()
{
// {8F3A5848-7741-4AA9-B6A0-FA4F76C9D918}
const ON_UUID default_text_style_id =
{ 0x8f3a5848, 0x7741, 0x4aa9,{ 0xb6, 0xa0, 0xfa, 0x4f, 0x76, 0xc9, 0xd9, 0x18 } };
ON_TextStyle text_style;
Internal_TextStyleInit(L"Default", default_text_style_id, -1, &ON_Font:... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c24b2(%rip), %xmm0 # 0x908830
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x325260
movq -0x58(%rbp), %r9
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_ByParentTextStyle() | static ON_TextStyle Internal_ByParentTextStyle()
{
// {4D82AFFA-0433-4CE0-92C8-BD328E23C49F}
const ON_UUID ByParent_text_style_id =
{ 0x4d82affa, 0x433, 0x4ce0,{ 0x92, 0xc8, 0xbd, 0x32, 0x8e, 0x23, 0xc4, 0x9f } };
ON_TextStyle text_style;
Internal_TextStyleInit(L"By Parent", ByParent_text_style_id, -3, nullp... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c2392(%rip), %xmm0 # 0x908850
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x325260
movq -0x58(%rbp), %r9
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleDefault() | static ON_DimStyle Internal_DimStyleDefault()
{
const ON_UUID id =
{ 0x25b90869, 0x22, 0x4e04,{ 0xb4, 0x98, 0x98, 0xb4, 0x17, 0x5f, 0x65, 0xfd } };
ON_DimStyle dimstyle;
Internal_DimStyleInit(L"Default", -1, id, dimstyle);
Internal_DimStyleDefaultInit(dimstyle);
Internal_SystemDimStyleFinalize(dimstyle);
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c2302(%rip), %xmm0 # 0x908860
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x336900
movq -0x58(%rbp), %r8
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleInchFractional() | static ON_DimStyle Internal_DimStyleInchFractional()
{
const ON_UUID id =
{ 0x6bcb1506, 0x699f, 0x445d,{ 0xa1, 0x22, 0x4f, 0xc7, 0x78, 0x2b, 0xc4, 0x86 } };
ON_DimStyle dimstyle;
Internal_DimStyleInit(L"Inch Fractional", -3, id, dimstyle);
Internal_DimStyleInchFractionalInit(dimstyle);
Internal_SystemDimSt... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c21c2(%rip), %xmm0 # 0x908880
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x336900
movq -0x58(%rbp), %r8
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleFootInchArchitectural() | static ON_DimStyle Internal_DimStyleFootInchArchitectural()
{
const ON_UUID id =
{ 0x50d6ef1b, 0xd1d0, 0x408a,{ 0x86, 0xc0, 0xee, 0x8b, 0x36, 0x8, 0x88, 0x3e } };
ON_DimStyle dimstyle;
Internal_DimStyleInit(L"Foot-Inch Architectural", -4, id, dimstyle);
Internal_DimStyleFootInchArchitecturalInit(dimstyle);
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c2122(%rip), %xmm0 # 0x908890
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x336900
movq -0x58(%rbp), %r8
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleMillimeterSmall() | static ON_DimStyle Internal_DimStyleMillimeterSmall()
{
const ON_UUID id =
{ 0xdbe22573, 0x8cad, 0x4ced,{ 0x89, 0x47, 0x3, 0xa0, 0x48, 0xed, 0xde, 0x56 } };
ON_DimStyle dimstyle;
Internal_DimStyleInit(L"Millimeter Small", -5, id, dimstyle);
Internal_DimStyleMillimeterSmallInit(dimstyle);
Internal_SystemDim... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c2082(%rip), %xmm0 # 0x9088a0
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x336900
movq -0x58(%rbp), %r8
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleMillimeterArchitectural() | static ON_DimStyle Internal_DimStyleMillimeterArchitectural()
{
const ON_UUID id =
{ 0xe5a4c08f, 0x23b3, 0x4033,{ 0x90, 0xb2, 0xfb, 0x31, 0xec, 0x45, 0x92, 0x9b } };
ON_DimStyle dimstyle;
Internal_DimStyleInit(L"Millimeter Architectural", -7, id, dimstyle);
Internal_DimStyleMillimeterArchitecturalInit(dimsty... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c1f42(%rip), %xmm0 # 0x9088c0
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x336900
movq -0x58(%rbp), %r8
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleModelUnitsDecimal() | static ON_DimStyle Internal_DimStyleModelUnitsDecimal()
{
const ON_UUID id =
{ 0x93a38bdf, 0x4c1c, 0x428c, { 0x8b, 0x97, 0x93, 0x59, 0xf1, 0xbd, 0xed, 0x17 } };
ON_DimStyle dimstyle;
Internal_DimStyleInit(L"Model Units Decimal", -9, id, dimstyle);
Internal_DimStyleModelUnitsDecimalInit(dimstyle);
Internal_... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c1e02(%rip), %xmm0 # 0x9088e0
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x336900
movq -0x58(%rbp), %r8
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleMillimeterEngrave() | static ON_DimStyle Internal_DimStyleMillimeterEngrave()
{
const ON_UUID id =
{ 0x741980ff, 0xde0f, 0x4ed7, { 0xaa, 0x6f, 0xee, 0x91, 0xb3, 0xbe, 0x96, 0xc6 } };
ON_DimStyle dimstyle;
Internal_DimStyleInit(L"Millimeter Engrave", -11, id, dimstyle);
Internal_DimStyleMillimeterEngraveInit(dimstyle);
const ON_... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c1c92(%rip), %xmm0 # 0x908900
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x336900
movq -0x60(%rbp), %r8
movaps -0x20(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_SolidHatchPatternInit() | static ON_HatchPattern Internal_SolidHatchPatternInit()
{
// {B319435D-86B6-4D89-972D-1F75FEF0D950}
ON_UUID id = { 0xb319435d, 0x86b6, 0x4d89,{ 0x97, 0x2d, 0x1f, 0x75, 0xfe, 0xf0, 0xd9, 0x50 } };
ON_HatchPattern hatch_pattern;
hatch_pattern.SetFillType(ON_HatchPattern::HatchFillType::Solid);
Internal_System... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movups 0x1c1af2(%rip), %xmm0 # 0x908920
movaps %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x324e30
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x2fc2e0
jmp 0x746e48
movq -0x58(%rbp), %... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
ON_SubD::AutomaticMeshToSubD(ON_SubD::AutomaticMeshToSubDContext) | bool ON_SubD::AutomaticMeshToSubD(
ON_SubD::AutomaticMeshToSubDContext context
)
{
bool bAutomaticallyCreateSubD;
switch (context)
{
case ON_SubD::AutomaticMeshToSubDContext::Unset:
bAutomaticallyCreateSubD = false;
break;
case ON_SubD::AutomaticMeshToSubDContext::Rhino5BoxModeTSpline:
bAutomati... | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x3(%rbp)
testb %al, %al
je 0x747b58
jmp 0x747b46
movb -0x3(%rbp), %al
subb $0x1, %al
je 0x747b5e
jmp 0x747b4f
movb -0x3(%rbp), %al
subb $0x2, %al
je 0x747b6e
jmp 0x747b7e
movb $0x0, -0x2(%rbp)
jmp 0x747b82
movq 0x336b23(%rip... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_EmptyVertexInit() | static const ON_SubDVertex Internal_EmptyVertexInit()
{
// For efficiency, ON_SubDVertex() does not waste time
// initializing m_limitP[], ..., m_cache_subd_P[], m_displacementV[]
// but the offical "Empty" vertex should have every byte initialized.
ON_SubDVertex empty;
memset(&empty, 0, sizeof(empty));
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
callq 0x339e40
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x108, %edx # imm = 0x108
callq 0x308880
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_statics.cpp |
ON_ModelComponent::Internal_SystemComponentHelper() | unsigned int ON_ModelComponent::Internal_SystemComponentHelper()
{
static unsigned int rc = 0;
if (0 == rc)
{
rc = 1;
const ON_ModelComponent* list[] =
{
&ON_ModelComponent::Unset,
&ON_InstanceDefinition::Unset,
&ON_Linetype::Unset,
&ON_Layer::Unset,
&ON_TextStyle::Unset,... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
xorl %eax, %eax
cmpl 0x3726a5(%rip), %eax # 0xaba778
jne 0x7481f1
movl $0x1, 0x372695(%rip) # 0xaba778
leaq -0x70(%rbp), %rdi
leaq 0x330852(%rip), %rsi # 0xa78940
movl $0x70, %edx
callq 0x2fcd50
leaq -0x180(%rbp), %rdi
leaq 0x3308aa(%rip), %... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_TextStyleInit(wchar_t const*, ON_UUID_struct, int, ON_Font const*, ON_TextStyle&) | static void Internal_TextStyleInit(
const wchar_t* name,
ON_UUID id,
int index,
const ON_Font* font,
ON_TextStyle& text_style
)
{
ON_wString font_description;
bool bLockName = false;
if (nullptr != font)
{
font_description = font->Description();
text_style.SetFont(font);
if ( (nullptr =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3390e0
movb $0x0, -0x39(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x74837e
movq -0x28(%rbp), %rsi
leaq -... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleDefaultInit(ON_DimStyle&) | static void Internal_DimStyleDefaultInit(ON_DimStyle& ds)
{
ds.SetExtExtension (0.5);
ds.SetExtOffset (0.5);
ds.SetArrowSize (1.0);
ds.SetLeaderArrowSize (1.0);
ds.SetCenterMark (0.5);
ds.SetCenterMarkSt... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x18d4d5(%rip), %xmm0 # 0x8d5960
callq 0x310600
movq -0x8(%rbp), %rdi
movsd 0x18d4c4(%rip), %xmm0 # 0x8d5960
callq 0x339810
movq -0x8(%rbp), %rdi
movsd 0x18ab53(%rip), %xmm0 # 0x8d3000
callq 0x30ee00
movq -0x8(%rbp), %rd... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
Internal_DimStyleMillimeterArchitecturalInit(ON_DimStyle&) | static void Internal_DimStyleMillimeterArchitecturalInit(ON_DimStyle& ds)
{
Internal_DimStyleDefaultInit(ds);
ds.SetExtExtension (1.0);
ds.SetArrowSize (3.0);
ds.SetLeaderArrowSize (3.0);
ds.SetCenterMark (3.0);
ds.SetTextGap ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x748470
movq -0x8(%rbp), %rdi
movsd 0x18a00f(%rip), %xmm0 # 0x8d3000
callq 0x310600
movq -0x8(%rbp), %rdi
movsd 0x18c976(%rip), %xmm0 # 0x8d5978
callq 0x30ee00
movq -0x8(%rbp), %rdi
movsd 0x18c965(%rip), %xmm0 # 0x8d597... | /mcneel[P]opennurbs/opennurbs_statics.cpp |
ON_std_wstring_format[abi:cxx11](wchar_t const*, ...) | std::wstring ON_VARGS_FUNC_CDECL ON_std_wstring_format(const wchar_t* format, ...) ON_NOEXCEPT
{
wchar_t stack_buffer[2048];
ON_wStringBuffer buffer(stack_buffer, sizeof(stack_buffer) / sizeof(stack_buffer[0]));
int n = 0;
std::wstring str;
if (0 != format || 0 != format[0])
{
va_list args;
va_star... | pushq %rbp
movq %rsp, %rbp
subq $0x2140, %rsp # imm = 0x2140
movq %rdi, -0x2130(%rbp)
movq %rdi, %r10
movq %r10, -0x2128(%rbp)
testb %al, %al
je 0x74ae98
movaps %xmm0, -0x20f0(%rbp)
movaps %xmm1, -0x20e0(%rbp)
movaps %xmm2, -0x20d0(%rbp)
movaps %xmm3, -0x20c0(%rbp)
movaps %xmm4, -0x20b0(%rbp)
movaps %xmm5, -0... | /mcneel[P]opennurbs/opennurbs_std_string_format.cpp |
ON_UTF16_to_std_wstring[abi:cxx11](int, unsigned short const*, int, unsigned int*, unsigned int, unsigned int, unsigned short const**) | std::wstring ON_UTF16_to_std_wstring(
int bTestByteOrder,
const ON__UINT16* sUTF16,
int sUTF16_count,
unsigned int* error_status,
unsigned int error_mask,
ON__UINT32 error_code_point,
const ON__UINT16** sNextUTF16
) ON_NOEXCEPT
{
std::wstring str;
wchar_t buffer[512];
const int buffer_count = stat... | pushq %rbp
movq %rsp, %rbp
subq $0x8a0, %rsp # imm = 0x8A0
movq %rdi, -0x878(%rbp)
movq %rdi, %rax
movq %rax, -0x870(%rbp)
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movb $0... | /mcneel[P]opennurbs/opennurbs_std_string_utf.cpp |
ON_String::Header() const | ON_aStringHeader* ON_String::Header() const
{
ON_aStringHeader* hdr = (ON_aStringHeader*)m_s;
if (hdr)
hdr--;
else
hdr = &empty_astring.header;
return hdr;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x74c9a8
movq -0x10(%rbp), %rax
addq $-0xc, %rax
movq %rax, -0x10(%rbp)
jmp 0x74c9b3
leaq 0x36de69(%rip), %rax # 0xaba818
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
r... | /mcneel[P]opennurbs/opennurbs_string.cpp |
ON_String::ReserveArray(unsigned long) | char* ON_String::ReserveArray( size_t array_capacity )
{
if (array_capacity <= 0)
return nullptr;
ON_aStringHeader* hdr0 = Header();
if (array_capacity > (size_t)ON_String::MaximumStringLength)
{
ON_ERROR("Requested capacity > ON_String::MaximumStringLength");
return nullptr;
}
const int capa... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x74ce5c
movq $0x0, -0x8(%rbp)
jmp 0x74cfed
movq -0x40(%rbp), %rdi
callq 0x30a0d0
movq %rax, -0x20(%rbp)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpq ... | /mcneel[P]opennurbs/opennurbs_string.cpp |
ON_String::operator=(ON_String const&) | ON_String& ON_String::operator=(const ON_String& src)
{
if (m_s != src.m_s)
{
if ( nullptr != src.IncrementedHeader() )
{
Destroy();
m_s = src.m_s;
}
else
{
Destroy();
Create();
}
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x74dad4
movq -0x10(%rbp), %rdi
callq 0x3047e0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x74dac0
movq -0x18(%rbp),... | /mcneel[P]opennurbs/opennurbs_string.cpp |
ON_StringLengthUTF32(unsigned int const*) | int ON_StringLengthUTF32(
const ON__UINT32* string
)
{
const ON__UINT32* string1 = string;
if (nullptr != string1)
{
while (0 != *string1)
string1++;
}
return (int)(string1 - string);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x74e364
jmp 0x74e34a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x74e362
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x74e34a
jmp 0x74e364
movq ... | /mcneel[P]opennurbs/opennurbs_string.cpp |
ON_StringLengthUTF16(unsigned short const*, unsigned long) | int ON_StringLengthUTF16(
const ON__UINT16* string,
size_t string_capacity
)
{
const ON__UINT16* string1 = string;
if (nullptr != string1 && string_capacity > 0 )
{
for (const ON__UINT16* end = string1 + string_capacity; string1 < end; string1++)
{
if ( 0 == *string1)
break;
}
}
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x74e470
cmpq $0x0, -0x10(%rbp)
jbe 0x74e470
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %ra... | /mcneel[P]opennurbs/opennurbs_string.cpp |
ON_WildCardMatch(char const*, char const*) | bool ON_WildCardMatch(const char* s, const char* pattern)
{
if ( !pattern || !pattern[0] ) {
return ( !s || !s[0] ) ? true : false;
}
if ( *pattern == '*' ) {
pattern++;
while ( *pattern == '*' )
pattern++;
if ( !pattern[0] )
return true;
while (*s) {
if ( ON_WildCardM... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x74e540
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x74e56c
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x74e55b
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
mo... | /mcneel[P]opennurbs/opennurbs_string.cpp |
ON_WildCardMatchNoCase(char const*, char const*) | bool ON_WildCardMatchNoCase(const char* s, const char* pattern)
{
if ( !pattern || !pattern[0] ) {
return ( !s || !s[0] ) ? true : false;
}
if ( *pattern == '*' )
{
pattern++;
while ( *pattern == '*' )
pattern++;
if ( !pattern[0] )
return true;
while (*s) {
if ( ON_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x74e700
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x74e72c
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x74e71b
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
mo... | /mcneel[P]opennurbs/opennurbs_string.cpp |
ON_SubDEdge::AddFaceToArray(ON_SubDFacePtr) | bool ON_SubDEdge::AddFaceToArray(
ON_SubDFacePtr face_ptr
)
{
if (m_face_count < 2)
m_face2[m_face_count] = face_ptr;
else if (nullptr != m_facex && m_face_count < 2 + m_facex_capacity)
m_facex[m_face_count - 2] = face_ptr;
else
{
// not enough room in m_facex.
// If you really are trying to m... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl 0x64(%rax), %eax
cmpl $0x2, %eax
jge 0x776434
movq -0x20(%rbp), %rax
movzwl 0x64(%rax), %ecx
movq -0x10(%rbp), %rdx
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0x77647c
movq -0x20(%rbp), %... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDFace::RotateEdgeArray(unsigned int) | bool ON_SubDFace::RotateEdgeArray(
unsigned int fei0
)
{
if (0 == fei0)
return true;
const unsigned int edge_count = m_edge_count;
if (edge_count < 2 || edge_count > ON_SubDFace::MaximumEdgeCount || fei0 >= edge_count)
return false;
ON_SubDEdgePtr stack_eptr[8];
ON_SubDEdgePtr* eptr
= (edge_c... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x7769da
movb $0x1, -0x1(%rbp)
jmp 0x776b5e
movq -0x80(%rbp), %rax
movzwl 0x9c(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jb 0... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDMeshFragmentIterator::SubDAppearance() const | ON_SubDComponentLocation ON_SubDMeshFragmentIterator::SubDAppearance() const
{
return
(ON_SubDComponentLocation::Surface == m_subd_appearance_override || ON_SubDComponentLocation::ControlNet == m_subd_appearance_override)
? m_subd_appearance_override
: SubD().SubDAppearance();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movb $0x2, %al
cmpb 0x72(%rcx), %al
je 0x777cd6
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpb 0x72(%rcx), %al
jne 0x777ce2
movq -0x10(%rbp), %rax
movb 0x72(%rax), %al
movb %al, -0x11(%rbp)
jmp 0x777cf6
movq -0x10... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDimple::LocalSubdivide(ON_SubDFace const* const*, unsigned long) | bool ON_SubDimple::LocalSubdivide(
ON_SubDFace const*const* face_list,
size_t face_list_count
)
{
if (nullptr == face_list || face_list_count < 1 || m_levels.UnsignedCount() < 1)
return false;
unsigned int level0_index = ON_UNSET_UINT_INDEX;
for (size_t i = 0; i < face_list_count; ++i)
{
const ON_S... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2d0(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x78dfd9
cmpq $0x1, -0x20(%rbp)
jb 0x78dfd9
movq -0x2d0(%rbp), %rdi
addq $0x5e0, %rdi ... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::DeleteComponents(ON_COMPONENT_INDEX const*, unsigned long) | bool ON_SubD::DeleteComponents(
const ON_COMPONENT_INDEX* ci_list,
size_t ci_count
)
{
ON_SimpleArray<ON_SubDComponentPtr> cptr_list;
if (ComponentPtrFromComponentIndex(ci_list,ci_count,cptr_list) <= 0)
return true; // nothing to delete
return DeleteComponents(cptr_list.Array(),cptr_list.UnsignedCount(... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2ff8d0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rcx
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::DeleteComponentsForExperts(ON_SubDComponentPtr const*, unsigned long, bool, bool, bool) | bool ON_SubD::DeleteComponentsForExperts(
const ON_SubDComponentPtr* cptr_list,
size_t cptr_count,
bool bDeleteIsolatedEdges,
bool bUpdateTagsAndCoefficients,
bool bMarkDeletedFaceEdges
)
{
if (bMarkDeletedFaceEdges)
ClearComponentMarks(false,true,false,nullptr);
if ( cptr_count <= 0 )
return tru... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movl %r8d, -0x178(%rbp)
movl %ecx, %eax
movl -0x178(%rbp), %ecx
movl %eax, -0x174(%rbp)
movq %rdx, %rax
movl -0x174(%rbp), %edx
movq %rax, -0x170(%rbp)
movq %rsi, %rax
movq -0x170(%rbp), %rsi
movq %rax, -0x168(%rbp)
movq %rdi, %r8
movq -0x168(%rbp), ... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::ClearComponentMarks(bool, bool, bool, ON_SimpleArray<ON_SubDComponentBase const*>*) const | unsigned int ON_SubD::ClearComponentMarks(
bool bClearVertexMarks,
bool bClearEdgeMarks,
bool bClearFaceMarks,
ON_SimpleArray< const ON_SubDComponentBase* >* marked_component_list
) const
{
unsigned int clear_count = 0;
if (bClearVertexMarks)
{
ON_SubDVertexIterator vit(*this);
for (const ON_SubD... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq %r8, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movl $0x0... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDimple::DeleteComponents(unsigned int, bool, bool, bool) | unsigned int ON_SubDimple::DeleteComponents(
unsigned int level_index,
bool bDeleteIsolatedEdges,
bool bUpdateTagsAndCoefficients,
bool bMarkDeletedFaceEdges
)
{
unsigned int deleted_component_count = 0;
if (level_index >= m_levels.UnsignedCount())
return ON_SUBD_RETURN_ERROR(0);
ON_SubDLevel* le... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %dl
movb %dl, -0x15(%rbp)
andb $0x1, %cl
movb %cl, -0x16(%rbp)
andb $0x1, %al
movb %al, -0x17(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x118(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::DeleteMarkedComponents(bool, unsigned char, bool) | bool ON_SubD::DeleteMarkedComponents(
bool bDeleteMarkedComponents,
ON__UINT8 mark_bits,
bool bMarkDeletedFaceEdges
)
{
ON_SimpleArray<ON_SubDComponentPtr> cptr_list;
GetMarkedComponents(bDeleteMarkedComponents, mark_bits, true, true, true, cptr_list);
return DeleteComponents(
cptr_list.Array(),
cpt... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2ff8d0
movq -0x48(%... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::GetMarkedComponents(bool, unsigned char, bool, bool, bool, ON_SimpleArray<ON_SubDComponentPtr>&) const | unsigned int ON_SubD::GetMarkedComponents(
bool bAddMarkedComponents,
ON__UINT8 mark_bits,
bool bIncludeVertices,
bool bIncludeEdges,
bool bIncludeFaces,
ON_SimpleArray< ON_SubDComponentPtr >& component_list
) const
{
bAddMarkedComponents = bAddMarkedComponents ? true : false; // so we can use == on boole... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movl %r8d, -0x118(%rbp)
movl %ecx, %eax
movl -0x118(%rbp), %ecx
movl %eax, -0x114(%rbp)
movl %edx, %eax
movl -0x114(%rbp), %edx
movl %eax, -0x110(%rbp)
movl %esi, %eax
movl -0x110(%rbp), %esi
movl %eax, -0x10c(%rbp)
movq %rdi, %r8
movl -0x10c(%rbp), ... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::DeleteMarkedComponentsForExperts(bool, unsigned char, bool, bool, bool) | bool ON_SubD::DeleteMarkedComponentsForExperts(
bool bDeleteMarkedComponents,
ON__UINT8 mark_bits,
bool bDeleteIsolatedEdges,
bool bUpdateTagsAndCoefficients,
bool bMarkDeletedFaceEdges
)
{
ON_SimpleArray<ON_SubDComponentPtr> cptr_list;
GetMarkedComponents(bDeleteMarkedComponents, mark_bits, true, true, t... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %r8d, -0x58(%rbp)
movl %ecx, %eax
movl -0x58(%rbp), %ecx
movl %eax, -0x54(%rbp)
movl %edx, %eax
movl -0x54(%rbp), %edx
movl %eax, -0x50(%rbp)
movl %esi, %eax
movl -0x50(%rbp), %esi
movl %eax, -0x4c(%rbp)
movq %rdi, %r8
movl -0x4c(%rbp), %edi
movb %r9b, %al
movq %r8, -0x8... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDLevel::UpdateEdgeTags(bool) | unsigned int ON_SubDLevel::UpdateEdgeTags(
bool bUnsetEdgeTagsOnly
)
{
// Update edge flags and sector coefficients.
unsigned int edge_change_count = 0;
ON_SubDEdge* next_edge = m_edge[0];
for (ON_SubDEdge* edge = next_edge; nullptr != edge; edge = next_edge)
{
next_edge = const_cast<ON_SubDEdge*>(edg... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x10(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x79c44a
movq -0x20(%rbp)... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDLevel::UpdateVertexTags(bool) | unsigned int ON_SubDLevel::UpdateVertexTags(
bool bUnsetVertexTagsOnly
)
{
// Update edge flags and sector coefficients.
unsigned int vertex_change_count = 0;
ON_SubDVertex* next_vertex = m_vertex[0];
for (ON_SubDVertex* vertex = next_vertex; nullptr != vertex; vertex = next_vertex)
{
next_vertex =... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x79c4ff
movq -0x20(%rbp),... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDLevel::ClearComponentDamagedState(bool, bool, bool) const | unsigned int ON_SubDLevel::ClearComponentDamagedState(
bool bClearVerticesDamagedState,
bool bClearEdgesDamagedState,
bool bClearFacesDamagedState
) const
{
unsigned int change_count = 0;
unsigned int i;
if (bClearVerticesDamagedState)
{
i = 0;
for (const ON_SubDVertex* v = m_vertex[0]; nullptr !=... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x10(%rbp)
testb $0x1, -0x9(%rbp)
je 0x79c5bc
... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::SubDModifiedNofification() | void ON_SubD::SubDModifiedNofification()
{
// DestroyRuntimeCache()
// Clears
// Saved subdivision points.
// Saved limit surface information.
// Bounding boxes.
//
DestroyRuntimeCache();
// This is a heavy handed tag update.
UpdateAllTagsAndSectorCoefficients(false);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rax
movl $0x1, %esi
callq *0xb8(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x326750
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::ClearComponentGroupIds(bool, bool, bool) const | unsigned int ON_SubD::ClearComponentGroupIds(
bool bClearVertexGroupIds,
bool bClearEdgeGroupIds,
bool bClearFaceGroupIds
) const
{
unsigned int clear_count = 0;
if (bClearVertexGroupIds)
{
ON_SubDVertexIterator vit(*this);
for (const ON_SubDVertex* v = vit.FirstVertex(); nullptr != v; v = vit.Next... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movl $0x0, -0x10(%rbp)
testb $0x... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubD::ClearComponentMarkBits(bool, bool, bool) const | unsigned int ON_SubD::ClearComponentMarkBits(
bool bClearVertexMarkBits,
bool bClearEdgeMarkBits,
bool bClearFaceMarkBits
) const
{
unsigned int clear_count = 0;
if (bClearVertexMarkBits)
{
ON_SubDVertexIterator vit(*this);
for (const ON_SubDVertex* v = vit.FirstVertex(); nullptr != v; v = vit.Next... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movl $0x0, -0x10(%rbp)
testb $0x... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SubDEdgeChain::Write(ON_BinaryArchive&) const | bool ON_SubDEdgeChain::Write(class ON_BinaryArchive& archive) const
{
// This write has to work if a read happened but the m_edge_chain[] was never set.
if (m_edge_chain.UnsignedCount() > 0)
SetPersistentEdgeIdsFromRuntimeEdgePtrs();
const unsigned count = m_persistent_edge_id.UnsignedCount();
if (false ==... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
callq 0x3072f0
cmpl $0x0, %eax
jbe 0x7a9f0f
movq -0x28(%rbp), %rdi
callq 0x31dcc0
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x336bb0
movl %eax, -0x1c(%rbp)
movq -0... | /mcneel[P]opennurbs/opennurbs_subd.cpp |
ON_SimpleArray<unsigned char>::NewCapacity() const | int ON_SimpleArray<T>::NewCapacity() const
{
// Note:
// This code appears in ON_SimpleArray<T>::NewCapacity()
// and ON_ClassArray<T>::NewCapacity(). Changes made to
// either function should be made to both functions.
// Because this code is template code that has to
// support dynamic linking... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x10000000, -0x18(%rbp) # imm = 0x10000000
movslq 0x10(%rax), %rax
shlq $0x0, %rax
cmpq $0x10000000, %rax # imm = 0x10000000
jbe 0x7bf822
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x7bf84a
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SubDQuadNeighborhood::CenterVertexDex(int) | const ON_2dex ON_SubDQuadNeighborhood::CenterVertexDex(
int vi
)
{
if (0 == vi)
return ON_2dex(1, 1);
if (1==vi)
return ON_2dex(2, 1);
if (2==vi)
return ON_2dex(2, 2);
if (3==vi)
return ON_2dex(1, 2);
return ON_2dex(ON_UNSET_INT_INDEX,ON_UNSET_INT_INDEX);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jne 0x7fde34
leaq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x32b310
jmp 0x7fde9e
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jne 0x7fde53
leaq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x32b310
j... | /mcneel[P]opennurbs/opennurbs_subd_limit.cpp |
GetQuadCreaseEigenvalues(unsigned int, unsigned int, double*) | static unsigned int GetQuadCreaseEigenvalues(
unsigned int N,
unsigned int R,
double* eigenvalues
)
{
static const double e2[4] =
{1.0, 0.5, 0.25, 0.25};
static const double e3[6] =
{1.0, 0.5, 0.5, 0.25, 0.25, 0.125};
static const double e4[8] =
{1.0, 0.5, 0.5, 0.3475970508005518921819191, 0.25, 0.... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x13, 0x29a3ae(%rip) # 0xaa12d8
je 0x806f3d
callq 0x327d70
movl $0x0, -0x4(%rbp)
jmp 0x807014
cmpl $0x2, -0x8(%rbp)
jae 0x806f54
callq 0x327d70
movl $0x0, -0x4(%rbp)
jmp 0x807014
movl -0x8(%rbp), %eax
... | /mcneel[P]opennurbs/opennurbs_subd_matrix.cpp |
VertexToDuplicate::NeedsDuplicated(ON_SubDVertex const*) | bool VertexToDuplicate::NeedsDuplicated(
const ON_SubDVertex* vertex
)
{
if ( nullptr == vertex || vertex->m_face_count < 2 || vertex->m_edge_count < 2 || nullptr == vertex->m_edges || nullptr == vertex->m_faces)
return false;
if (vertex->IsSmooth())
return false;
const unsigned int edge_count = verte... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x8138b6
movq -0x10(%rbp), %rax
movzwl 0x6a(%rax), %eax
cmpl $0x2, %eax
jl 0x8138b6
movq -0x10(%rbp), %rax
movzwl 0x68(%rax), %eax
cmpl $0x2, %eax
jl 0x8138b6
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x70(%rc... | /mcneel[P]opennurbs/opennurbs_subd_mesh.cpp |
ON_SubD::Internal_GetGeometryControlNetMesh(ON_SubDLevel const&, ON_SubDLevelComponentIdIterator&, ON_SubDLevelComponentIdIterator&, ON_Mesh&) const | bool ON_SubD::Internal_GetGeometryControlNetMesh(
const ON_SubDLevel& level,
ON_SubDLevelComponentIdIterator& vit_by_id,
ON_SubDLevelComponentIdIterator& fit_by_id,
ON_Mesh& mesh
) const
{
VertexToDuplicate dup;
ON_SimpleArray<VertexToDuplicate> dups_array;
const unsigned int subd_vertex_count = level.m_... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x300c70
leaq -0x68(%rbp), %rdi
callq 0x323480
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x6... | /mcneel[P]opennurbs/opennurbs_subd_mesh.cpp |
ON_SubD::Internal_GetTextureCoordinatesGeometryControlNetMesh(ON_SubDLevel const&, ON_Mesh&) const | bool ON_SubD::Internal_GetTextureCoordinatesGeometryControlNetMesh(
const ON_SubDLevel& level,
ON_Mesh& mesh
) const
{
const bool bSetMeshT = 2 * this->TexturePointsAreSet() > this->FaceCount(); // more than half the faces have texture points.
bool bSubdivide = false; // required if any SubD faces are not quad... | pushq %rbp
movq %rsp, %rbp
subq $0x750, %rsp # imm = 0x750
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x600(%rbp)
callq 0x31ebc0
movq -0x600(%rbp), %rdi
shll %eax
movl %eax, -0x5f4(%rbp)
callq 0x318170
movl %eax, %ecx
movl -0x5f4(%rbp), %eax
cmpl %... | /mcneel[P]opennurbs/opennurbs_subd_mesh.cpp |
Internal_DuplicateVertices(ON_Mesh&, ON_3dPointArray&, ON_SimpleArray<VertexToDuplicate>&) | static bool Internal_DuplicateVertices(
ON_Mesh& mesh,
ON_3dPointArray& D,
ON_SimpleArray<VertexToDuplicate>& dups_array
)
{
const unsigned int mesh_F_count = mesh.m_F.UnsignedCount();
const unsigned int mesh_D_count0 = D.UnsignedCount();
const unsigned int dups_count = dups_array.UnsignedCount();
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x30e480
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x330620
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x32f770
movl... | /mcneel[P]opennurbs/opennurbs_subd_mesh.cpp |
ON_SimpleArray<VertexToDuplicate>::QuickSortAndRemoveDuplicates(int (*)(VertexToDuplicate const*, VertexToDuplicate const*)) | bool ON_SimpleArray<T>::QuickSortAndRemoveDuplicates( int (*compar)(const T*,const T*) )
{
bool rc = false;
if ( m_a && m_count > 0 && compar )
{
if (m_count > 1)
{
ON_qsort(m_a, m_count, sizeof(T), (int(*)(const void*, const void*))compar);
const T* prev_ele = &m_a[0];
int clean_count =... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x817342
movq -0x30(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x817342
cmpq $0x0, -0x10(%rbp)
je 0x817342
movq -0x30(%rbp), %rax
cmpl $0x1, 0x1... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<VertexToDuplicate>::Move(int, int, int) | void ON_SimpleArray<T>::Move( int dest_i, int src_i, int ele_cnt )
{
// private function for moving blocks of array memory
// caller is responsible for updating m_count.
if ( ele_cnt <= 0 || src_i < 0 || dest_i < 0 || src_i == dest_i ||
src_i + ele_cnt > m_count || dest_i > m_count )
return;
int ca... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x817642
cmpl $0x0, -0x10(%rbp)
jl 0x817642
cmpl $0x0, -0xc(%rbp)
jl 0x817642
movl -0x10(%rbp), %eax
cmpl -0xc(%rb... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<VertexToDuplicate>::SetCapacity(unsigned long) | T* ON_SimpleArray<T>::SetCapacity( size_t new_capacity )
{
if (0 == m_capacity)
{
// Allow "expert" users of ON_SimpleArray<>.SetArray(*,*,0) to clean up after themselves
// and deals with the case when the forget to clean up after themselves.
m_a = nullptr;
m_count = 0;
}
// sets capacity to ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jne 0x8176f2
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x81770d
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SubDComponentRef::operator=(ON_SubDComponentRef const&) | ON_SubDComponentRef& ON_SubDComponentRef::operator=(const ON_SubDComponentRef& src)
{
if (this != &src)
{
ON_Geometry::operator=(src);
m_subd_ref = src.m_subd_ref;
m_component_ptr = src.m_component_ptr;
m_component_index = src.m_component_index;
m_component_location = src.m_component_location;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x817fc2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x313510
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x31... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRef::ON_SubDComponentRef(ON_SubDComponentRef const&) | ON_SubDComponentRef::ON_SubDComponentRef(const ON_SubDComponentRef& src) ON_NOEXCEPT
: ON_Geometry(src)
, m_subd_ref(src.m_subd_ref)
, m_component_ptr(src.m_component_ptr)
, m_component_index(src.m_component_index)
, m_component_location(src.m_component_location)
, m_reference_id(src.m_reference_id)
{} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x336c70
jmp 0x818053
movq -0x18(%rbp), %rdi
movq 0x2657d2(%rip), %rax # 0xa7d830
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq -0x10(%rbp), %r... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRef::Compare2(ON_SubDComponentRef const* const*, ON_SubDComponentRef const* const*) | int ON_SubDComponentRef::Compare2(const ON_SubDComponentRef* const* lhs, const ON_SubDComponentRef* const* rhs)
{
if (lhs == rhs)
return 0;
if (nullptr == lhs)
return 1;
if (nullptr == rhs)
return -1;
return ON_SubDComponentRef::Compare(*lhs, *rhs);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x8181b3
movl $0x0, -0x4(%rbp)
jmp 0x8181eb
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x8181c4
movl $0x1, -0x4(%rbp)
jmp 0x8181eb
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x8181... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRef::Create(ON_SubDRef const&, ON_SubDComponentPtr, ON_SubDComponentLocation, unsigned long) | const ON_SubDComponentRef ON_SubDComponentRef::Create(
const ON_SubDRef& subd_ref,
ON_SubDComponentPtr component_ptr,
ON_SubDComponentLocation component_location,
ON__UINT_PTR reference_id
)
{
ON_SubDComponentRef component_ref;
component_ref.m_subd_ref = subd_ref;
component_ref.m_reference_id = referenc... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3141d0
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
call... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRef::Clear() | void ON_SubDComponentRef::Clear()
{
ON_Geometry::DestroyRuntimeCache();
PurgeUserData();
m_subd_ref.Clear();
m_component_ptr = ON_SubDComponentPtr::Null;
m_component_index = ON_COMPONENT_INDEX::UnsetComponentIndex;
m_reference_id = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, %esi
callq 0x333d70
movq -0x10(%rbp), %rdi
callq 0x333680
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x31fe90
movq -0x10(%rbp), %rax
movq 0x2656d1(%rip), %rcx # 0xa7dd50
movq (%rcx), %rcx
movq... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRef::IsValid(ON_TextLog*) const | bool ON_SubDComponentRef::IsValid(ON_TextLog* text_log) const
{
return (
m_component_ptr.IsNotNull()
&& (ON_SubDComponentLocation::ControlNet == m_component_location || ON_SubDComponentLocation::Surface == m_component_location)
&& false == SubD().IsEmpty()
);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0x3045f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x81882f
jmp 0x81886a
movq -0x20(%rbp), %rcx
movb $0x1, %al
cmpb 0x30(%rcx), %al
j... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRef::GetBBox(double*, double*, bool) const | bool ON_SubDComponentRef::GetBBox(
double* boxmin,
double* boxmax,
bool bGrowBox
) const
{
if ( nullptr == boxmin || nullptr == boxmax )
return false;
ON_BoundingBox bbox = ON_BoundingBox::EmptyBoundingBox;
switch (m_component_ptr.ComponentType())
{
case ON_SubDComponentPtr::Type::Unset:
... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x818919
xorl %eax, %eax
cmpq -0x20(%rbp)... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRefList::Internal_Destroy() | void ON_SubDComponentRefList::Internal_Destroy()
{
for (unsigned int i = 0; i < m_list.UnsignedCount(); i++)
{
ON_SubDComponentRef* p = m_list[i];
m_list[i] = nullptr;
if (nullptr != p)
delete p;
}
m_list.SetCount(0);
m_bIsClean = false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x32f7f0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jae 0x818c38
movq -0x20(%rbp), %rdi
movl -0xc(%rb... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRefList::Internal_CopyFrom(ON_SubDComponentRefList const&) | void ON_SubDComponentRefList::Internal_CopyFrom(const ON_SubDComponentRefList& src)
{
const unsigned int count = src.m_list.UnsignedCount();
m_list.Reserve(count);
m_list.SetCount(0);
for (unsigned int i = 0; i < count; i++)
{
const ON_SubDComponentRef* p = src.m_list[i];
if (nullptr == p)
m_lis... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32f7f0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x301590
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x3... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRefList::Internal_UpdateCount(ON_SubDComponentRef const&, int) | bool ON_SubDComponentRefList::Internal_UpdateCount(const ON_SubDComponentRef& r, int i)
{
if (r.SubD().IsEmpty())
return false;
bool rc = false;
ON_SubDComponentPtr cptr = r.ComponentPtr();
switch (cptr.ComponentType())
{
case ON_SubDComponentPtr::Type::Unset:
break;
case O... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x306160
movq %rax, %rdi
callq 0x329240
testb $0x1, %al
jne 0x818ef2
jmp 0x818efb
movb $0x0, -0x1(%rbp)
jmp 0x819065
movb $0x0, -0x1... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRefList::Append(ON_SubDRef const&, ON_COMPONENT_INDEX, ON_SubDComponentLocation, unsigned long) | const ON_SubDComponentRef& ON_SubDComponentRefList::Append(
const ON_SubDRef & subd_ref,
ON_COMPONENT_INDEX ci,
ON_SubDComponentLocation component_location,
ON__UINT_PTR reference_id
)
{
for (;;)
{
if (subd_ref.SubD().IsEmpty())
break;
if (false == ci.IsSubDComponentIndex())
break;
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %cl, %al
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x318380
movq %rax, %rdi
callq 0x329240
testb $0x1, %al
jne 0x8190b2
jmp 0... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRefList::Append(ON_SubDComponentRef const*) | const ON_SubDComponentRef& ON_SubDComponentRefList::Append(const ON_SubDComponentRef* src_ref)
{
for (;;)
{
if (nullptr == src_ref)
break;
if (src_ref->SubD().IsEmpty())
break;
if (false == Internal_UpdateCount(*src_ref,1))
break;
m_list.Append(new ON_SubDComponentRef(*src_ref));
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x819192
jmp 0x81920f
movq -0x18(%rbp), %rdi
callq 0x306160
movq %rax, %rdi
callq 0x329240
testb $0x1, %al
jne 0x8191a9
jmp 0x8191ab
jmp 0x81... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRefList::Append(ON_SubDRef const&, ON_SubDComponentPtr, ON_SubDComponentLocation, unsigned long) | const ON_SubDComponentRef& ON_SubDComponentRefList::Append(
const ON_SubDRef & subd_ref,
ON_SubDComponentPtr component_ptr,
ON_SubDComponentLocation component_location,
ON__UINT_PTR reference_id
)
{
for (;;)
{
if (subd_ref.SubD().IsEmpty())
break;
if (false == component_ptr.IsNull())
b... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %cl, %al
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x318380
movq %rax, %rdi
callq 0x329240
testb $0x1, %al
jne 0x819272
jmp 0... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
ON_SubDComponentRefList::AppendForExperts(ON_SubD const&, ON_COMPONENT_INDEX, ON_SubDComponentLocation, unsigned long) | const ON_SubDComponentRef& ON_SubDComponentRefList::AppendForExperts(
const ON_SubD& subd,
ON_COMPONENT_INDEX ci,
ON_SubDComponentLocation component_location,
ON__UINT_PTR reference_id
)
{
for (;;)
{
if (subd.IsEmpty())
break;
return Append(ON_SubDRef::CreateReferenceForExperts(subd),ci,compon... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x329240
testb $0x1, %al
jne 0x819434
jmp 0x819436
jmp 0x819498
movq -0x20... | /mcneel[P]opennurbs/opennurbs_subd_ref.cpp |
main | int main()
{
const auto data = Data{};
auto& os = std::cout;
auto serializer = kiste::raw{os};
auto sample = test::Sample(data, serializer);
sample.render();
} | subq $0x48, %rsp
movq 0x2dc1(%rip), %rax # 0x3fd8
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x2e64(%rip), %rax # 0x408a
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xf(%rsp), %rax
movq %rax, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rdi, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
callq 0x1254
xorl... | /rbock[P]kiss-templates/examples/4_composition/test.cpp |
void QtPrivate::QGenericArrayOps<QLinuxFbDevice::Output>::emplace<QLinuxFbDevice::Output const&>(long long, QLinuxFbDevice::Output const&) | void emplace(qsizetype i, Args &&... args)
{
bool detach = this->needsDetach();
if (!detach) {
if (i == this->size && this->freeSpaceAtEnd()) {
new (this->end()) T(std::forward<Args>(args)...);
++this->size;
return;
}
... | endbr64
subq $0x1f8, %rsp # imm = 0x1F8
movq %fs:0x28, %rax
movq %rax, 0x1f0(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20480
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x22215
movq 0x8(%rsp), %rcx
movq 0x20(%... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<QLinuxFbDevice::Output>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QLinuxFbDevice::Output const**) | bool tryReadjustFreeSpace(QArrayData::GrowthPosition pos, qsizetype n, const T **data = nullptr)
{
Q_ASSERT(!this->needsDetach());
Q_ASSERT(n > 0);
Q_ASSERT((pos == QArrayData::GrowsAtEnd && this->freeSpaceAtEnd() < n)
|| (pos == QArrayData::GrowsAtBeginning && this->freeSpa... | endbr64
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x20b50
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x20c10
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QLinuxFbDevice::Output>::relocate(long long, QLinuxFbDevice::Output const**) | void relocate(qsizetype offset, const T **data = nullptr)
{
T *res = this->ptr + offset;
QtPrivate::q_relocate_overlap_n(this->ptr, this->size, res);
// first update data pointer, then this->ptr
if (data && QtPrivate::q_points_into_range(*data, *this))
*data += offset;
... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rcx
imulq $0x170, 0x18(%rsp), %rdx # imm = 0x170
addq %rdx, %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x22810
cmpq $0x... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n_left_move<QLinuxFbDevice::Output*, long long>(QLinuxFbDevice::Output*, long long, QLinuxFbDevice::Output*) | void q_relocate_overlap_n_left_move(iterator first, N n, iterator d_first)
{
// requires: [first, n) is a valid range
// requires: d_first + n is reachable from d_first
// requires: iterator is at least a random access iterator
// requires: value_type(iterator) has a non-throwing destructor
Q_ASSER... | endbr64
subq $0x68, %rsp
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x5f5a4(%rip), %rax # 0x81f00
movq %rax, 0x38(%rsp)
movq 0x5f5a0(%rip), %rax # 0x81f08
movq %rax, 0x40(%rsp)
movq 0x5f59c(%rip), %rax # 0x81f10
movq %rax, 0x48(%rsp)
leaq... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QArrayDataPointer<_drmModeModeInfo>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<_drmModeModeInfo>*) | Q_NEVER_INLINE void reallocateAndGrow(QArrayData::GrowthPosition where, qsizetype n,
QArrayDataPointer *old = nullptr)
{
if constexpr (QTypeInfo<T>::isRelocatable && alignof(T) <= alignof(std::max_align_t)) {
if (where == QArrayData::GrowsAtEnd && !old &... | endbr64
subq $0x88, %rsp
movq %fs:0x28, %rax
movq %rax, 0x80(%rsp)
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x5c(%rsp)
jne 0x23c64
cmpq $0x0, 0x48(%rsp)
jne 0x23c64
movq 0x38(%rsp), %rdi
callq 0x23b80
testb $0x1, %al
j... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QPodArrayOps<_drmModeModeInfo>::copyAppend(_drmModeModeInfo const*, _drmModeModeInfo const*) | void copyAppend(const T *b, const T *e) noexcept
{
Q_ASSERT(this->isMutable() || b == e);
Q_ASSERT(!this->isShared() || b == e);
Q_ASSERT(b <= e);
Q_ASSERT((e - b) <= this->freeSpaceAtEnd());
if (b == e)
return;
::memcpy(static_cast<void *>(this->end()),... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x2424f
jmp 0x242a8
movq 0x8(%rsp), %rdi
callq 0x246e0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
s... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QTypedArrayData<_drmModeModeInfo>::allocate(long long, QArrayData::AllocationOption) | [[nodiscard]] static std::pair<QTypedArrayData *, T *> allocate(qsizetype capacity, AllocationOption option = QArrayData::KeepSize)
{
static_assert(sizeof(QTypedArrayData) == sizeof(QArrayData));
QArrayData *d;
void *result;
if constexpr (sizeof(T) == 1) {
// necessarily,... | endbr64
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x38(%rsp), %rdi
movl $0x44, %esi
movl $0x10, %edx
cal... | /qt[P]qtbase/src/corelib/tools/qarraydata.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.