name string | code string | asm string | file string |
|---|---|---|---|
vera::loadOBJ(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, vera::Scene*, bool) | bool loadOBJ(const std::string& _filename, Scene* _scene, bool _verbose) {
tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
std::string warn;
std::string err;
std::string base_dir = getBaseDir(_filename.c_str());
bool ret = tinyobj:... | pushq %rbp
movq %rsp, %rbp
subq $0x760, %rsp # imm = 0x760
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x47b420
leaq -0xc8(%rbp), %rdi
callq 0x47b480
leaq -0xe0(%rbp), %rdi
callq 0x47ac80
leaq -0x100(%rbp), %rdi
callq 0x21b8a0
... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/io/obj.cpp |
vera::loadOBJ(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, vera::Mesh&) | bool loadOBJ( const std::string& _filename, Mesh& _mesh ) {
tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
std::string warn;
std::string err;
std::string base_dir = getBaseDir(_filename.c_str());
bool ret = tinyobj::LoadObj(&attri... | pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x47b420
leaq -0xc0(%rbp), %rdi
callq 0x47b480
leaq -0xd8(%rbp), %rdi
callq 0x47ac80
leaq -0xf8(%rbp), %rdi
callq 0x21b8a0
leaq -0x118(%rbp), %rdi
callq 0x21b8a0
movq -0x10(%r... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/io/obj.cpp |
tinyobj::InitTexOpt(tinyobj::texture_option_t*, bool) | static void InitTexOpt(texture_option_t *texopt, const bool is_bump) {
if (is_bump) {
texopt->imfchan = 'l';
} else {
texopt->imfchan = 'm';
}
texopt->bump_multiplier = static_cast<real_t>(1.0);
texopt->clamp = false;
texopt->blendu = true;
texopt->blendv = true;
texopt->sharpness = static_cast<... | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x4798a0
movq -0x8(%rbp), %rax
movb $0x6c, 0x35(%rax)
jmp 0x4798a8
movq -0x8(%rbp), %rax
movb $0x6d, 0x35(%rax)
movq -0x8(%rbp), %rax
movss 0x60764(%rip), %xmm0 # 0x4da018
movss %xmm0, 0x38(%... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/tinyobjloader/tiny_obj_loader.h |
tinyobj::parseReal(char const**, float*) | static inline bool parseReal(const char **token, real_t *out) {
(*token) += strspn((*token), " \t");
const char *end = (*token) + strcspn((*token), " \t\r");
double val;
bool ret = tryParseDouble((*token), end, &val);
if (ret) {
real_t f = static_cast<real_t>(val);
(*out) = f;
}
(*token) = end;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x94e62(%rip), %rsi # 0x50e810
callq 0x21bd80
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/tinyobjloader/tiny_obj_loader.h |
tinyobj::fixIndex(int, int, int*) | static inline bool fixIndex(int idx, int n, int *ret) {
if (!ret) {
return false;
}
if (idx > 0) {
(*ret) = idx - 1;
return true;
}
if (idx == 0) {
// zero is not allowed according to the spec.
return false;
}
if (idx < 0) {
(*ret) = n + idx; // negative value = relative
re... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x479a5b
movb $0x0, -0x1(%rbp)
jmp 0x479a9b
cmpl $0x0, -0x8(%rbp)
jle 0x479a73
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x479a9b
cmpl $... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/tinyobjloader/tiny_obj_loader.h |
int tinyobj::pnpoly<float>(int, float*, float*, float, float) | static int pnpoly(int nvert, T *vertx, T *verty, T testx, T testy) {
int i, j, c = 0;
for (i = 0, j = nvert - 1; i < nvert; j = i++) {
if (((verty[i] > testy) != (verty[j] > testy)) &&
(testx <
(vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) +
vertx[i]))
c ... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x479bae
movq -0x18... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/tinyobjloader/tiny_obj_loader.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> vera::toString<int>(int const&, int, char) | inline std::string toString(const T& _value, int _width, char _fill) {
std::ostringstream out;
out << std::fixed << std::setfill(_fill) << std::setw(_width) << _value;
return out.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x1c8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x21c900
movq -0x1b8(%rbp), ... | /patriciogonzalezvivo[P]glslViewer/deps/vera/include/vera/ops/string.h |
vera::loadPLY(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, vera::Scene*, bool) | bool loadPLY(const std::string& _filename, Scene* _scene, bool _verbose) {
std::fstream is(_filename.c_str(), std::ios::in);
if (is.is_open()) {
if (_scene->materials.find("default") == _scene->materials.end())
_scene->materials["default"] = new Material("default");
Mat... | pushq %rbp
movq %rsp, %rbp
subq $0xa60, %rsp # imm = 0xA60
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21b2a0
movq %rax, %rsi
leaq -0x230(%rbp), %rdi
movq %rdi, -0x920(%rbp)
movl $0x8, %edx
callq 0x21b700
movq -0x920(%rbp), %... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/io/ply.cpp |
vera::loadPLY(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, vera::Mesh&) | bool loadPLY( const std::string& _filename, Mesh& _mesh ) {
std::fstream is(_filename.c_str(), std::ios::in);
if (is.is_open()) {
std::string line;
std::string error;
int orderVertices=-1;
int orderIndices=-1;
int vertexCoordsFound=0;
int colorCompsFound=0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x870, %rsp # imm = 0x870
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21b2a0
movq %rax, %rsi
leaq -0x228(%rbp), %rdi
movq %rdi, -0x7b8(%rbp)
movl $0x8, %edx
callq 0x21b700
movq -0x7b8(%rbp), %rdi
callq 0x21bf00
movb %al, -0x7ad(%rbp)
jmp 0x48c... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/io/ply.cpp |
vera::loadSTL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, vera::Mesh&) | bool loadSTL( const std::string& _filename, Mesh& _mesh ) {
FILE * stl_file = fopen(_filename.c_str(),"rb");
if (NULL == stl_file) {
fprintf(stderr,"IOError: %s could not be opened...\n", _filename.c_str());
return false;
}
// Specifically 80 character header
char header[80];
c... | pushq %rbp
movq %rsp, %rbp
subq $0x3e70, %rsp # imm = 0x3E70
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21b2a0
movq %rax, %rdi
leaq 0x53d89(%rip), %rsi # 0x4e344f
callq 0x21cf60
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x48f712
movq 0x1df882(%rip)... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/io/stl.cpp |
vera::texelCoordToVec(float*, float, float, unsigned char) | void texelCoordToVec(float* _out3f, float _u, float _v, uint8_t _faceId) {
// out = u * s_faceUv[0] + v * s_faceUv[1] + s_faceUv[2].
_out3f[0] = cubemapUV[_faceId][0][0] * _u + cubemapUV[_faceId][1][0] * _v + cubemapUV[_faceId][2][0];
_out3f[1] = cubemapUV[_faceId][0][1] * _u + cubemapUV[_faceId][1][1] * _v... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x7e917(%rip), %rax # 0x50f990
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movss (%rax), %xmm0
movss -0xc(%rbp), %xmm2
mov... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
vera::getFaceViewport(int, int) | glm::vec4 getFaceViewport(int _size, int _faceId) {
if (_faceId == 0)
return glm::vec4((float)_size * 2.0f, (float)_size, (float)_size, (float)_size);
else if (_faceId == 1)
return glm::vec4(0.0f, (float)_size, (float)_size, (float)_size);
else if (_faceId ==... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x491322
cvtsi2ssl -0x14(%rbp), %xmm0
movss 0x4b32b(%rip), %xmm1 # 0x4dc62c
mulss %xmm1, %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
cvtsi2ssl -0x14(%rbp), %xmm2
cvtsi2ssl -0x14(%rbp), %xmm3
leaq -0x10(%rbp), ... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
vera::dynamicCubemap(std::function<void (vera::Camera&, glm::vec<4, float, (glm::qualifier)0>&, int&)>, glm::vec<3, float, (glm::qualifier)0>, int) | void dynamicCubemap(std::function<void(Camera&, glm::vec4&, int&)> _renderFnc, glm::vec3 _pos, int _viewSize) {
// save the viewport for the total quilt
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
Camera cubemapCam;
cubemapCam.setPosition(_pos);
cubemapCam.setFOV(90.0);
cubem... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdi, -0x330(%rbp)
movlpd %xmm0, -0x20(%rbp)
movss %xmm1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl $0xba2, %edi # imm = 0... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
vera::dynamicCubemap(std::function<void (vera::Camera&, glm::vec<4, float, (glm::qualifier)0>&, int&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, glm::vec<3, float, (glm::qualifier)0>, int) | void dynamicCubemap(std::function<void(Camera&, glm::vec4&, int&)> _renderFnc, const std::string& _file, glm::vec3 _pos, int _viewSize) {
if (!cubemapFbo.isAllocated() || cubemapFbo.getWidth() != _viewSize || cubemapFbo.getHeight() != _viewSize)
cubemapFbo.allocate(_viewSize * 4, _viewSize * 3, COLOR_TEXTUR... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
leaq 0x23302c(%rip), %rdi # 0x6c4778
cal... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
vera::skyEquirectangular(vera::SkyData*, unsigned long, unsigned long) | float* skyEquirectangular(SkyData* _sky, size_t _width, size_t _height) {
int nPixels = _width * _height * 3;
float *data = new float[nPixels];
// FILAMENT SKYGEN
// https://github.com/google/filament/blob/master/tools/skygen/src/main.cpp
//
float solarElevation = _sky->elevation;
float s... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
imulq $0x3, %rax, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
void vera::splitFacesFromVerticalCross<float>(float const*, unsigned long, unsigned long, unsigned long, vera::CubemapFace<float>**) | void splitFacesFromVerticalCross(const T *_data, size_t _width, size_t _height, size_t _channels, CubemapFace<T> **_faces ) {
int faceWidth = _width / 3;
int faceHeight = _height / 4;
for (int i = 0; i < 6; i++) {
_faces[i] = new CubemapFace<T>();
_faces[i]->id = i;
_faces[i]->data ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x30(%rbp)
movl $0x0, -0... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
void vera::splitFacesFromHorizontalCross<float>(float const*, unsigned long, unsigned long, unsigned long, vera::CubemapFace<float>**) | void splitFacesFromHorizontalCross(const T *_data, size_t _width, size_t _height, size_t _channels, CubemapFace<T> **_faces ) {
int faceWidth = _width / 4;
int faceHeight = _height / 3;
for (int i = 0; i < 6; i++) {
_faces[i] = new CubemapFace<T>();
_faces[i]->id = i;
_faces[i]->dat... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x30(%rbp)
movl $0x0, -0... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
void vera::splitFacesFromHorizontalCross<unsigned char>(unsigned char const*, unsigned long, unsigned long, unsigned long, vera::CubemapFace<unsigned char>**) | void splitFacesFromHorizontalCross(const T *_data, size_t _width, size_t _height, size_t _channels, CubemapFace<T> **_faces ) {
int faceWidth = _width / 4;
int faceHeight = _height / 3;
for (int i = 0; i < 6; i++) {
_faces[i] = new CubemapFace<T>();
_faces[i]->id = i;
_faces[i]->dat... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x30(%rbp)
movl $0x0, -0... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
void vera::splitFacesFromHorizontalRow<float>(float const*, unsigned long, unsigned long, unsigned long, vera::CubemapFace<float>**) | void splitFacesFromHorizontalRow(const T *_data, size_t _width, size_t _height, size_t _channels, CubemapFace<T> **_faces ) {
int faceWidth = _width / 6;
int faceHeight = _height;
for (int i = 0; i < 6; i++) {
_faces[i] = new CubemapFace<T>();
_faces[i]->id = i;
_faces[i]->data = ne... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x6, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
void vera::splitFacesFromEquirectangular<float>(float const*, unsigned long, unsigned long, unsigned long, vera::CubemapFace<float>**) | void splitFacesFromEquirectangular(const T *_data, size_t _width, size_t _height, size_t _channels, CubemapFace<T> **_faces ) {
// Alloc data.
const uint32_t faceWidth = (_height + 1)/2;
const uint32_t faceHeight = faceWidth;
// Get source parameters.
const float srcWidthMinusOne = float(int(_widt... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
incq %rax
shrq %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x10(%rbp), %eax
decl %eax
cvtsi2ss %eax, %xm... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
void vera::splitFacesFromEquirectangular<unsigned char>(unsigned char const*, unsigned long, unsigned long, unsigned long, vera::CubemapFace<unsigned char>**) | void splitFacesFromEquirectangular(const T *_data, size_t _width, size_t _height, size_t _channels, CubemapFace<T> **_faces ) {
// Alloc data.
const uint32_t faceWidth = (_height + 1)/2;
const uint32_t faceHeight = faceWidth;
// Get source parameters.
const float srcWidthMinusOne = float(int(_widt... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
incq %rax
shrq %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x10(%rbp), %eax
decl %eax
cvtsi2ss %eax, %xm... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/env.cpp |
vera::inside(std::vector<glm::vec<2, float, (glm::qualifier)0>, std::allocator<glm::vec<2, float, (glm::qualifier)0>>>, glm::vec<2, float, (glm::qualifier)0>) | bool inside(const std::vector<glm::vec2> _points, const glm::vec2 _v) {
int counter = 0;
double xinters;
glm::vec2 p1,p2;
size_t N = _points.size();
p1 = _points[0];
for (size_t i = 1; i <= N; i++) {
p2 = _points[i % N];
if (_v.y > std::min(p1.y, p2.y)) {
if (_v.y <=... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movlpd %xmm0, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x304770
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3055e0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x48(%rbp)
movq -0x48... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
vera::intersection(glm::vec<2, float, (glm::qualifier)0> const&, glm::vec<2, float, (glm::qualifier)0> const&, glm::vec<2, float, (glm::qualifier)0> const&, glm::vec<2, float, (glm::qualifier)0> const&, glm::vec<2, float, (glm::qualifier)0>&) | bool intersection( const glm::vec2 &_line1Start, const glm::vec2 &_line1End,
const glm::vec2 &_line2Start, const glm::vec2 &_line2End,
glm::vec2 &_intersection ) {
glm::vec2 diffLA, diffLB;
double compareA, compareB;
diffLA = _line1End - _line1Start;
diffLB = _li... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x329cb0
movlpd %xmm0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
vera::intersection(vera::Ray const&, vera::Triangle const&) | IntersectionData intersection(const Ray& _ray, const Triangle& _triangle) {
IntersectionData idata;
float t,u,v;
idata.hit = intersection(_ray, _triangle, t, u, v);
// idata.hit = intersectionMT(_ray, _triangle, t, u, v);
if (!idata.hit) return idata;
// float vn = glm::dot(_ray.getDirection... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x497110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
callq 0x494410
movq -0x40(%rbp), %rdi
and... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
vera::intersection(vera::Line const&, vera::Plane const&) | IntersectionData intersection(const Line& _line, const Plane& _plane) {
IntersectionData idata;
float dist1 = distance(_line[0], _plane);
float dist2 = distance(_line[1], _plane);
int pos1 = sign(dist1);
int pos2 = sign(dist2);
if (pos1==pos2) {
idata.hit = false;
retur... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x497110
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4972d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x494760
movss %xmm0, -0x14(%rbp)
movq -... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
vera::intersection(vera::Line const&, vera::Line const&, glm::vec<3, float, (glm::qualifier)0>&, float) | bool intersection(const Line& _A, const Line& _B, glm::vec3& _p, float _threshold ) {
// Unnormalized direction of the ray
glm::vec3 da = _A.getDireciton();
glm::vec3 db = _B.getDireciton();
glm::vec3 dc = _B[0] - _A[0];
glm::vec3 cross_da_db = glm::cross(da, db);
// lines are not coplanar
... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x497320
movl 0x8(%rax), %ecx
movl %ecx, -0x28(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x49... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
vera::distance(glm::vec<3, float, (glm::qualifier)0> const&, vera::Line const&, glm::vec<3, float, (glm::qualifier)0>&) | float distance(const glm::vec3& _point, const Line& _line, glm::vec3& _closes_point) {
glm::vec3 dx = _line.getDireciton();
float m2 = _line.getMagintude2();
// find parameter value of closest point on segment
float s12 = glm::dot(_line[1]-_point, dx) / m2;
if (s12 < 0)
s12 = 0;
else if(s12 > ... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x497320
movl 0x8(%rax), %ecx
movl %ecx, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x497360
movss %xmm0, -0x2c(%r... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
vera::intersection(vera::Plane const&, vera::Plane const&) | IntersectionData intersection(const Plane& _plane1, const Plane& _plane2) {
IntersectionData idata;
glm::vec3 n1 = _plane1.getNormal();
glm::vec3 n2 = _plane2.getNormal();
float d1 = _plane1.getDCoeff();
float d2 = _plane2.getDCoeff();
// Check if planes are parallel, if so return fals... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x188(%rbp)
movq %rdi, %rax
movq %rax, -0x190(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x497110
movq -0x8(%rbp), %rdi
callq 0x497130
movss %xmm1, -0x28(%rbp)
movlpd %xmm0, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x1... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
vera::containsValue(std::vector<glm::vec<3, float, (glm::qualifier)0>, std::allocator<glm::vec<3, float, (glm::qualifier)0>>>*, glm::vec<3, float, (glm::qualifier)0> const&) | bool containsValue(std::vector<glm::vec3>* _points, const glm::vec3& _point) {
for (int i = 0; i < _points->size(); i++)
if ((_points->at(i)-_point).length()<EPS )
return true;
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x304810
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x49629f
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq... | /patriciogonzalezvivo[P]glslViewer/deps/vera/src/ops/intersection.cpp |
waitForEvent | static GLFWbool waitForEvent(double* timeout)
{
fd_set fds;
const int fd = ConnectionNumber(_glfw.x11.display);
int count = fd + 1;
#if defined(__linux__)
if (_glfw.linjs.inotify > fd)
count = _glfw.linjs.inotify + 1;
#endif
for (;;)
{
FD_ZERO(&fds);
FD_SET(fd, &fds);
#i... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
leaq 0x1f7c82(%rip), %rax # 0x6c4848
movq 0x209f8(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
leaq 0x1f7c5c(%rip), %rax # 0x6c4848
movl 0x21e08(%r... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/glfw/src/x11_window.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "GLX: Platform not initialized");
return None;
}... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1eee4d(%rip), %rax # 0x6c4848
cmpl $0x0, (%rax)
jne 0x4d5a1a
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x4ba8f0
movq $0x0, -0x8(%rbp)
jmp 0x4... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/glfw/src/glx_context.c |
getEGLErrorString | static const char* getEGLErrorString(EGLint error)
{
switch (error)
{
case EGL_SUCCESS:
return "Success";
case EGL_NOT_INITIALIZED:
return "EGL is not or could not be initialized";
case EGL_BAD_ACCESS:
return "EGL cannot access a requested resource";
... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0xffffd000, %eax # imm = 0xFFFFD000
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xe, %eax
ja 0x4d7427
movq -0x18(%rbp), %rax
leaq 0xb01df(%rip), %rcx # 0x587528
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8fe15(%rip... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/glfw/src/egl_context.c |
glfwGetOSMesaDepthBuffer | GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
int* width, int* height,
int* bytesPerValue,
void** buffer)
{
void* mesaBuffer;
GLint mesaWidth, mesaHeight, mesaBytes;
_GLFWwindow* window ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x4d974d
jmp 0x4d976c
leaq 0x842c(%rip), %rdi # 0x4e1b80
leaq 0xae8be(%rip), %rsi ... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/glfw/src/osmesa_context.c |
glfwGetOSMesaContext | GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.source != GLFW_OSMESA_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1eafcd(%rip), %rax # 0x6c4848
cmpl $0x0, (%rax)
jne 0x4d989a
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x4ba8f0
movq $0x0, -0x8(%rbp)
jmp 0x4... | /patriciogonzalezvivo[P]glslViewer/deps/vera/deps/glfw/src/osmesa_context.c |
yy_stack_print(unsigned char*, unsigned char*) | static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x17271(%rip), %rax # 0x2afc8
movq (%rax), %rdi
leaq 0xeddf(%rip), %rsi # 0x22b40
movb $0x0, %al
callq 0xc3a0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x13da5
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax... | /DuoLife-QNL[P]Pascal-S-Compiler/parser/parser.tab.cpp |
Write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<TCacheReq, std::allocator<TCacheReq>> const&) | void Write(const std::string& output, const std::vector<TCacheReq>& reqs) {
std::ofstream out(output);
out << reqs.size() << std::endl;
for (const auto& req : reqs) {
out << req.ServerId << " " << req.VideoId << std::endl;
}
out.close();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x2240
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x4, %rsi
movq %r14, %rdi
callq 0x20e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18... | /discobot[P]hashcode-practice/run.cpp |
RandomAssignment(TProblem const&) | std::vector<TCacheReq> RandomAssignment(const TProblem& p) {
std::mt19937 rng;
std::uniform_int_distribution<size_t> randomVideo(0, p.Vides.size() - 1);
std::vector<TCacheReq> reqs;
for (size_t i = 0; i < p.CacheCount; ++i) {
std::unordered_set<size_t> selected;
size_t capacity = p.Ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x13f8, %rsp # imm = 0x13F8
movq %rsi, %r14
movq %rdi, (%rsp)
movq $0x1571, 0x70(%rsp) # imm = 0x1571
movl $0x1, %eax
movl $0x1571, %ecx # imm = 0x1571
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx... | /discobot[P]hashcode-practice/run.cpp |
CalcPriority(TProblem&, std::unordered_map<TEndpointVideo, unsigned long, std::hash<TEndpointVideo>, std::equal_to<TEndpointVideo>, std::allocator<std::pair<TEndpointVideo const, unsigned long>>>&, TCacheReq&) | double CalcPriority(
TProblem& p,
std::unordered_map<TEndpointVideo, size_t>& serveTime,
TCacheReq& candidate
) {
size_t savedTime = 0;
for (size_t e : p.VideoEndpoints[candidate.VideoId]) {
size_t currentServeTime = serveTime[{e, candidate.VideoId}];
auto foundLatenc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, 0x40(%rsp)
movq 0x8(%rdx), %rax
movq 0x48(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r15
movq 0x8(%rcx,%rax,8), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %r15
je 0x2cea
leaq 0x78(%rdi), %rax
movq %ra... | /discobot[P]hashcode-practice/run.cpp |
PriorityQueueAssignment(TProblem&) | std::vector<TCacheReq> PriorityQueueAssignment(TProblem& p) {
std::vector<TCacheReq> result;
std::unordered_map<TEndpointVideo, size_t> serveTime;
std::unordered_set<TCacheReq> addedCacheRequests;
for (size_t e = 0; e < p.Endpoints.size(); ++e) {
for (size_t v = 0; v < p.Vides.size(); ++v) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq %rdi, 0x78(%rsp)
movq $0x0, 0x10(%rdi)
leaq 0xd8(%rsp), %rax
movq %rax, -0x30(%rax)
movl $0x1, %ecx
movq %rcx, -0x28(%rax)
movupd %xmm0, -0x20(%rax)
m... | /discobot[P]hashcode-practice/run.cpp |
main | int main(int argc, char* argv[]) {
if (argc != 3) {
std::cerr << "usage: " << argv[0] << " INPUT OUTPUT" << std::endl;
return 1;
}
auto p = Read(argv[1]);
Write(argv[2], PriorityQueueAssignment(p));
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rsi, %r14
cmpl $0x3, %edi
jne 0x34c7
movq 0x8(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x37b2
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x241c
leaq 0x20(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x... | /discobot[P]hashcode-practice/run.cpp |
lest::version(std::ostream&) | inline int version( std::ostream & os )
{
os << "lest version " << lest_VERSION << "\n"
<< "Compiled with " << compiler() << " on " << __DATE__ << " at " << __TIME__ << ".\n"
<< "For more information, see https://github.com/martinmoene/lest.\n";
return 0;
} | pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
leaq 0x5cc9(%rip), %rsi # 0xa8f1
movl $0xd, %edx
callq 0x21e0
leaq 0x5cc6(%rip), %rsi # 0xa8ff
movl $0x6, %edx
movq %rbx, %rdi
callq 0x21e0
leaq 0x55ca(%rip), %rsi # 0xa217
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21e0
leaq 0... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::print& lest::for_test<lest::print>(std::vector<lest::test, std::allocator<lest::test>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, lest::print&, int) | Action & for_test( tests specification, texts in, Action & perform, int n = 1 )
{
for ( int i = 0; indefinite( n ) || i < n; ++i )
{
for ( tests::iterator pos = specification.begin(); pos != specification.end() ; ++pos )
{
test & testing = *pos;
if ( select( testing.name... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x38(%rsp)
cmpl $-0x1, %ecx
setne %al
movl %ecx, (%rsp)
testl %ecx, %ecx
setle %cl
testb %cl, %al
jne 0x51e5
movq %rdi, %r15
leaq 0x50(%rsp), %rbx
movq 0x8(%rdi), %r14
xorl %edx, %edx
leaq 0x40(%rsp), %r12... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::ptags& lest::for_test<lest::ptags>(std::vector<lest::test, std::allocator<lest::test>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, lest::ptags&, int) | Action & for_test( tests specification, texts in, Action & perform, int n = 1 )
{
for ( int i = 0; indefinite( n ) || i < n; ++i )
{
for ( tests::iterator pos = specification.begin(); pos != specification.end() ; ++pos )
{
test & testing = *pos;
if ( select( testing.name... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x30(%rsp)
cmpl $-0x1, %ecx
setne %al
movl %ecx, (%rsp)
testl %ecx, %ecx
setle %cl
testb %cl, %al
jne 0x538f
movq %rdi, %rbp
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq 0x8(%rbp), %r14
xorl %esi, %esi... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::times::times(std::ostream&, lest::options) | times( std::ostream & out, options option )
: action( out ), output( out, option ), selected( 0 ), failures( 0 ), total()
{
os << std::setfill(' ') << std::fixed << std::setprecision( lest_FEATURE_TIME_PRECISION );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x10(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, ... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::confirm& lest::for_test<lest::confirm>(std::vector<lest::test, std::allocator<lest::test>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, lest::confirm&, int) | Action & for_test( tests specification, texts in, Action & perform, int n = 1 )
{
for ( int i = 0; indefinite( n ) || i < n; ++i )
{
for ( tests::iterator pos = specification.begin(); pos != specification.end() ; ++pos )
{
test & testing = *pos;
if ( select( testing.name... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $-0x1, %ecx
setne %al
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
setle %cl
testb %cl, %al
je 0x57d7
movq 0x8(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::seed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline seed_t seed( text opt, text arg )
{
// std::time_t: implementation dependent
if ( arg == "time" )
return static_cast<seed_t>( time( lest_nullptr ) );
if ( is_number( arg ) )
return static_cast<seed_t>( lest::stoi( arg ) );
throw std::runtime_error( "expecting 'time' or positive... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbp
leaq 0x43b8(%rip), %rsi # 0xa2fe
movq %r15, %rdi
callq 0x6744
testl %eax, %eax
je 0x6018
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline bool search( text part, text line )
{
return std::search(
line.begin(), line.end(),
part.begin(), part.end(), case_insensitive_equal ) != line.end();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq (%rsi), %rbx
movq 0x8(%rsi), %r15
movq 0x8(%rdi), %r14
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x877d
leaq (%rbx,%r15), %rax
movq %rax, 0x8(%rsp)
movq (%rdi), %rbp
movq %r15, %r12
sarq $0... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::tags(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>) | inline texts tags( text name, texts result = texts() )
{
size_t none = std::string::npos;
size_t lb = name.find_first_of( "[" );
size_t rb = name.find_first_of( "]" );
if ( lb == none || rb == none )
return result;
result.push_back( name.substr( lb, rb - lb + 1 ) );
return tags( n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1e3a(%rip), %rsi # 0xaa28
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x6806
movq %rax, %r13
leaq 0x14df(%rip), %rsi # 0xa0e6
movl $0x1, %ecx
movq %r15, %rdi
xorl... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
lest::confirm::operator()(lest::test) | confirm & operator()( test testing )
{
try
{
++selected; testing.behaviour( output( testing.name ) );
}
catch( message const & e )
{
++failures; report( os, e, output.context() );
}
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
incl 0x60(%rdi)
movq 0x20(%rsi), %r15
leaq 0x8(%rdi), %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x346a
leaq 0x48(%rbx), %rdi
movq 0... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> lest::make<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::... | C make( T const * first, T const * const last )
{
C result;
for ( ; first != last; ++first )
{
result.push_back( *first );
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpq %rdx, %rsi
je 0x9a86
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, 0x30(%rsp)
leaq 0x48(%rsp), %rbx
leaq 0x38(%rsp), %r12
leaq 0xf(%rsp), %r13
leaq 0x10(... | /martinmoene[P]atomic-lite/test/lest/lest_cpp03.hpp |
tidyPrintTidyLanguageNames | void tidyPrintTidyLanguageNames( ctmbstr format )
{
ctmbstr item;
TidyIterator i = getInstalledLanguageList();
while (i) {
item = getNextInstalledLanguage(&i);
if ( format )
printf( format, item );
else
printf( "%s\n", item );
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x39650
movq %rax, (%rsp)
testq %rax, %rax
je 0x305ba
movq %rsp, %r14
movq %r14, %rdi
callq 0x39655
testq %rbx, %rbx
je 0x305ab
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x30120
jmp 0x305b3
movq %rax, %rdi
callq 0x300b0
cmpq $0x0, (%rsp)
jne 0x3058f
add... | /geoffmcl[P]tidy-fork/console/tidy.c |
main | int main( int argc, char** argv )
{
ctmbstr prog = argv[0];
ctmbstr cfgfil = NULL, errfil = NULL, htmlfil = NULL;
TidyDoc tdoc = NULL;
int status = 0;
uint contentErrors = 0;
uint contentWarnings = 0;
uint accessWarnings = 0;
#if defined(ENABLE_DEBUG_LOG) && defined(_MSC_VER)
# if defined... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movl %edi, %r15d
movq (%rsi), %r12
callq 0x377b0
movq %rax, %rbx
leaq 0xdc9(%rip), %rsi # 0x313b1
movq %rax, %rdi
callq 0x37f29
movq 0xa29f9(%rip), %rax # 0xd2ff0
movq (%rax), %rax
movq %rax, 0xb59a7(%rip) #... | /geoffmcl[P]tidy-fork/console/tidy.c |
reportCallback | static Bool TIDY_CALL reportCallback(TidyMessage tmessage)
{
#if 0
TidyIterator pos;
TidyMessageArgument arg;
TidyFormatParameterType messageType;
ctmbstr messageFormat;
printf("FILTER: %s, %s\n", tidyGetMessageKey( tmessage ), tidyGetMessageOutput( tmessage ));
/* loop through the argumen... | movl $0x1, %eax
retq
| /geoffmcl[P]tidy-fork/console/tidy.c |
lang_help | static void lang_help( TidyDoc tdoc )
{
printf( "\n" );
printf( "%s", tidyLocalizedString(TC_TXT_HELP_LANG_1) );
printf( "\n" );
tidyPrintWindowsLanguageNames(" %-20s -> %s\n");
printf( "\n" );
printf( "%s", tidyLocalizedString(TC_TXT_HELP_LANG_2) );
printf( "\n" );
tidyPrintTidyLanguag... | pushq %rbx
movl $0xa, %edi
callq 0x30060
movl $0x360, %edi # imm = 0x360
callq 0x37dcf
leaq 0x33026(%rip), %rbx # 0x643f9
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x30120
movl $0xa, %edi
callq 0x30060
leaq 0x25eb7(%rip), %rdi # 0x572a8
callq 0x3050c
movl $0xa, %edi
callq 0x30060
movl $0x... | /geoffmcl[P]tidy-fork/console/tidy.c |
help | static void help(TidyDoc tdoc, /**< The tidy document for which help is showing. */
ctmbstr prog /**< The path of the current executable. */
)
{
tmbstr temp_string = NULL;
uint width = 78;
printf( tidyLocalizedString(TC_TXT_HELP_1), get_final_name(prog), tidyLibraryVersio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl $0x353, %edi # imm = 0x353
callq 0x37dcf
movq %rax, %r14
movq %rbx, %rdi
callq 0x300f0
testq %rax, %rax
je 0x314ad
leaq 0x1(%rbx), %rcx
movzbl -0x1(%rcx), %edx
cmpl $0x5c, %edx
je 0x3149e
cmpl $0x2f, %edx
... | /geoffmcl[P]tidy-fork/console/tidy.c |
xml_help | static void xml_help( void )
{
const CmdOptDesc* pos;
CmdOptDesc localPos;
printf( "<?xml version=\"1.0\"?>\n"
"<cmdline version=\"%s\">\n", tidyLibraryVersion());
for( pos=cmdopt_defs; pos->name1; ++pos)
{
localPos = *pos;
localize_option_names(&localPos);
print... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
callq 0x3799a
leaq 0x25db9(%rip), %rdi # 0x575f9
movq %rax, %rsi
xorl %eax, %eax
callq 0x30120
leaq 0x8c0cf(%rip), %rbp # 0xbd920
leaq 0x4cf0e(%rip), %r15 # 0x7e766
movups 0x20(%rbp), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x1... | /geoffmcl[P]tidy-fork/console/tidy.c |
xml_error_strings | static void xml_error_strings( TidyDoc tdoc )
{
uint errorCode;
ctmbstr localizedString;
TidyIterator j = getErrorCodeList();
printf( "<?xml version=\"1.0\"?>\n" );
printf( "<error_strings version=\"%s\">\n", tidyLibraryVersion());
while (j) {
errorCode = getNextErrorCode(&j);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x39604
movq %rax, %rbx
movq %rax, (%rsp)
leaq 0x26064(%rip), %rdi # 0x579f8
callq 0x300b0
callq 0x3799a
leaq 0x25ccd(%rip), %rdi # 0x57672
movq %rax, %rsi
xorl %eax, %eax
callq 0x30120
testq %rbx, %rbx
je 0x31a40
movq %rsp, %rbx... | /geoffmcl[P]tidy-fork/console/tidy.c |
xml_strings | static void xml_strings( void )
{
uint i;
TidyIterator j;
ctmbstr current_language = tidyGetLanguage();
ctmbstr current_label;
Bool skip_current = strcmp( current_language, "en" ) == 0;
Bool matches_base;
printf( "<?xml version=\"1.0\"?>\n"
"<localized_strings version=\"%s\">\n"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x39623
cmpb $0x65, (%rax)
jne 0x31ab6
cmpb $0x6e, 0x1(%rax)
jne 0x31ab6
cmpb $0x0, 0x2(%rax)
sete %r13b
jmp 0x31ab9
xorl %r13d, %r13d
callq 0x3799a
leaq 0x25d64(%rip), %rdi # 0x57829
movq %rax, %rsi
xorl %eax, %eax
callq 0x30120
cal... | /geoffmcl[P]tidy-fork/console/tidy.c |
optionhelp | static void optionhelp( TidyDoc tdoc )
{
printf( "\n" );
printf( "%s", tidyLocalizedString( TC_TXT_HELP_CONFIG ) );
printf( fmt,
tidyLocalizedString( TC_TXT_HELP_CONFIG_NAME ),
tidyLocalizedString( TC_TXT_HELP_CONFIG_TYPE ),
tidyLocalizedString( TC_TXT_HELP_CONFIG_ALLW ) );... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edi
callq 0x30060
movl $0x358, %edi # imm = 0x358
callq 0x37dcf
leaq 0x327ca(%rip), %rdi # 0x643f9
movq %rax, %rsi
xorl %eax, %eax
callq 0x30120
movl $0x359, %edi # imm = 0x359
callq 0x37dcf
movq %rax, %r14
movl... | /geoffmcl[P]tidy-fork/console/tidy.c |
helpEnv | static void helpEnv( TidyDoc tdoc )
{
tmbstr subst = "";
Bool uses_env = getenv("HTML_TIDY") != NULL;
ctmbstr env_var = uses_env ? getenv("HTML_TIDY"): tidyLocalizedString( TC_TXT_HELP_ENV_1B );
#if defined( TIDY_CONFIG_FILE ) && defined( TIDY_USER_CONFIG_FILE )
subst = stringWithFormat( tidyLocalizedS... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x2559d(%rip), %rdi # 0x57251
callq 0x30030
movq %rax, %rbx
movq %rax, %r15
testq %rax, %rax
jne 0x31cd1
movl $0x35e, %edi # imm = 0x35E
callq 0x37dcf
movq %rax, %r15
movl $0x35d, %edi # imm = 0x35D
callq 0x37dcf
leaq 0x25560(%rip), %rsi # 0x57242
leaq... | /geoffmcl[P]tidy-fork/console/tidy.c |
optionvalues | static void optionvalues( TidyDoc tdoc )
{
printf( "\n%s\n", tidyLocalizedString(TC_STRING_CONF_HEADER) );
printf( fmt, tidyLocalizedString(TC_STRING_CONF_NAME),
tidyLocalizedString(TC_STRING_CONF_TYPE),
tidyLocalizedString(TC_STRING_CONF_VALUE) );
printf( fmt, ul, ul, ul );
ForEa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x33f, %edi # imm = 0x33F
callq 0x37dcf
leaq 0x2582b(%rip), %rdi # 0x579d1
movq %rax, %rsi
xorl %eax, %eax
callq 0x30120
movl $0x340, %edi # imm = 0x340
callq 0x37dcf
movq %rax, %r14
movl $0x341, %edi # imm... | /geoffmcl[P]tidy-fork/console/tidy.c |
localize_option_names | static void localize_option_names( CmdOptDesc *pos)
{
ctmbstr fileString = tidyLocalizedString(pos->subKey);
pos->name1 = stringWithFormat(pos->name1, fileString);
if ( pos->name2 )
pos->name2 = stringWithFormat(pos->name2, fileString);
if ( pos->name3 )
pos->name3 = stringWithFormat(pos... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %edi
callq 0x37dcf
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x322c8
movq %rax, 0x8(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x32411
movq %r14, %rsi
xorl %eax, %eax
callq 0x322c8
movq %rax, 0x20(%rbx)
movq 0x28(%rb... | /geoffmcl[P]tidy-fork/console/tidy.c |
cutToWhiteSpace | static const char *cutToWhiteSpace(const char *s, /**< starting point of desired string to output */
uint offset, /**< column width desired */
char *sbuf /**< the buffer to output */
)
{
if (!s)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdi, %rdi
je 0x3247f
movl %esi, %ebp
movq %rdi, %r14
callq 0x300f0
movl %ebp, %r15d
cmpq %r15, %rax
jbe 0x32484
xorl %eax, %eax
testl %ebp, %ebp
je 0x32498
cmpb $0xa, (%r14,%rax)
je 0x32498
incq %rax
cmpq %rax, %r15
jne 0x3246e
jmp 0x3249c
mo... | /geoffmcl[P]tidy-fork/console/tidy.c |
get_escaped_name | static tmbstr get_escaped_name( ctmbstr name )
{
tmbstr escpName;
char aux[2];
uint len = 0;
ctmbstr c;
for(c=name; *c!='\0'; ++c)
switch(*c)
{
case '<':
case '>':
len += 4;
break;
case '"':
len += 6;
break;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %edi, %edi
movq %rbx, %rax
movzbl (%rax), %edx
cmpl $0x3b, %edx
jle 0x3255a
movl $0x4, %ecx
cmpl $0x3c, %edx
je 0x3256f
cmpl $0x3e, %edx
je 0x3256f
jmp 0x3256a
cmpl $0x22, %edx
jne 0x32566
movl $0x6, %ecx
jmp 0x3256f
testl %edx, %edx
je 0x32576
movl... | /geoffmcl[P]tidy-fork/console/tidy.c |
ForEachOption | static void ForEachOption(TidyDoc tdoc, /**< The Tidy document. */
OptionFunc OptionPrint /**< The printing function to be used. */
)
{
TidyIterator pos = tidyGetOptionList( tdoc );
while ( pos )
{
TidyOption topt = tidyGetNextOption( tdoc, &pos );
OptionD... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x37ae1
movq %rax, (%rsp)
testq %rax, %rax
je 0x32679
movq %rsp, %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x37af2
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x3... | /geoffmcl[P]tidy-fork/console/tidy.c |
printXMLOptionString | static void printXMLOptionString(TidyDoc tdoc, /**< The Tidy document. */
TidyOption topt, /**< The option. */
OptionDesc *d /**< The OptionDesc array. */
)
{
if ( tidyOptGetCategory(topt) == TidyInternalCategor... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x37b52
cmpl $0x138, %eax # imm = 0x138
jne 0x326ad
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4db5b(%rip), %rdi # 0x8020f
callq 0x300b0
movq (%r15), %rsi
leaq 0x24fcd(%rip), %rdi # 0x57690
xorl %eax... | /geoffmcl[P]tidy-fork/console/tidy.c |
GetOption | static void GetOption(TidyDoc tdoc, /**< The tidy document. */
TidyOption topt, /**< The option to create a description for. */
OptionDesc *d /**< [out] The new option description. */
)
{
TidyOptionId optId = tidyOptGetId( topt );
TidyOptio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x37b19
movl %eax, %r15d
movq %r12, %rdi
callq 0x37b34
movl %eax, %ebp
movq %r12, %rdi
callq 0x37b27
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x37b52
movl %eax, %ecx
addl $0xfffff... | /geoffmcl[P]tidy-fork/console/tidy.c |
ForEachSortedOption | static void ForEachSortedOption(TidyDoc tdoc, /**< The Tidy document. */
OptionFunc OptionPrint /**< The printing function to be used. */
)
{
AllOption_t tOption;
const TidyOption *topt;
getSortedOption( tdoc, &tOption );
for( top... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x3c8, %rsp # imm = 0x3C8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x37ae1
movq %rax, (%rsp)
xorl %r15d, %r15d
testq %rax, %rax
je 0x32935
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x37af2
movl %r15d, %ecx
movq %rax, 0x88(%rsp,%rcx,8)
incl %r15d
cmpq... | /geoffmcl[P]tidy-fork/console/tidy.c |
printOption | static void printOption(TidyDoc ARG_UNUSED(tdoc), /**< The Tidy document. */
TidyOption topt, /**< The option to print. */
OptionDesc *d /**< A pointer to the OptionDesc array. */
)
{
if (tidyOptGetCategory( topt ) == TidyI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rdi
callq 0x37b52
cmpl $0x138, %eax # imm = 0x138
je 0x32bcf
movq (%r14), %r12
cmpb $0x0, (%r12)
jne 0x329e6
movq 0x18(%r14), %rax
cmpb $0x0, (%rax)
je 0x32bcf
cmpl $0x0, 0x80(%r14)
... | /geoffmcl[P]tidy-fork/console/tidy.c |
printOptionValues | static void printOptionValues(TidyDoc ARG_UNUSED(tdoc), /**< The Tidy document. */
TidyOption topt, /**< The option for which to show values. */
OptionDesc *d /**< The OptionDesc array. */
)
{
TidyOptio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x37b19
movl %eax, %r15d
movq %r12, %rdi
callq 0x37b52
cmpl $0x138, %eax # imm = 0x138
je 0x3302f
leal -0x5(%r15), %eax
cmpl $0x3d, %eax
ja 0x32ff8
movabsq $0x100... | /geoffmcl[P]tidy-fork/console/tidy.c |
printOptionExportValues | static void printOptionExportValues(TidyDoc ARG_UNUSED(tdoc), /**< The Tidy document. */
TidyOption topt, /**< The option for which to show values. */
OptionDesc *d /**< The OptionDesc array. */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x37b19
movl %eax, %r15d
movq %r12, %rdi
callq 0x37b52
cmpl $0x138, %eax # imm = 0x138
je 0x3329f
leal -0x5(%r15), %eax
cmpl $0x3d, %eax
ja 0x33268
movabsq ... | /geoffmcl[P]tidy-fork/console/tidy.c |
prvTidyResetConfigToDefault | void TY_(ResetConfigToDefault)( TidyDocImpl* doc )
{
uint ixVal;
const TidyOptionImpl* option = option_defs;
TidyOptionValue* value = &doc->config.value[ 0 ];
for ( ixVal=0; ixVal < N_TIDY_OPTIONS; ++option, ++ixVal )
{
TidyOptionValue dflt;
assert( ixVal == (uint) option->id );
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
leaq 0x8af10(%rip), %r15 # 0xbe2e0
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movl (%r15), %eax
cmpq %rax, %r13
jne 0x3342f
cmpl $0x0, 0x10(%r15)
je 0x333ed
movq 0x18(%r15), %rax
jmp 0x333f1
movq 0x30(%r15), %r... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyTakeConfigSnapshot | void TY_(TakeConfigSnapshot)( TidyDocImpl* doc )
{
uint ixVal;
const TidyOptionImpl* option = option_defs;
const TidyOptionValue* value = &doc->config.value[ 0 ];
TidyOptionValue* snap = &doc->config.snapshot[ 0 ];
AdjustConfig( doc ); /* Make sure it's consistent */
for ( ixVal=0; ixVal < N_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b8(%rdi), %r14
callq 0x33ab4
leaq 0x8ae57(%rip), %r15 # 0xbe2e0
xorl %r12d, %r12d
movl (%r15), %eax
cmpq %rax, %r12
jne 0x334c6
leaq -0x348(%r14), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x339b7
addq $0x38, %r15
incq %... | /geoffmcl[P]tidy-fork/src/config.c |
ParseList | Bool ParseList( TidyDocImpl* doc, const TidyOptionImpl* option )
{
TidyConfigImpl* cfg = &doc->config;
tmbchar buf[1024];
uint i = 0, nItems = 0;
uint c;
TidyConfigChangeCallback callback = doc->pConfigChangeCallback;
tmbstr oldbuff = NULL;
/* Handle comparing before and after for the confi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rsi, %rbx
movq %rdi, %r14
movq 0x3418(%rdi), %r15
movq $0x0, 0x3418(%rdi)
testq %r15, %r15
je 0x335bf
movl (%rbx), %eax
movq 0x3460(%r14), %rdi
movq 0x70(%r14,%rax,8), %rsi
callq 0x36c18
movq %rax, %r13
jm... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidySetOptionInt | Bool TY_(SetOptionInt)( TidyDocImpl* doc, TidyOptionId optId, ulong val )
{
Bool status = ( optId < N_TIDY_OPTIONS );
if ( status )
{
assert( option_defs[ optId ].type == TidyInteger );
SetOptionInteger( doc, optId, val );
}
return status;
} | pushq %rbx
movl %esi, %ebx
cmpl $0x67, %esi
ja 0x338ac
movl %ebx, %ecx
imulq $0x38, %rcx, %rax
leaq 0x8aa60(%rip), %rsi # 0xbe2e0
cmpl $0x1, 0x10(%rax,%rsi)
jne 0x338b6
movq 0x3418(%rdi), %r8
testq %r8, %r8
je 0x338a7
cmpq %rdx, 0x70(%rdi,%rcx,8)
movq %rdx, 0x70(%rdi,%rcx,8)
je 0x338ac
addq %rax, %rsi
callq *%r8
jm... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidySetOptionBool | Bool TY_(SetOptionBool)( TidyDocImpl* doc, TidyOptionId optId, Bool val )
{
Bool status = ( optId < N_TIDY_OPTIONS );
if ( status )
{
assert( option_defs[ optId ].type == TidyBoolean );
SetOptionInteger( doc, optId, (ulong)val );
}
return status;
} | pushq %rbx
movl %esi, %ebx
cmpl $0x67, %esi
ja 0x33918
movl %ebx, %ecx
imulq $0x38, %rcx, %rax
leaq 0x8a9f6(%rip), %rsi # 0xbe2e0
cmpl $0x2, 0x10(%rax,%rsi)
jne 0x33922
movl %edx, %r8d
movq 0x3418(%rdi), %rdx
testq %rdx, %rdx
je 0x33913
cmpq %r8, 0x70(%rdi,%rcx,8)
movq %r8, 0x70(%rdi,%rcx,8)
je 0x33918
addq %rax, %... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyResetOptionToDefault | Bool TY_(ResetOptionToDefault)( TidyDocImpl* doc, TidyOptionId optId )
{
Bool status = ( optId > 0 && optId < N_TIDY_OPTIONS );
if ( status )
{
TidyOptionValue dflt;
const TidyOptionImpl* option = option_defs + optId;
TidyOptionValue* value = &doc->config.value[ optId ];
asse... | pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
leal -0x1(%rax), %ebx
cmpl $0x66, %ebx
ja 0x3398a
movl %eax, %ecx
imulq $0x38, %rcx, %rdx
leaq 0x8a983(%rip), %rsi # 0xbe2e0
cmpl %eax, (%rdx,%rsi)
jne 0x33998
addq %rdx, %rsi
leaq (%rdi,%rcx,8), %rdx
addq $0x70, %rdx
cmpl $0x0, 0x10(%rsi)
je 0x33979
movq 0x18(%rsi), %rax... | /geoffmcl[P]tidy-fork/src/config.c |
CopyOptionValue | static void CopyOptionValue( TidyDocImpl* doc, const TidyOptionImpl* option,
TidyOptionValue* oldval, const TidyOptionValue* newval )
{
Bool fire_callback = no;
assert( oldval != NULL );
/* Compare the old and new values. */
if ( doc->pConfigChangeCallback )
{
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x33a95
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x3418(%rdi)
je 0x33a19
cmpl $0x0, 0x10(%rbx)
je 0x339f1
movq (%r15), %rax
cmpq (%r12), %rax
setne %bpl
jmp 0x33a1b
movq (%r15), %rdi
movq (%r12), %rsi
cmpq %rsi,... | /geoffmcl[P]tidy-fork/src/config.c |
NeedReparseTagDecls | static Bool NeedReparseTagDecls( TidyDocImpl* doc,
const TidyOptionValue* current,
const TidyOptionValue* new,
uint *changedUserTags )
{
Bool ret = no;
uint ixVal;
const TidyOptionImpl* option = option_defs;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, (%rdx)
xorl %r12d, %r12d
leaq 0x8a5f5(%rip), %r13 # 0xbe2f0
xorl %ebp, %ebp
movl -0x10(%r13), %eax
cmpq %rax, %r12
jne 0x33dba
cmpl $0x26, %eax
jg 0x33d33
cmpl $0x5, %eax
je 0x33d5... | /geoffmcl[P]tidy-fork/src/config.c |
ReparseTagDecls | static void ReparseTagDecls( TidyDocImpl* doc, uint changedUserTags )
{
#define REPARSE_USERTAGS(USERTAGOPTION,USERTAGTYPE) \
if ( changedUserTags & USERTAGTYPE ) \
{ \
TY_(FreeDeclaredTags)( doc, USERTAGTYPE ); \
ReparseTagType( doc, USERTAGOPTION ); \
}
REPARSE_USERTAGS(TidyInlineTags... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x2, %bpl
je 0x33e01
movq %rbx, %rdi
movl $0x2, %esi
callq 0x43f94
movq %rbx, %rdi
movl $0x27, %esi
callq 0x35474
testb $0x4, %bpl
je 0x33e21
movq %rbx, %rdi
movl $0x4, %esi
callq 0x43f94
movq %rbx, %rdi
movl $0x5, %esi
callq 0x35474
testb $0x1, %b... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyCopyConfig | void TY_(CopyConfig)( TidyDocImpl* docTo, TidyDocImpl* docFrom )
{
if ( docTo != docFrom )
{
uint ixVal;
const TidyOptionImpl* option = option_defs;
const TidyOptionValue* from = &docFrom->config.value[ 0 ];
TidyOptionValue* to = &docTo->config.value[ 0 ];
uint changedU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x33ef7
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %r14
leaq 0x70(%rdi), %r15
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x33cd7
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3346b
leaq 0x8a433(%rip), %r12 # 0... | /geoffmcl[P]tidy-fork/src/config.c |
tidyFileExists | Bool TIDY_CALL tidyFileExists( TidyDoc tdoc, ctmbstr filename )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
ctmbstr fname = (tmbstr) ExpandTilde( doc, filename );
#ifndef NO_ACCESS_SUPPORT
Bool exists = ( access(fname, 0) == 0 );
#else
Bool exists;
/* at present */
FILE* fin = fopen(fname, "r");
if (fin !... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x33f6d
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x30280
movl %eax, %ebp
cmpq %r15, %r14
je 0x33f5b
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
xorl %eax, %eax
testl %ebp, %ebp
sete ... | /geoffmcl[P]tidy-fork/src/config.c |
ExpandTilde | static ctmbstr ExpandTilde( TidyDocImpl* doc, ctmbstr filename )
{
char *home_dir = NULL;
if ( !filename )
return NULL;
if ( filename[0] != '~' )
return filename;
if (filename[1] == '/')
{
home_dir = getenv("HOME");
if (home_dir) {
++filename;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x33faf
movq %rsi, %rbx
cmpb $0x7e, (%rsi)
jne 0x34070
movq %rdi, %r14
leaq 0x1(%rbx), %r15
movb 0x1(%rbx), %al
cmpb $0x2f, %al
jne 0x33fb6
leaq 0x24544(%rip), %rdi # 0x584e2
callq 0x30030
movq %rax, %r12
testq %rax, %r... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyParseConfigFileEnc | int TY_(ParseConfigFileEnc)( TidyDocImpl* doc, ctmbstr file, ctmbstr charenc )
{
enum { tidy_max_name = 64 };
uint opterrs = doc->optionErrors;
tmbstr fname = (tmbstr) ExpandTilde( doc, file );
TidyConfigImpl* cfg = &doc->config;
FILE* fin = fopen( fname, "r" );
int enc = TY_(CharEncodingId)( do... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2078, %rsp # imm = 0x2078
movq %rdx, %r12
movq %rdi, %rbx
movl 0x3428(%rdi), %r15d
movq %rsi, 0x28(%rsp)
callq 0x33f6d
movq %rax, %r14
leaq 0x7c0e8(%rip), %rsi # 0xb01a8
movq %rax, %rdi
callq 0x30290
movq %rax, %r13
movq %r12, %rdi
... | /geoffmcl[P]tidy-fork/src/config.c |
SkipWhite | static tchar SkipWhite( TidyConfigImpl* config )
{
while ( TY_(IsWhite)(config->c) && !TY_(IsNewline)(config->c) )
config->c = GetC( config );
return config->c;
} | pushq %rbx
movq %rdi, %rbx
movl 0x694(%rdi), %edi
callq 0x44c35
testl %eax, %eax
je 0x3456e
movl 0x694(%rbx), %edi
callq 0x44c4f
testl %eax, %eax
jne 0x3456e
movq 0x698(%rbx), %rdi
testq %rdi, %rdi
je 0x34561
callq 0x35e7c
movl %eax, %edi
jmp 0x34566
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl %edi, 0x694(%rbx... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyParseConfigOption | Bool TY_(ParseConfigOption)( TidyDocImpl* doc, ctmbstr optnam, ctmbstr optval )
{
const TidyOptionImpl* option = TY_(lookupOption)( optnam );
Bool isDeprecated = isOptionDeprecated( optnam );
Bool status = ( option != NULL ) && !isDeprecated;
if ( !status )
{
/* Unknown or deprecated, so che... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq $-0x38, %r12
leaq 0x89d4a(%rip), %r13 # 0xbe2e0
movq 0x40(%r12,%r13), %rsi
movq %r14, %rdi
callq 0x36d6b
testl %eax, %eax
je 0x345e1
addq $0x38, %r12
cmpq $0x1687, %r12 # imm = 0x1687
jbe 0x34596
mo... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyParseConfigValue | Bool TY_(ParseConfigValue)( TidyDocImpl* doc, TidyOptionId optId, ctmbstr optval )
{
const TidyOptionImpl* option = NULL;
/* #472: fail status if there is a NULL parser. @ralfjunker */
Bool status = ( optId < N_TIDY_OPTIONS
&& (option = option_defs + optId)->parser
&& o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ecx
movq %rdi, %rbx
cmpl $0x67, %esi
ja 0x346c8
movq %rdx, %r15
movl %ecx, %eax
imulq $0x38, %rax, %rax
leaq 0x89c7e(%rip), %rcx # 0xbe2e0
leaq (%rcx,%rax), %r14
movq 0x20(%rax,%rcx), %r13
testq %r13, %r13
setne %al
testq... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyAdjustCharEncoding | Bool TY_(AdjustCharEncoding)( TidyDocImpl* doc, int encoding )
{
int outenc = -1;
int inenc = -1;
switch( encoding )
{
case MACROMAN:
inenc = MACROMAN;
outenc = ASCII;
break;
case WIN1252:
inenc = WIN1252;
outenc = ASCII;
break;
case IB... | xorl %eax, %eax
cmpl $0xd, %esi
ja 0x347a5
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %edx
leaq 0x23df6(%rip), %rax # 0x58558
movq (%rax,%rdx,8), %r14
leaq 0x23e5b(%rip), %rax # 0x585c8
movq (%rax,%rdx,8), %r15
movl $0x8, %esi
callq 0x3386b
movq %rbx, %rdi
movl $0x22, %esi
movq %r15, %rdx
callq... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyDeclareListItem | void TY_(DeclareListItem)( TidyDocImpl* doc, const TidyOptionImpl* opt, ctmbstr name )
{
ctmbstr prvval = cfgStr( doc, opt->id );
tmbstr catval = NULL;
ctmbstr theval = name;
if ( prvval )
{
uint len = TY_(tmbstrlen)(name) + TY_(tmbstrlen)(prvval) + 3;
catval = TY_(tmbstrndup)( doc->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movq 0x70(%rdi,%rax,8), %r12
testq %r12, %r12
je 0x34812
movq %r15, %rdi
callq 0x36c57
movl %eax, %r13d
movq %r12, %rdi
callq 0x36c57
leal (%rax,%r13), %edx
addl $0x3, %edx
movq 0x3460(%rbx), %rdi
mo... | /geoffmcl[P]tidy-fork/src/config.c |
SetOptionValue | static Bool SetOptionValue( TidyDocImpl* doc, TidyOptionId optId, ctmbstr val )
{
const TidyOptionImpl* option = &option_defs[ optId ];
Bool fire_callback = no;
Bool status = ( optId < N_TIDY_OPTIONS );
if ( status )
{
assert( option->id == optId && option->type == TidyString );
/*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x67, %esi
ja 0x34977
movl %esi, %r12d
imulq $0x38, %r12, %rax
leaq 0x89a21(%rip), %r14 # 0xbe2e0
addq %rax, %r14
cmpl %esi, (%r14)
jne 0x34980
cmpl $0x0, 0x10(%r14)
jne 0x34980
movq %rdx, %r15
movq %rdi, %rbx
movb $0x1, %bpl
cmpq $0x0, 0x3418(%rdi)
je 0x... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidygetNextOption | const TidyOptionImpl* TY_(getNextOption)( TidyDocImpl* ARG_UNUSED(doc),
TidyIterator* iter )
{
const TidyOptionImpl* option = NULL;
size_t optId;
assert( iter != NULL );
optId = (size_t) *iter;
if ( optId > TidyUnknownOption && optId < N_TIDY_OPTIONS )
... | testq %rsi, %rsi
je 0x34a10
movq (%rsi), %rcx
testq %rcx, %rcx
setne %al
cmpq $0x68, %rcx
setb %dl
andb %al, %dl
imulq $0x38, %rcx, %rdi
leaq 0x898ed(%rip), %rax # 0xbe2e0
addq %rdi, %rax
xorl %edi, %edi
testb %dl, %dl
cmoveq %rdi, %rax
movzbl %dl, %edx
addq %rcx, %rdx
cmpq $0x68, %rdx
cmovaeq %rdi, %rdx
movq %rdx,... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidygetNextOptionPick | ctmbstr TY_(getNextOptionPick)( const TidyOptionImpl* option,
TidyIterator* iter )
{
size_t ix;
ctmbstr val = NULL;
const PickListItem *item= NULL;
assert( option!=NULL && iter != NULL );
ix = (size_t) *iter;
if ( option->pickList )
{
i... | testq %rdi, %rdi
je 0x34a92
testq %rsi, %rsi
je 0x34a92
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x34a8f
movq (%rsi), %rcx
testq %rcx, %rcx
sete %al
cmpq $0x10, %rcx
setae %dil
orb %al, %dil
jne 0x34a87
leaq (%rcx,%rcx,2), %rdi
shlq $0x5, %rdi
movq -0x60(%rdi,%rdx), %rax
testq %rax, %rax
je 0x34a87
cmpq $0x0, (%rdx,%r... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidyConfigDiffThanDefault | Bool TY_(ConfigDiffThanDefault)( TidyDocImpl* doc )
{
Bool diff = no;
const TidyOptionImpl* option = option_defs + 1;
const TidyOptionValue* val = doc->config.value + 1;
for ( /**/; !diff && option && option->name; ++option, ++val )
{
diff = !OptionValueEqDefault( option, val );
}
return diff;
} | addq $0x78, %rdi
leaq 0x89877(%rip), %rcx # 0xbe358
cmpl $0x0, -0x30(%rcx)
je 0x34af2
movq (%rdi), %rdx
xorl %eax, %eax
cmpq -0x28(%rcx), %rdx
jmp 0x34afb
movq (%rdi), %rdx
xorl %eax, %eax
cmpq -0x10(%rcx), %rdx
setne %al
jne 0x34b0e
addq $0x8, %rdi
cmpq $0x0, (%rcx)
leaq 0x38(%rcx), %rcx
jne 0x34ae1
retq
| /geoffmcl[P]tidy-fork/src/config.c |
prvTidySaveConfigFile | int TY_(SaveConfigFile)( TidyDocImpl* doc, ctmbstr cfgfil )
{
int status = -1;
StreamOut* out = NULL;
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
FILE* fout = fopen( cfgfil, "wb" );
if ( fout )
{
out = TY_(FileOutput)( doc, fout, outenc, nl );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x238(%rdi), %r15
movq 0x250(%rdi), %r12
leaq 0x232e6(%rip), %rsi # 0x57e18
movq %rax, %rdi
callq 0x30290
testq %rax, %rax
je 0x34b7f
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x... | /geoffmcl[P]tidy-fork/src/config.c |
SaveConfigToStream | static int SaveConfigToStream( TidyDocImpl* doc, StreamOut* out )
{
int rc = 0;
const TidyOptionImpl* option;
for ( option=option_defs+1; 0==rc && option && option->name; ++option )
{
const TidyOptionValue* val = &doc->config.value[ option->id ];
if ( option->parser == NULL )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x8976f(%rip), %r15 # 0xbe318
movq 0x8(%r15), %rbp
testq %rbp, %rbp
je 0x34d16
xorl %r13d, %r13d
cmpq $0x0, 0x20(%r15)
je 0x34c9b
movl (%r15), %ebx
movl 0x10(%r15), %eax
testl %eax, %eax
je 0x34... | /geoffmcl[P]tidy-fork/src/config.c |
prvTidySaveConfigSink | int TY_(SaveConfigSink)( TidyDocImpl* doc, TidyOutputSink* sink )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
StreamOut* out = TY_(UserOutput)( doc, sink, outenc, nl );
int status = SaveConfigToStream( doc, out );
TidyDocFree( doc, out );
return status;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x238(%rdi), %ecx
movl 0x250(%rdi), %edx
callq 0x36640
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x34b8d
movl %eax, %ebp
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /geoffmcl[P]tidy-fork/src/config.c |
ParsePickList | Bool ParsePickList( TidyDocImpl* doc, const TidyOptionImpl* entry )
{
uint value;
if ( GetParsePickListValue( doc, entry, &value ) )
{
if ( entry->type == TidyBoolean )
TY_(SetOptionBool)( doc, entry->id, value );
else if ( entry->type == TidyInteger )
TY_(SetOpt... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc(%rsp), %rdx
callq 0x3530d
testl %eax, %eax
je 0x34dae
movl 0x10(%r15), %eax
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x34dbe
cmpl $0x2, %eax
jne 0x34dcd
movl (%r15), %esi
movl 0xc(%rsp), %edx
movq %r14, %rdi
callq 0x338d5
jmp 0x34dcd
m... | /geoffmcl[P]tidy-fork/src/config.c |
ParseString | Bool ParseString( TidyDocImpl* doc, const TidyOptionImpl* option )
{
TidyConfigImpl* cfg = &doc->config;
tmbchar buf[8192];
uint i = 0;
tchar delim = 0;
Bool waswhite = yes;
tchar c = SkipWhite( cfg );
if ( c == '"' || c == '\'' )
{
delim = c;
c = AdvanceChar( cfg );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp # imm = 0x2018
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x3452a
movl %eax, %r15d
cmpl $0x27, %eax
movq %r14, 0x8(%rsp)
je 0x34e0e
xorl %ebp, %ebp
cmpl $0x22, %r15d
jne 0x34e46
cmpl $-0x1, 0x704(%rbx)
je 0x34e2a
... | /geoffmcl[P]tidy-fork/src/config.c |
ParseCharEnc | Bool ParseCharEnc( TidyDocImpl* doc, const TidyOptionImpl* option )
{
tmbchar buf[64] = {0};
uint i = 0;
int enc = ASCII;
Bool validEncoding = yes;
tchar c = SkipWhite( &doc->config );
while ( i < sizeof(buf)-2 && c != EndOfStream && !TY_(IsWhite)(c) )
{
buf[i++] = (tmbchar) TY_(ToL... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
addq $0x70, %rdi
callq 0x3452a
cmpl $-0x1, %eax
je 0x34fe0
movl %eax, %ebp
xorl %eax, %eax
movq %rax, %r15
movl ... | /geoffmcl[P]tidy-fork/src/config.c |
ParseCSS1Selector | Bool ParseCSS1Selector( TidyDocImpl* doc, const TidyOptionImpl* option )
{
TidyConfigImpl* cfg = &doc->config;
char buf[256] = {0};
uint i = 0;
uint c;
/* Given an empty string, so signal success. */
if ( cfg->c == EndOfStream )
{
SetOptionValue( doc, option->id, NULL );
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
xorl %r12d, %r12d
movl $0x100, %edx # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x30160
cmpl $-0x1, 0x704(%rbx)
je 0x350e4
leaq 0x70(%rbx), %rdi... | /geoffmcl[P]tidy-fork/src/config.c |
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.