name string | code string | asm string | file string |
|---|---|---|---|
ParseDocType | Bool ParseDocType( TidyDocImpl* doc, const TidyOptionImpl* option )
{
Bool status = yes;
uint value;
TidyConfigImpl* cfg = &doc->config;
tchar c;
/* Given an empty string, so signal success. */
if ( cfg->c == EndOfStream )
{
SetOptionValue( doc, option->id, NULL );
return ye... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x704(%rdi)
je 0x351af
leaq 0x70(%rbx), %rdi
callq 0x3452a
cmpl $0x2d, %eax
ja 0x351c9
movl %eax, %eax
movabsq $0x288400000000, %rcx # imm = 0x288400000000
btq %rax, %rcx
jae 0x351c9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34dd9
movl $0x5, %... | /geoffmcl[P]tidy-fork/src/config.c |
ParseInt | Bool ParseInt( TidyDocImpl* doc, const TidyOptionImpl* entry )
{
ulong number = 0;
Bool digits = no;
TidyConfigImpl* cfg = &doc->config;
tchar c = SkipWhite( cfg );
while ( TY_(IsDigit)(c) )
{
number = c - '0' + (10 * number);
digits = yes;
c = AdvanceChar( cfg );
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x3452a
movl %eax, %r12d
movl %eax, %edi
callq 0x44c69
testl %eax, %eax
je 0x35288
movl %eax, %ebp
xorl %r15d, %r15d
cmpl $-0x1, 0x704(%rbx)
je 0x3523f
movq 0x708(%rbx), %rdi
testq %rdi, %... | /geoffmcl[P]tidy-fork/src/config.c |
ParseTabs | Bool ParseTabs( TidyDocImpl* doc, const TidyOptionImpl* entry )
{
uint flag = 0;
Bool status = GetParsePickListValue( doc, entry, &flag );
if ( status ) {
Bool tabs = flag != 0 ? yes : no;
TY_(SetOptionBool)( doc, entry->id, tabs );
if (tabs) {
TY_(SetOptionInt)( doc... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
callq 0x3530d
movl %eax, %ebp
testl %eax, %eax
je 0x35300
movl 0x4(%rsp), %r15d
xorl %edx, %edx
testl %r15d, %r15d
setne %dl
movl (%r14), %esi
movq %rbx, %rdi
callq 0x338d5
testl %r15d, %r15d
je... | /geoffmcl[P]tidy-fork/src/config.c |
GetParsePickListValue | static Bool GetParsePickListValue( TidyDocImpl* doc, const TidyOptionImpl* entry, uint *result )
{
TidyConfigImpl* cfg = &doc->config;
tchar c = SkipWhite( cfg );
tmbchar work[ 16 ] = {0};
tmbstr cp = work, end = work + sizeof(work);
while ( c!=EndOfStream && cp < end && !TY_(IsWhite)(c) && c != '\... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rdi
callq 0x3452a
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cmpl $-0x1, %eax
je 0x3539b
movl %eax, %ebp
xorl %r12d, %r12d
movl %ebp, %edi
callq 0x44c35
testl %eax, %eax
jne... | /geoffmcl[P]tidy-fork/src/config.c |
WriteOptionString | static int WriteOptionString( const TidyOptionImpl* option,
ctmbstr sval, StreamOut* out )
{
ctmbstr cp = option->name;
while ( *cp )
TY_(WriteChar)( *cp++, out );
TY_(WriteChar)( ':', out );
TY_(WriteChar)( ' ', out );
cp = sval;
while ( *cp )
TY_(WriteChar)( *cp... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movb (%rdi), %al
testb %al, %al
je 0x354e5
movq %rdi, %r15
incq %r15
movsbl %al, %edi
movq %rbx, %rsi
callq 0x3668b
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x354d0
movl $0x3a, %edi
movq %rbx, %rsi
callq 0x3668b
movl $0x20, %edi
movq %rbx, %rsi
callq... | /geoffmcl[P]tidy-fork/src/config.c |
WriteOptionPick | static int WriteOptionPick( const TidyOptionImpl* option, uint ival, StreamOut* out )
{
uint ix = 0;
const PickListItem *item = NULL;
if ( option-> pickList )
{
while ( (item = &(*option->pickList)[ ix ]) && item->label && ix<ival )
{
++ix;
}
if ( ix==iv... | movq 0x28(%rdi), %r8
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %r8, %r8
je 0x35583
pushq %rax
movl %esi, %r9d
xorl %r10d, %r10d
movq %r10, %r11
movq (%r8), %rcx
incq %r10
cmpq %r9, %r11
jae 0x3555c
addq $0x60, %r8
testq %rcx, %rcx
jne 0x35545
incl %esi
cmpl %r10d, %esi
setne %sil
testq %rcx, %rcx
sete %r8b
... | /geoffmcl[P]tidy-fork/src/config.c |
tidyBufAllocWithAllocator | void TIDY_CALL tidyBufInitWithAllocator( TidyBuffer* buf,
TidyAllocator *allocator )
{
assert( buf != NULL );
TidyClearMemory( buf, sizeof(TidyBuffer) );
buf->allocator = allocator ? allocator : &TY_(g_default_allocator);
} | pushq %rbx
testq %rdi, %rdi
je 0x356b2
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
testq %rsi, %rsi
jne 0x3569a
leaq 0xb08f6(%rip), %rsi # 0xe5f90
movq %rsi, (%rbx)
movq %rbx, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x356d1
movl $0x0, 0x18(%rbx)
popq %rbx
retq
leaq 0x22f7f(%r... | /geoffmcl[P]tidy-fork/src/buffio.c |
tidyBufCheckAlloc | void TIDY_CALL tidyBufCheckAlloc( TidyBuffer* buf, uint allocSize, uint chunkSize )
{
assert( buf != NULL );
if ( !buf->allocator )
setDefaultAllocator( buf );
if ( 0 == chunkSize )
chunkSize = 256;
if ( allocSize+1 > buf->allocated )
{
byte* bp;
uint allocA... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3574c
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x356f0
leaq 0xb08a3(%rip), %rdi # 0xe5f90
movq %rdi, (%rbx)
incl %esi
movl 0x14(%rbx), %ecx
cmpl %ecx, %esi
jbe 0x35746
testl %edx, %edx
movl $0x100, %eax # imm = 0x100
cmovnel %edx, %eax
... | /geoffmcl[P]tidy-fork/src/buffio.c |
tidyBufFree | void TIDY_CALL tidyBufFree( TidyBuffer* buf )
{
assert( buf != NULL );
TidyFree( buf->allocator, buf->bp );
tidyBufInitWithAllocator( buf, buf->allocator );
} | pushq %rbx
testq %rdi, %rdi
je 0x357a4
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
testq %rax, %rax
jne 0x3579f
leaq 0xb07f1(%rip), %rax # 0xe5f90
movq %rax, (%rbx)
popq %rbx
retq
leaq 0... | /geoffmcl[P]tidy-fork/src/buffio.c |
tidyBufClear | void TIDY_CALL tidyBufClear( TidyBuffer* buf )
{
assert( buf != NULL );
if ( buf->bp )
{
TidyClearMemory( buf->bp, buf->allocated );
buf->size = 0;
}
buf->next = 0;
} | pushq %rbx
testq %rdi, %rdi
je 0x357ef
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x357e6
movl 0x14(%rbx), %edx
xorl %esi, %esi
callq 0x30160
movl $0x0, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
popq %rbx
retq
leaq 0x22e42(%rip), %rdi # 0x58638
leaq 0x22e47(%rip), %rsi # 0x58644
leaq 0x22f16(%rip), %rcx ... | /geoffmcl[P]tidy-fork/src/buffio.c |
tidyBufAttach | void TIDY_CALL tidyBufAttach( TidyBuffer* buf, byte* bp, uint size )
{
assert( buf != NULL );
buf->bp = bp;
buf->size = buf->allocated = size;
buf->next = 0;
if ( !buf->allocator )
setDefaultAllocator( buf );
} | testq %rdi, %rdi
je 0x35836
movq %rsi, 0x8(%rdi)
movl %edx, 0x14(%rdi)
movl %edx, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
cmpq $0x0, (%rdi)
je 0x3582b
retq
leaq 0xb075e(%rip), %rax # 0xe5f90
movq %rax, (%rdi)
retq
pushq %rax
leaq 0x22dfa(%rip), %rdi # 0x58638
leaq 0x22dff(%rip), %rsi # 0x58644
leaq 0x22f1f(%rip), ... | /geoffmcl[P]tidy-fork/src/buffio.c |
tidyBufAppend | void TIDY_CALL tidyBufAppend( TidyBuffer* buf, void* vp, uint size )
{
assert( buf != NULL );
if ( vp != NULL && size > 0 )
{
tidyBufCheckAlloc( buf, buf->size + size, 0 );
memcpy( buf->bp + buf->size, vp, size );
buf->size += size;
}
} | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x358c1
movl %edx, %ebx
movq %rsi, %r15
testq %rsi, %rsi
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x358bb
movq %rdi, %r14
movl 0x10(%rdi), %esi
addl %ebx, %esi
xorl %edx, %edx
callq 0x356d1
movl 0x10(%r14), %edi
addq 0x8(%r14), %rdi
movl %ebx, %edx
movq %r... | /geoffmcl[P]tidy-fork/src/buffio.c |
prvTidyReleaseStreamOut | void TY_(ReleaseStreamOut)( TidyDocImpl *doc, StreamOut* out )
{
if ( out && out != &stderrStreamOut && out != &stdoutStreamOut )
{
if ( out->iotype == FileIO )
fclose( (FILE*) out->sink.sinkData );
TidyDocFree( doc, out );
}
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x9d7ce(%rip), %rax # 0xd31d0
cmpq %rax, %rsi
je 0x35a47
movq %rsi, %rbx
testq %rsi, %rsi
je 0x35a47
leaq 0x9d79a(%rip), %rax # 0xd31b0
cmpq %rax, %rbx
je 0x35a47
movq %rdi, %r14
cmpl $0x0, 0xc(%rbx)
jne 0x35a2d
movq 0x10(%rbx), %rdi
callq 0x300e0
movq 0x3460(%r14), %rdi
mo... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyinitStreamIn | StreamIn* TY_(initStreamIn)( TidyDocImpl* doc, int encoding )
{
StreamIn *in = (StreamIn*) TidyDocAlloc( doc, sizeof(StreamIn) );
TidyClearMemory( in, sizeof(StreamIn) );
in->curline = 1;
in->curcol = 1;
in->encoding = encoding;
in->state = FSM_ASCII;
in->doc = doc;
in->bufsize = CHARBU... | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x3460(%rdi), %rdi
movq (%rdi), %rax
movl $0x160, %esi # imm = 0x160
callq *(%rax)
movq %rax, %r15
movl $0x158, %edx # imm = 0x158
movq %rax, %rdi
xorl %esi, %esi
callq 0x30160
movabsq $0x100000001, %rax # imm = 0x100000001... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyFileInput | StreamIn* TY_(FileInput)( TidyDocImpl* doc, FILE *fp, int encoding )
{
StreamIn *in = TY_(initStreamIn)( doc, encoding );
if ( TY_(initFileSource)( doc->allocator, &in->source, fp ) != 0 )
{
TY_(freeStreamIn)( in );
return NULL;
}
in->iotype = FileIO;
return in;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x3460(%rdi), %rdi
movq (%rdi), %rax
movl $0x160, %esi # imm = 0x160
callq *(%rax)
movq %rax, %rbx
movl $0x158, %edx # imm = 0x158
movq %rax, %rdi
xorl %esi, %esi
callq 0x30160
movabsq $0x10... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyBufferInput | StreamIn* TY_(BufferInput)( TidyDocImpl* doc, TidyBuffer* buf, int encoding )
{
StreamIn *in = TY_(initStreamIn)( doc, encoding );
tidyInitInputBuffer( &in->source, buf );
in->iotype = BufferIO;
return in;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x3460(%rdi), %rdi
movq (%rdi), %rax
movl $0x160, %esi # imm = 0x160
callq *(%rax)
movq %rax, %r14
movl $0x158, %edx # imm = 0x158
movq %rax, %rdi
xorl %esi, %esi
callq 0x30160
movabsq $0x10... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyUserInput | StreamIn* TY_(UserInput)( TidyDocImpl* doc, TidyInputSource* source, int encoding )
{
StreamIn *in = TY_(initStreamIn)( doc, encoding );
memcpy( &in->source, source, sizeof(TidyInputSource) );
in->iotype = UserIO;
return in;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x3460(%rdi), %rdi
movq (%rdi), %rax
movl $0x160, %esi # imm = 0x160
callq *(%rax)
movq %rax, %r14
movl $0x158, %edx # imm = 0x158
movq %rax, %rdi
xorl %esi, %esi
callq 0x30160
movabsq $0x10... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyReadBOMEncoding | int TY_(ReadBOMEncoding)(StreamIn *in)
{
uint c, c1;
uint bom;
c = ReadByte(in);
if (c == EndOfStream)
return -1;
c1 = ReadByte( in );
if (c1 == EndOfStream)
{
UngetByte(in, c);
return -1;
}
/* todo: dont warn about mismatch for auto input encoding */
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x138(%rdi), %rdi
callq *0x140(%r14)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x35e71
movl %eax, %ebp
movq 0x138(%r14), %rdi
callq *0x140(%r14)
cmpl $-0x1, %eax
je 0x35d96
movl %eax, %r15d
movl %ebp, %eax
shll $0x8, %... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyReadChar | uint TY_(ReadChar)( StreamIn *in )
{
uint c = EndOfStream;
if ( in->pushed )
return PopChar( in );
SaveLastPos( in );
if ( in->tabs > 0 )
{
in->curcol++;
in->tabs--;
return ' ';
}
for (;;)
{
c = ReadCharFromStream(in);
if ( EndOfSt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
je 0x35ef0
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0x36294
movq 0x10(%rbx), %rcx
decl %eax
movl %eax, 0x18(%rbx)
movl (%rcx,%rax,4), %eax
jne 0x35eb0
movl $0x0, 0x4(%rbx)
cmpl $0xa, %eax
jne 0x35f42
movl ... | /geoffmcl[P]tidy-fork/src/streamio.c |
ReadCharFromStream | static uint ReadCharFromStream( StreamIn* in )
{
uint c, n;
if ( TY_(IsEOF)(in) )
return EndOfStream;
c = ReadByte( in );
if (c == EndOfStream)
return c;
#ifndef NO_NATIVE_ISO2022_SUPPORT
/*
A document in ISO-2022 based encoding uses some ESC sequences
called "d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x138(%rdi), %rdi
callq *0x150(%r14)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x362e8
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x138(%r14), %rdi
cal... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyUngetChar | void TY_(UngetChar)( uint c, StreamIn *in )
{
if (c == EndOfStream)
{
/* fprintf(stderr, "Attempt to UngetChar EOF\n"); */
return;
}
in->pushed = yes;
if (in->bufpos + 1 >= in->bufsize)
in->charbuf = (tchar*)TidyRealloc(in->allocator, in->charbuf, sizeof(tchar) * ++(in-... | cmpl $-0x1, %edi
je 0x3654d
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, 0x4(%rsi)
movl 0x18(%rsi), %ecx
movl 0x1c(%rsi), %edx
leal 0x1(%rcx), %esi
cmpl %edx, %esi
jae 0x364d5
movq 0x10(%rbx), %rax
jmp 0x364f9
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq (%rdi), %rax
movq 0x8(%rax), %r... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyFileOutput | StreamOut* TY_(FileOutput)( TidyDocImpl *doc, FILE* fp, int encoding, uint nl )
{
StreamOut* out = initStreamOut( doc, encoding, nl );
TY_(initFileSink)( &out->sink, fp );
out->iotype = FileIO;
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq 0x3460(%rdi), %rdi
movq (%rdi), %rax
movl $0x20, %esi
callq *(%rax)
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl %ebp, (%rax)
xorl %ebp, %ebp
movl %ebp, 0x4(%rax)
movl %eb... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyBufferOutput | StreamOut* TY_(BufferOutput)( TidyDocImpl *doc, TidyBuffer* buf, int encoding, uint nl )
{
StreamOut* out = initStreamOut( doc, encoding, nl );
tidyInitOutputBuffer( &out->sink, buf );
out->iotype = BufferIO;
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq 0x3460(%rdi), %rdi
movq (%rdi), %rax
movl $0x20, %esi
callq *(%rax)
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl %ebp, (%rax)
movl $0x0, 0x4(%rax)
movl %ebx, 0x8(%rax)
lea... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyUserOutput | StreamOut* TY_(UserOutput)( TidyDocImpl *doc, TidyOutputSink* sink, int encoding, uint nl )
{
StreamOut* out = initStreamOut( doc, encoding, nl );
memcpy( &out->sink, sink, sizeof(TidyOutputSink) );
out->iotype = UserIO;
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq 0x3460(%rdi), %rdi
movq (%rdi), %rax
movl $0x20, %esi
callq *(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl %ebp, (%rax)
movl $0x0, 0x4(%rax)
movl %ebx, 0x8(%rax)
movups (%r14), %xmm0
movups %xmm0, 0x10(%... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyWriteChar | void TY_(WriteChar)( uint c, StreamOut* out )
{
/* Translate outgoing newlines */
if ( LF == c )
{
if ( out->nl == TidyCRLF )
TY_(WriteChar)( CR, out );
else if ( out->nl == TidyCR )
c = CR;
}
if (out->encoding == MACROMAN)
{
EncodeMacRoman( c, out );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movl %edi, %r14d
cmpl $0xa, %edi
jne 0x366cb
movl 0x8(%r12), %eax
cmpl $0x2, %eax
je 0x366c5
movl $0xa, %r14d
cmpl $0x1, %eax
jne 0x366cb
movl $0xd, %edi
movq %r12, %rsi
callq 0x3668b
jmp 0x366cb
movl $0xd, %r14d
movl (%r12), %eax
addl $-0x2, ... | /geoffmcl[P]tidy-fork/src/streamio.c |
tidyInitSource | Bool TIDY_CALL tidyInitSource( TidyInputSource* source,
void* srcData,
TidyGetByteFunc gbFunc,
TidyUngetByteFunc ugbFunc,
TidyEOFFunc endFunc )
{
Bool status = ( source && s... | movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
testq %r8, %r8
setne %r9b
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0 # xmm0 = xm... | /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidyoutBOM | void TY_(outBOM)( StreamOut *out )
{
if ( out->encoding == UTF8
|| out->encoding == UTF16LE
|| out->encoding == UTF16BE
|| out->encoding == UTF16
)
{
/* this will take care of encoding the BOM correctly */
TY_(WriteChar)( UNICODE_BOM, out );
}
} | movl (%rdi), %eax
cmpl $0xb, %eax
ja 0x36b76
movl $0xe10, %ecx # imm = 0xE10
btl %eax, %ecx
jae 0x36b76
movq %rdi, %rsi
movl $0xfeff, %edi # imm = 0xFEFF
jmp 0x3668b
retq
| /geoffmcl[P]tidy-fork/src/streamio.c |
prvTidytmbstrdup | tmbstr TY_(tmbstrdup)( TidyAllocator *allocator, ctmbstr str )
{
tmbstr s = NULL;
if ( str )
{
uint len = TY_(tmbstrlen)( str );
tmbstr cp = s = (tmbstr) TidyAlloc( allocator, 1+len );
while ( 0 != (*cp++ = *str++) )
/**/;
}
return s;
} | testq %rsi, %rsi
je 0x36c39
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x36c3c
movl $0x1, %eax
cmpb $0x0, (%rbx,%rax)
leaq 0x1(%rax), %rax
jne 0x36c2b
movl %eax, %esi
jmp 0x36c41
xorl %eax, %eax
retq
movl $0x1, %esi
movq (%rdi), %rax
callq *(%rax)
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %r... | /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbstrndup | tmbstr TY_(tmbstrndup)( TidyAllocator *allocator, ctmbstr str, uint len )
{
tmbstr s = NULL;
if ( str && len > 0 )
{
tmbstr cp = s = (tmbstr) TidyAlloc( allocator, 1+len );
while ( len-- > 0 && (*cp++ = *str++) )
/**/;
*cp = 0;
}
return s;
} | testq %rsi, %rsi
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x36cbd
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq (%rdi), %rax
leal 0x1(%r14), %esi
callq *(%rax)
movl %r14d, %edx
xorl %ecx, %ecx
cmpl %ecx, %edx
je 0x36cac
movb (%rbx,%rcx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
testb %s... | /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbstrncpy | uint TY_(tmbstrncpy)( tmbstr s1, ctmbstr s2, uint size )
{
if ( s1 != NULL && s2 != NULL )
{
tmbstr cp = s1;
while ( *s2 && --size ) /* Predecrement: reserve byte */
*cp++ = *s2++; /* for NULL terminator. */
*cp = 0;
}
return size;
} | movl %edx, %eax
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x36cf7
movb (%rsi), %cl
testb %cl, %cl
je 0x36cf4
incq %rsi
cmpl $0x1, %eax
je 0x36cf2
movb %cl, (%rdi)
incq %rdi
movb (%rsi), %cl
incq %rsi
decl %eax
testb %cl, %cl
jne 0x36cdb
jmp 0x36cf4
xorl %eax, %eax
movb $0x0, (%rdi)
retq
| /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbstrcat | uint TY_(tmbstrcat)( tmbstr s1, ctmbstr s2 )
{
uint ncpy = 0;
while ( *s1 )
++s1;
while (0 != (*s1++ = *s2++) )
++ncpy;
return ncpy;
} | cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x36d15
movb (%rsi), %al
movb %al, -0x1(%rdi)
testb %al, %al
je 0x36d38
xorl %eax, %eax
movb 0x1(%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
testb %cl, %cl
jne 0x36d29
retq
xorl %eax, %eax
retq
| /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbstrcmp | int TY_(tmbstrcmp)( ctmbstr s1, ctmbstr s2 )
{
int c;
while ((c = *s1) == *s2)
{
if (c == '\0')
return 0;
++s1;
++s2;
}
return (*s1 > *s2 ? 1 : -1);
} | movb (%rdi), %al
movb (%rsi), %cl
cmpb %cl, %al
jne 0x36d59
movl $0x1, %edx
testb %al, %al
je 0x36d68
movb (%rdi,%rdx), %al
movb (%rsi,%rdx), %cl
incq %rdx
cmpb %cl, %al
je 0x36d48
xorl %edx, %edx
cmpb %cl, %al
setg %dl
leal -0x1(,%rdx,2), %eax
retq
xorl %eax, %eax
retq
| /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbstrcasecmp | int TY_(tmbstrcasecmp)( ctmbstr s1, ctmbstr s2 )
{
uint c;
while (c = (uint)(*s1), TY_(ToLower)(c) == TY_(ToLower)((uint)(*s2)))
{
if (c == '\0')
return 0;
++s1;
++s2;
}
return (*s1 > *s2 ? 1 : -1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb (%rdi), %r15b
movsbl %r15b, %edi
callq 0x45978
movl %eax, %ebp
movsbl (%r14), %edi
callq 0x45978
cmpl %eax, %ebp
jne 0x36dc2
testb %r15b, %r15b
je 0x36dd9
leaq 0x1(%r14), %r12
movb 0x1(%rbx), %r15b
incq %rbx
movsbl %r15b, %edi
c... | /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbstrncasecmp | int TY_(tmbstrncasecmp)( ctmbstr s1, ctmbstr s2, uint n )
{
uint c;
while (c = (uint)(*s1), TY_(ToLower)(c) == TY_(ToLower)((uint)(*s2)))
{
if (c == '\0')
return 0;
if (n == 0)
return 0;
++s1;
++s2;
--n;
}
if (n == 0)
return... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rdi), %r12b
movsbl %r12b, %edi
callq 0x45978
movl %eax, %r15d
movsbl (%r14), %edi
callq 0x45978
cmpl %eax, %r15d
jne 0x36ebb
subl $0x1, %ebp
setb %cl
xorl %eax, %eax
testb %r12b, %r12b
je ... | /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbsubstrn | ctmbstr TY_(tmbsubstrn)( ctmbstr s1, uint len1, ctmbstr s2 )
{
uint len2 = TY_(tmbstrlen)(s2);
int ix, diff = len1 - len2;
for ( ix = 0; ix <= diff; ++ix )
{
if ( TY_(tmbstrncmp)(s1+ix, s2, len2) == 0 )
return (ctmbstr) s1+ix;
}
return NULL;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x36f16
cmpb $0x0, (%r14)
je 0x36f16
xorl %r12d, %r12d
cmpb $0x0, 0x1(%r14,%r12)
leaq 0x1(%r12), %r12
jne 0x36f09
subl %r12d, %r15d
js 0x36f38
incl %r15d
movq %rbx, %rdi
movq %r1... | /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbvsnprintf | int TY_(tmbvsnprintf)(tmbstr buffer, size_t count, ctmbstr format, va_list args)
{
int retval;
#if HAS_VSNPRINTF
retval = vsnprintf(buffer, count - 1, format, args);
/* todo: conditionally null-terminate the string? */
buffer[count - 1] = 0;
#else
retval = vsprintf(buffer, format, args);
#endif /* ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
decq %rsi
callq 0x300d0
movb $0x0, -0x1(%r14,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidytmbsnprintf | int TY_(tmbsnprintf)(tmbstr buffer, size_t count, ctmbstr format, ...)
{
int retval;
va_list args;
va_start(args, format);
retval = TY_(tmbvsnprintf)(buffer, count, format, args);
va_end(args);
return retval;
} | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x370ad
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5... | /geoffmcl[P]tidy-fork/src/tmbstr.c |
prvTidyDecodeUTF8BytesToChar | int TY_(DecodeUTF8BytesToChar)( uint* c, uint firstByte, ctmbstr successorBytes,
TidyInputSource* inp, int* count )
{
byte tempbuf[10];
byte *buf = &tempbuf[0];
uint ch = 0, n = 0;
int i, bytes = 0;
Bool hasError = no;
if ( successorBytes )
buf = (byt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdx, %rdx
leaq 0x3e(%rsp), %r13
movq %rdx, %r15
cmoveq %r13, %r15
cmpl $-0x1, %esi
je 0x37127
movq %rcx, %r12
movl %esi, %r14d
movl $0x1, %ebx
cmpl $0x80, %esi
jae 0x3713b
movb $0x1, %r10b
xorl %eax, %eax
movl %r14d, %ebp
jmp 0x37... | /geoffmcl[P]tidy-fork/src/utf8.c |
prvTidyEncodeCharToUTF8Bytes | int TY_(EncodeCharToUTF8Bytes)( uint c, tmbstr encodebuf,
TidyOutputSink* outp, int* count )
{
byte tempbuf[10] = {0};
byte* buf = &tempbuf[0];
int bytes = 0;
Bool hasError = no;
if ( encodebuf )
buf = (byte*) encodebuf;
if (c <= 0x7F) /* 0X... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
leaq 0x8(%rsp), %rax
movw $0x0, 0x8(%rax)
movq $0x0, (%rax)
testq %rsi, %rsi
movq %rsi, %r15
cmoveq %rax, %r15
cmpl $0x7f, %edi
movq %rcx, (%rsp)
ja 0x37449
movb %dil, (%r15)
movb $0x1, %bpl
movl $0x1, %r12d
jmp 0x37519
c... | /geoffmcl[P]tidy-fork/src/utf8.c |
prvTidyGetUTF8 | uint TY_(GetUTF8)( ctmbstr str, uint *ch )
{
uint n;
int bytes;
int err;
bytes = 0;
/* first byte "str[0]" is passed in separately from the */
/* rest of the UTF-8 byte sequence starting at "str[1]" */
err = TY_(DecodeUTF8BytesToChar)( &n, str[0], str+1, NULL, &bytes );
if (er... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r8
movl $0x0, (%r8)
movsbl (%rdi), %esi
leaq 0x1(%rdi), %rdx
leaq 0xc(%rsp), %rdi
xorl %ecx, %ecx
callq 0x370e8
movl $0xfffd, %ecx # imm = 0xFFFD
testl %eax, %eax
jne 0x3766c
movl 0xc(%rsp), %ecx
movl %ecx, (%rbx)
movl 0x8(%rsp), %eax
decl %eax
addq... | /geoffmcl[P]tidy-fork/src/utf8.c |
prvTidyPutUTF8 | tmbstr TY_(PutUTF8)( tmbstr buf, uint c )
{
int err, count = 0;
err = TY_(EncodeCharToUTF8Bytes)( c, buf, NULL, &count );
if (err)
{
#if 1 && defined(_DEBUG)
fprintf(stderr, "pprint UTF-8 encoding error for U+%x : ", c);
#endif
/* replacement char 0xFFFD encoded as UTF-8 */
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movl %esi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x37402
testl %eax, %eax
je 0x376ad
movw $0xbfef, (%rbx) # imm = 0xBFEF
movb $-0x43, 0x2(%rbx)
movl $0x3, %eax
jmp 0x376b2
movslq 0xc(%rsp), %rax
addq %rax, %rbx
movq %rbx, %r... | /geoffmcl[P]tidy-fork/src/utf8.c |
prvTidyCombineSurrogatePair | tchar TY_(CombineSurrogatePair)( tchar high, tchar low )
{
assert( TY_(IsHighSurrogate)(high) && TY_(IsLowSurrogate)(low) );
return ( ((low - kUTF16LowSurrogateBegin) * 0x400) +
high - kUTF16HighSurrogateBegin + 0x10000 );
} | movl $0xfffffc00, %eax # imm = 0xFFFFFC00
movl %edi, %ecx
andl %eax, %ecx
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x37714
andl %esi, %eax
cmpl $0xd800, %eax # imm = 0xD800
jne 0x37714
shll $0xa, %esi
leal (%rdi,%rsi), %eax
addl $0xfca02400, %eax # imm = 0xFCA02400
retq
pushq %rax
leaq 0x21... | /geoffmcl[P]tidy-fork/src/utf8.c |
tidyDocCreate | TidyDocImpl* tidyDocCreate( TidyAllocator *allocator )
{
TidyDocImpl* doc = (TidyDocImpl*)TidyAlloc( allocator, sizeof(TidyDocImpl) );
TidyClearMemory( doc, sizeof(*doc) );
doc->allocator = allocator;
TY_(InitMap)();
TY_(InitTags)( doc );
TY_(InitAttrs)( doc );
TY_(InitConfig)( doc );
T... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
movl $0x3490, %esi # imm = 0x3490
callq *(%rax)
movq %rax, %rbx
movl $0x3490, %edx # imm = 0x3490
movq %rax, %rdi
xorl %esi, %esi
callq 0x30160
movq %r14, 0x3460(%rbx)
callq 0x48bfa
movq %rbx, %rdi
callq 0x43f30
movq %rbx, %rdi
callq... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyRelease | void tidyDocRelease( TidyDocImpl* doc )
{
/* doc in/out opened and closed by parse/print routines */
if ( doc )
{
assert( doc->docIn == NULL );
assert( doc->docOut == NULL );
TY_(ReleaseStreamOut)( doc, doc->errout );
doc->errout = NULL;
TY_(FreePrintBuf)( ... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x37932
movq %rdi, %rbx
cmpq $0x0, 0x33d8(%rdi)
jne 0x3793a
cmpq $0x0, 0x33e0(%rbx)
jne 0x37959
movq 0x33e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x359f7
xorl %r14d, %r14d
movq %r14, 0x33e8(%rbx)
movq %rbx, %rdi
callq 0x4a7ed
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x45aab... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyOptGetDefault | ctmbstr TIDY_CALL tidyOptGetDefault( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
/* Special case for TidyDoctype, because it is declared as string */
if ( option && option->id == TidyDoctype )
{
const TidyOptionImpl* newopt = TY_(getOption)( TidyDoctypeMode... | testq %rdi, %rdi
je 0x37b8a
cmpl $0xd, (%rdi)
jne 0x37b84
pushq %rax
movl $0xe, %edi
callq 0x33535
movl 0x18(%rax), %esi
movl $0xe, %edi
popq %rax
jmp 0x33826
cmpl $0x0, 0x10(%rdi)
je 0x37b8d
xorl %eax, %eax
retq
movq 0x30(%rdi), %rax
retq
| /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyOptGetDefaultInt | ulong TIDY_CALL tidyOptGetDefaultInt( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option && option->type != TidyString )
return option->dflt;
/* Special case for TidyDoctype, because it has a picklist */
if ( option->id == TidyDoctype )
{
... | pushq %rax
testq %rdi, %rdi
je 0x37b9e
cmpl $0x0, 0x10(%rdi)
jne 0x37bb5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0xd, (%rdi)
jne 0x37bb9
movl $0xe, %edi
callq 0x33535
movq %rax, %rdi
movq 0x18(%rdi), %rax
popq %rcx
retq
| /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyOptSetInt | Bool TIDY_CALL tidyOptSetInt( TidyDoc tdoc, TidyOptionId optId, ulong val )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
/* Special case for TidyDoctype, because it has a picklist */
if ( optId == TidyDoctype )
return TY_(SetOptionInt)( impl, TidyDoctypeMode,... | testq %rdi, %rdi
je 0x37c88
cmpl $0xd, %esi
movl $0xe, %eax
cmovnel %esi, %eax
movl %eax, %esi
jmp 0x3386b
xorl %eax, %eax
retq
| /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyOptGetNextPriorityAttr | ctmbstr TIDY_CALL tidyOptGetNextPriorityAttr(TidyDoc tdoc, TidyIterator* iter )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
ctmbstr result = NULL;
if ( impl )
result = TY_(getNextPriorityAttr)( impl, iter );
else if ( iter )
*iter = 0;
return result;
} | testq %rdi, %rdi
jne 0x3b5ad
testq %rsi, %rsi
je 0x37d8d
movq $0x0, (%rsi)
xorl %eax, %eax
retq
| /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyOptGetNextDocLinks | TidyOption TIDY_CALL tidyOptGetNextDocLinks( TidyDoc tdoc, TidyIterator* pos )
{
const TidyOptionId* curr = (const TidyOptionId *)*pos;
TidyOption opt;
if (*curr == TidyUnknownOption)
{
*pos = (TidyIterator)NULL;
return (TidyOption)0;
}
opt = tidyGetOption(tdoc, *curr);
curr... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r14
movl (%r14), %edi
testl %edi, %edi
je 0x37e21
callq 0x33535
leaq 0x4(%r14), %rdx
xorl %ecx, %ecx
cmpl $0x0, 0x4(%r14)
cmovneq %rdx, %rcx
jmp 0x37e25
xorl %ecx, %ecx
xorl %eax, %eax
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyGetEmacsFile | ctmbstr TIDY_CALL tidyOptGetValue( TidyDoc tdoc, TidyOptionId optId )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
ctmbstr optval = NULL;
if ( impl )
{
if ( optId == TidyDoctype )
{
/* Special case for TidyDoctype, because it has a picklist and is a string. */
... | testq %rdi, %rdi
je 0x37efc
movq 0x110(%rdi), %rax
retq
xorl %eax, %eax
retq
| /geoffmcl[P]tidy-fork/src/tidylib.c |
tidySetErrorSink | int TIDY_CALL tidySetErrorSink( TidyDoc tdoc, TidyOutputSink* sink )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
uint outenc = cfg( impl, TidyOutCharEncoding );
uint nl = cfg( impl, TidyNewline );
TY_(ReleaseStreamOut)( impl, impl->errout );
impl->errout = T... | testq %rdi, %rdi
je 0x383f3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x238(%rdi), %ebp
movl 0x250(%rdi), %r15d
movq 0x33e8(%rdi), %rsi
callq 0x359f7
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x36640
movq %rax, 0x33e8(%rbx)
xorl %ecx, %ecx
t... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyParseBuffer | int tidyDocParseBuffer( TidyDocImpl* doc, TidyBuffer* inbuf )
{
int status = -EINVAL;
if ( inbuf )
{
StreamIn* in = TY_(BufferInput)( doc, inbuf, cfg( doc, TidyInCharEncoding ));
status = TY_(DocParseStream)( doc, in );
TY_(freeStreamIn)(in);
}
return status;
} | testq %rsi, %rsi
je 0x38701
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x180(%rdi), %edx
callq 0x35bc1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38d35
movl %eax, %ebx
movq %r14, %rdi
callq 0x35ad0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffea, %eax # imm = 0xFF... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidySaveStdout | int TIDY_CALL tidySaveStdout( TidyDoc tdoc )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocSaveStdout( doc );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x238(%rdi), %ecx
movl 0x250(%rdi), %edx
movq 0x9a79a(%rip), %r15 # 0xd2fc0
movq (%r15), %rsi
callq 0x36588
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3965a
movl %eax, %ebp
movq (%r15), %rdi
callq 0x30230
movq 0x9a7a3(%rip), %r... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidySaveBuffer | int tidyDocSaveBuffer( TidyDocImpl* doc, TidyBuffer* outbuf )
{
int status = -EINVAL;
if ( outbuf )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
StreamOut* out = TY_(BufferOutput)( doc, outbuf, outenc, nl );
status = tidyDocSave... | testq %rsi, %rsi
je 0x38960
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x238(%rdi), %ecx
movl 0x250(%rdi), %edx
callq 0x365e1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3965a
movl %eax, %ebp
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movl %ebp, %eax
popq %rbx
pop... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyRunDiagnostics | int TIDY_CALL tidyRunDiagnostics( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return tidyDocRunDiagnostics( impl );
return -EINVAL;
} | pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x38d0f
movq %rdi, %rbx
callq 0x51433
movq %rbx, %rdi
callq 0x514ca
cmpl $0x0, 0x342c(%rbx)
je 0x38cf2
movl $0x2, %ebp
cmpl $0x0, 0x160(%rbx)
jne 0x38d14
movq %rbx, %rdi
movl $0x21c, %esi # imm = 0x21C
xorl %eax, %eax
callq 0x50f3b
cmpl $0x0, 0x342c(%rbx)
... | /geoffmcl[P]tidy-fork/src/tidylib.c |
prvTidyDocParseStream | int TY_(DocParseStream)( TidyDocImpl* doc, StreamIn* in )
{
Bool xmlIn = cfgBool( doc, TidyXmlTags );
TidyConfigChangeCallback callback = doc->pConfigChangeCallback;
int bomEnc;
doc->pConfigChangeCallback = NULL;
assert( doc != NULL && in != NULL );
assert( doc->docIn == NULL );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x3a8(%rdi), %r12d
movq 0x3418(%rdi), %r15
movq $0x0, 0x3418(%rdi)
testq %rdi, %rdi
je 0x38ec0
movq %rsi, %r14
testq %rsi, %rsi
je 0x38ec0
movq %rdi, %rbx
cmpq $0x0, 0x33d8(%rdi)
jne 0x38edf
movq %r14, 0x33d8(%rbx)
movq %rbx, %rdi
callq 0x44236
movq %rbx, %rdi... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyNodeGetText | Bool TIDY_CALL tidyNodeGetText( TidyDoc tdoc, TidyNode tnod, TidyBuffer* outbuf )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
Node* nimp = tidyNodeToImpl( tnod );
if ( doc && nimp && outbuf )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
Stream... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %sil
xorl %eax, %eax
orb %cl, %sil
jne 0x394e9
movq %rdi, %rbx
movl 0x238(%rdi), %ecx
movl 0x250(%rdi), %eax
movq %rdx, %rsi
movl %eax, %edx
callq 0x365e1
movq %rax, %r15
movl 0x380(%r... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyNodeGetValue | Bool TIDY_CALL tidyNodeGetValue( TidyDoc tdoc, TidyNode tnod, TidyBuffer* buf )
{
TidyDocImpl *doc = tidyDocToImpl( tdoc );
Node *node = tidyNodeToImpl( tnod );
if ( doc == NULL || node == NULL || buf == NULL )
return no;
switch( node->type ) {
case TextNode:
case CDATATag:
case Com... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x39550
movq %rsi, %r14
movl 0x50(%rsi), %ecx
cmpl $0xc, %ecx
ja 0x39550
movl $0x1f1c, %edx # imm = 0x1F1C
btl %ecx, %edx
jae 0x39550
mov... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyNodeIsProp | Bool TIDY_CALL tidyNodeIsProp( TidyDoc ARG_UNUSED(tdoc), TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
Bool isProprietary = yes;
if ( nimp )
{
switch ( nimp->type )
{
case RootNode:
case DocTypeTag:
case CommentTag:
case XmlDecl:
case ProcInsTag:
case TextNode:
case ... | movl $0x1, %eax
testq %rsi, %rsi
je 0x39574
movl 0x50(%rsi), %ecx
cmpl $0xd, %ecx
ja 0x39574
movl $0x211f, %edx # imm = 0x211F
btl %ecx, %edx
jae 0x39575
xorl %eax, %eax
retq
movl $0xe0, %edx
btl %ecx, %edx
jae 0x39574
movq 0x38(%rsi), %rcx
testq %rcx, %rcx
je 0x39574
xorl %eax, %eax
testb $-0x20, 0x11(%rcx)
... | /geoffmcl[P]tidy-fork/src/tidylib.c |
tidyDocSaveStream | int tidyDocSaveStream( TidyDocImpl* doc, StreamOut* out )
{
Bool showMarkup = cfgBool( doc, TidyShowMarkup );
Bool forceOutput = cfgBool( doc, TidyForceOutput );
Bool outputBOM = ( cfgAutoBool(doc, TidyOutputBOM) == TidyYesState );
Bool smartBOM = ( cfgAutoBool(doc, TidyOutputBOM) == TidyA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movl 0x2d0(%rdi), %eax
movq %rax, 0x38(%rsp)
movl 0x160(%rdi), %eax
movq %rax, 0x30(%rsp)
movl 0x260(%rdi), %eax
movl %eax, 0x10(%rsp)
movl 0x390(%rdi), %eax
movq %rax, 0x28(%rsp)
movl 0x380(%rdi), %... | /geoffmcl[P]tidy-fork/src/tidylib.c |
prvTidyinitFileSource | int TY_(initFileSource)( TidyAllocator *allocator, TidyInputSource* inp, FILE* fp )
{
MappedFileSource* fin;
struct stat sbuf;
int fd;
fin = (MappedFileSource*) TidyAlloc( allocator, sizeof(MappedFileSource) );
if ( !fin )
return -1;
fd = fileno(fp);
if ( fstat(fd, &sbuf) == -1
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq (%rdi), %rax
movl $0x20, %esi
callq *(%rax)
testq %rax, %rax
je 0x3998a
movq %rax, %r15
movq %r14, %rdi
callq 0x30210
movl %eax, %ebp
leaq 0x8(%rsp), %r13
movl %eax, %edi
movq %r13, %r... | /geoffmcl[P]tidy-fork/src/mappedio.c |
prvTidyfreeFileSource | void TY_(freeFileSource)( TidyInputSource* inp, Bool closeIt )
{
if ( inp->getByte == mapped_getByte )
{
MappedFileSource* fin = (MappedFileSource*) inp->sourceData;
munmap( (void*)fin->base, fin->size );
TidyFree( fin->allocator, fin );
}
else
TY_(freeStdIOFileSource)( i... | leaq -0x2f(%rip), %rax # 0x399a5
cmpq %rax, 0x8(%rdi)
jne 0x524de
pushq %rbx
movq (%rdi), %rbx
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x30270
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
popq %rbx
jmpq *%rax
nop
| /geoffmcl[P]tidy-fork/src/mappedio.c |
prvTidytidyLocalizedStringN | ctmbstr TY_(tidyLocalizedStringN)( uint messageType, uint quantity )
{
ctmbstr result;
result = tidyLocalizedStringImpl( messageType, tidyLanguages.currentLanguage, quantity);
if (!result && tidyLanguages.fallbackLanguage )
{
result = tidyLocalizedStringImpl( messageType, tidyLanguage... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %ebx
movq 0x995cd(%rip), %r14 # 0xd31f8
movl %esi, %edi
callq *(%r14)
movl %eax, %ecx
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x39c5b
addq $0xc, %r14
cmpl %ebx, -0x4(%r14)
jne 0x39c4e
cmpl %ecx, (%r14)
je 0x39cfe
movq 0x14(%r14), %rax
addq $0x10, %r14
te... | /geoffmcl[P]tidy-fork/src/language.c |
prvTidytidyTestLanguage | languageDefinition *TY_(tidyTestLanguage)( ctmbstr languageCode )
{
uint i;
languageDefinition *testLang;
languageDictionary *testDict;
ctmbstr testCode;
for (i = 0; tidyLanguages.languages[i]; ++i)
{
testLang = tidyLanguages.languages[i];
testDict = &testLang->messages;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x993dc(%rip), %rbx # 0xd3208
testq %rbx, %rbx
je 0x39e5e
movq %rdi, %r14
movl $0x1, %ebp
leaq 0x993b0(%rip), %r15 # 0xd31f0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x301b0
testl %eax, %eax
je 0x39e60
movl %ebp, %eax
movq 0x18(%r15,%rax,8), %rbx
in... | /geoffmcl[P]tidy-fork/src/language.c |
prvTidytidySetLanguage | Bool TY_(tidySetLanguage)( ctmbstr languageCode )
{
languageDefinition *dict1 = NULL;
languageDefinition *dict2 = NULL;
tmbstr wantCode = NULL;
char lang[3] = "";
if ( !languageCode || !(wantCode = TY_(tidyNormalizedLocaleName)( languageCode )) )
{
return no;
}
/* We wa... | testq %rdi, %rdi
je 0x39eef
pushq %r14
pushq %rbx
pushq %rax
callq 0x39d0d
leaq 0x993c5(%rip), %r14 # 0xd3248
movq %r14, %rdi
callq 0x39e1e
movq %rax, %rbx
movq %r14, %rdi
callq 0x300f0
cmpq $0x2, %rax
jbe 0x39ef2
leaq 0x993a5(%rip), %rsi # 0xd3248
leaq 0x5(%rsp), %r14
movl $0x2, %edx
movq %r14, %rdi
callq 0x30... | /geoffmcl[P]tidy-fork/src/language.c |
prvTidygetNextStringKey | uint TY_(getNextStringKey)( TidyIterator* iter )
{
uint item = 0;
size_t itemIndex;
assert( iter != NULL );
itemIndex = (size_t)*iter;
if ( itemIndex > 0 && itemIndex <= tidyStringKeyListSize() )
{
item = language_en.messages[ itemIndex - 1 ].key;
itemIndex++;
}
... | testq %rdi, %rdi
je 0x3a049
movq (%rdi), %rcx
xorl %eax, %eax
movl 0xabfff(%rip), %edx # 0xe5fb0
testq %rcx, %rcx
je 0x39fe6
testl %edx, %edx
jne 0x39fec
cmpq $0x0, 0xa73ce(%rip) # 0xe1390
je 0x39fea
xorl %edx, %edx
leaq 0xa73b3(%rip), %rsi # 0xe1380
incl %edx
movq %rdx, %r8
shlq $0x4, %r8
cmpq $0x0, 0x10(%... | /geoffmcl[P]tidy-fork/src/language.c |
prvTidygetNextWindowsLanguage | const tidyLocaleMapItemImpl *TY_(getNextWindowsLanguage)( TidyIterator *iter )
{
const tidyLocaleMapItemImpl *item = NULL;
size_t itemIndex;
assert( iter != NULL );
itemIndex = (size_t)*iter;
if ( itemIndex > 0 && itemIndex <= tidyLanguageListSize() )
{
item = &localeMappings[ ... | testq %rdi, %rdi
je 0x3a104
movq (%rdi), %rcx
movl 0xabf33(%rip), %edx # 0xe5fb4
testq %rcx, %rcx
je 0x3a0b2
testl %edx, %edx
jne 0x3a0a9
xorl %edx, %edx
leaq 0x8976d(%rip), %rax # 0xc3800
incl %edx
movq %rdx, %rsi
shlq $0x4, %rsi
cmpq $0x0, (%rsi,%rax)
jne 0x3a093
movl %edx, 0xabf0b(%rip) # 0xe5fb4
cmpq %r... | /geoffmcl[P]tidy-fork/src/language.c |
prvTidygetNextInstalledLanguage | ctmbstr TY_(getNextInstalledLanguage)( TidyIterator* iter )
{
ctmbstr item = NULL;
size_t itemIndex;
assert( iter != NULL );
itemIndex = (size_t)*iter;
if ( itemIndex > 0 && itemIndex <= tidyInstalledLanguageListSize() )
{
item = tidyLanguages.languages[itemIndex - 1]->messages... | pushq %rax
testq %rdi, %rdi
je 0x3a1d5
movq (%rdi), %rcx
movl 0xabe72(%rip), %edx # 0xe5fb8
testq %rcx, %rcx
je 0x3a174
testl %edx, %edx
jne 0x3a17c
cmpq $0x0, 0x990b1(%rip) # 0xd3208
je 0x3a17a
xorl %edx, %edx
leaq 0x9908e(%rip), %rax # 0xd31f0
incl %edx
cmpq $0x0, 0x18(%rax,%rdx,8)
jne 0x3a162
movl %edx, ... | /geoffmcl[P]tidy-fork/src/language.c |
prvTidytidyMessageCreate | TidyMessageImpl *TY_(tidyMessageCreate)( TidyDocImpl *doc,
uint code,
TidyReportLevel level,
... )
{
TidyMessageImpl *result;
va_list args;
va_start(args, level);
result = tidyMessa... | subq $0xe8, %rsp
movl %edx, %r10d
movl %esi, %edx
leaq 0x30(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x3a28b
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %... | /geoffmcl[P]tidy-fork/src/messageobj.c |
prvTidytidyMessageCreateWithNode | TidyMessageImpl *TY_(tidyMessageCreateWithNode)( TidyDocImpl *doc,
Node *node,
uint code,
TidyReportLevel level,
... )
{
... | subq $0xe8, %rsp
movl %ecx, %r10d
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x3ab4a
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
testq %rsi, %rsi
j... | /geoffmcl[P]tidy-fork/src/messageobj.c |
prvTidygetNextMessageArgument | TidyMessageArgument TY_(getNextMessageArgument)( TidyMessageImpl message, TidyIterator* iter )
{
size_t item = 0;
size_t itemIndex;
assert( iter != NULL );
itemIndex = (size_t)*iter;
if ( itemIndex >= 1 && itemIndex <= (size_t)message.argcount )
{
item = itemIndex;
item... | pushq %rax
testq %rdi, %rdi
je 0x3adc1
leaq 0x10(%rsp), %rax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x3adab
movslq 0x28(%rax), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rcx, %rsi
setbe %dl
cmovbeq %rsi, %rax
addq %rsi, %rdx
jmp 0x3adb3
movslq 0x28(%rax), %rcx
xorl %eax, %eax
xorl %edx, %edx
xorl %esi, %esi
cmpq %rcx, %... | /geoffmcl[P]tidy-fork/src/messageobj.c |
prvTidygetArgValueString | ctmbstr TY_(getArgValueString)( TidyMessageImpl message, TidyMessageArgument* arg )
{
int argNum = (int)(size_t)*arg - 1;
assert( argNum <= message.argcount );
assert( message.arguments[argNum].type == tidyFormatType_STRING);
return message.arguments[argNum].u.s;
} | pushq %rax
movl (%rdi), %ecx
decl %ecx
cmpl 0x38(%rsp), %ecx
jg 0x3ae96
leaq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
cmpl $0x2, (%rax,%rcx)
jne 0x3aeb5
addq %rcx, %rax
movq 0x28(%rax), %rax
popq %rcx
retq
leaq 0x4714d(%rip), %rdi # 0x81fea
leaq 0x47094(%rip)... | /geoffmcl[P]tidy-fork/src/messageobj.c |
prvTidygetArgValueInt | int TY_(getArgValueInt)( TidyMessageImpl message, TidyMessageArgument* arg )
{
int argNum = (int)(size_t)*arg - 1;
assert( argNum <= message.argcount );
assert( message.arguments[argNum].type == tidyFormatType_INT);
return message.arguments[argNum].u.i;
} | pushq %rax
movl (%rdi), %ecx
decl %ecx
cmpl 0x38(%rsp), %ecx
jg 0x3af6c
leaq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
cmpl $0x0, (%rax,%rcx)
jne 0x3af8b
addq %rcx, %rax
movl 0x28(%rax), %eax
popq %rcx
retq
leaq 0x47077(%rip), %rdi # 0x81fea
leaq 0x46fbe(%rip)... | /geoffmcl[P]tidy-fork/src/messageobj.c |
prvTidygetArgValueDouble | double TY_(getArgValueDouble)( TidyMessageImpl message, TidyMessageArgument* arg )
{
int argNum = (int)(size_t)*arg - 1;
assert( argNum <= message.argcount );
assert( message.arguments[argNum].type == tidyFormatType_DOUBLE);
return message.arguments[argNum].u.d;
} | pushq %rax
movl (%rdi), %ecx
decl %ecx
cmpl 0x38(%rsp), %ecx
jg 0x3afd9
leaq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
cmpl $0x3, (%rax,%rcx)
jne 0x3aff8
addq %rcx, %rax
movsd 0x28(%rax), %xmm0
popq %rax
retq
leaq 0x4700a(%rip), %rdi # 0x81fea
leaq 0x46f51(%ri... | /geoffmcl[P]tidy-fork/src/messageobj.c |
prvTidyNodeAttributeVersions | uint TY_(NodeAttributeVersions)( Node* node, TidyAttrId id )
{
uint i;
if (!node || !node->tag || !node->tag->attrvers)
return VERS_UNKNOWN;
for (i = 0; node->tag->attrvers[i].attribute; ++i)
if (node->tag->attrvers[i].attribute == id)
return node->tag->attrvers[i].versions;
... | xorl %eax, %eax
testq %rdi, %rdi
je 0x3b058
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x3b058
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0x3b058
movl (%rcx), %edx
testl %edx, %edx
je 0x3b058
cmpl %esi, %edx
jne 0x3b03f
xorl %eax, %eax
jmp 0x3b054
movl $0x1, %edx
movl %edx, %eax
movl (%rcx,%rax,8), %edi
testl %edi, %edi
... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyAttributeIsProprietary | Bool TY_(AttributeIsProprietary)(Node* node, AttVal* attval)
{
if (!node || !attval)
return no;
if (!node->tag)
return no;
if (!(node->tag->versions & VERS_ALL))
return no;
if (AttributeVersions(node, attval) & VERS_ALL)
return no;
return yes;
} | testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x3b097
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x3b097
testl $0x61fff, 0x10(%rcx) # imm = 0x61FFF
je 0x3b097
pushq %rax
callq 0x3b098
movl %eax, %ecx
xorl %eax, %eax
testl $0x61fff, %ecx # imm = 0x61FFF
sete %al
addq $0x... | /geoffmcl[P]tidy-fork/src/attrs.c |
AttributeVersions | static uint AttributeVersions(Node* node, AttVal* attval)
{
uint i;
/* Override or add to items in attrdict.c */
if (attval && attval->attribute) {
/* HTML5 data-* attributes can't be added generically; handle here. */
if (TY_(tmbstrncmp)(attval->attribute, "data-", 5) == 0)
ret... | pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3b102
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rsi), %rdi
testq %rdi, %rdi
je 0x3b0c8
leaq 0x4736d(%rip), %rsi # 0x82427
movl $0x5, %edx
callq 0x36de4
testl %eax, %eax
je 0x3b0fd
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x3b102
movl $0xe000, %... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyAttributeIsMismatched | Bool TY_(AttributeIsMismatched)(Node* node, AttVal* attval, TidyDocImpl* doc)
{
uint doctype;
if (!node || !attval)
return no;
if (!node->tag)
return no;
if (!(node->tag->versions & VERS_ALL))
return no;
doctype = doc->lexer->versionEmitted == 0 ? doc->lexer->... | testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x3b169
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x3b169
testl $0x61fff, 0x10(%rcx) # imm = 0x61FFF
je 0x3b169
pushq %rbx
movq 0x68(%rdx), %rax
movl 0x28(%rax), %ebx
testl %ebx, %ebx
jne 0x3b15a
movl 0x24(%rax), %ebx
callq 0x3b09... | /geoffmcl[P]tidy-fork/src/attrs.c |
attrsLookup | static const Attribute* attrsLookup(TidyDocImpl* doc,
TidyAttribImpl* ARG_UNUSED(attribs),
ctmbstr atnam)
{
const Attribute *np;
const AttrHash *p;
if (!atnam)
return NULL;
for (p = attribs->hashtab[attrsHash(atnam)]; p && p->attr; ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x3b251
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb (%rdx), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x3b1f5
leaq 0x1(%r14), %rcx
movsbl %dl, %edx
movl %eax, %esi
shll $0x5, %esi
subl %eax, %esi
movl %esi, %eax
addl %edx, %eax
movb (%rcx),... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyDropAttrByName | void TY_(DropAttrByName)( TidyDocImpl* doc, Node *node, ctmbstr name )
{
AttVal *attr, *prev = NULL, *next;
for (attr = node->attributes; attr != NULL; prev = attr, attr = next)
{
next = attr->next;
if (attr->attribute && TY_(tmbstrcmp)(attr->attribute, name) == 0)
{
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rsi), %r13
testq %r13, %r13
je 0x3b350
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rbx
xorl %ebp, %ebp
movq %r13, %r12
movq (%r13), %r13
movq 0x28(%r12), %rdi
testq %rdi, %rdi
je 0x3b348
movq %r15, %rsi
callq 0x36d3... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyAddAttribute | AttVal* TY_(AddAttribute)( TidyDocImpl* doc,
Node *node, ctmbstr name, ctmbstr value )
{
AttVal *av = TY_(NewAttribute)(doc);
av->delim = '"';
av->attribute = TY_(tmbstrdup)(doc->allocator, name);
if (value)
av->value = TY_(tmbstrdup)(doc->allocator, value);
else
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0x48cfa
movq %rax, %r14
movl $0x22, 0x20(%rax)
movq 0x3460(%r12), %rdi
movq %r15, %rsi
callq 0x36c18
movq %rax, 0x28(%r14)
testq %r13, %r13
je 0x3b3d1
movq 0x3460(%r12), %rdi
movq %r13, %rsi
call... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyRepairAttrValue | AttVal* TY_(RepairAttrValue)(TidyDocImpl* doc, Node* node, ctmbstr name, ctmbstr value)
{
AttVal* old = TY_(GetAttrByName)(node, name);
if (old)
{
if (old->value)
TidyDocFree(doc, old->value);
if (value)
old->value = TY_(tmbstrdup)(doc->allocator, value);
els... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3b2ce
testq %rax, %rax
je 0x3b45a
movq %rax, %rbx
movq 0x30(%rax), %rsi
testq %rsi, %rsi
je 0x3b444
movq 0x3460(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
t... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyFreeAttrPriorityList | void TY_(FreeAttrPriorityList)( TidyDocImpl* doc )
{
PriorityAttribs *priorities = &(doc->attribs.priorityAttribs);
if ( priorities->list )
{
uint i = 0;
while ( priorities->list[i] != NULL )
{
TidyFree( doc->allocator, priorities->list[i] );
i++;
}
... | movq 0x2ca0(%rdi), %rsi
testq %rsi, %rsi
je 0x3b4e0
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x3b4ca
movl $0x1, %ebp
movq 0x3460(%rbx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x10(%rcx)
movq 0x2ca0(%rbx), %rsi
movl %ebp, %eax
movq (%rsi,%rax,8), %rax
incl %ebp
testq ... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyDefinePriorityAttribute | void TY_(DefinePriorityAttribute)(TidyDocImpl* doc, ctmbstr name)
{
enum { capacity = 10 };
PriorityAttribs *priorities = &(doc->attribs.priorityAttribs);
if ( !priorities->list )
{
priorities->list = TidyAlloc(doc->allocator, sizeof(ctmbstr) * capacity );
priorities->list[0] = NULL;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x2ca0(%rdi)
je 0x3b530
movl 0x2cac(%rbx), %eax
cmpl %eax, 0x2ca8(%rbx)
jb 0x3b560
addl %eax, %eax
movl %eax, 0x2cac(%rbx)
movq 0x3460(%rbx), %rdi
movq (%rdi), %rcx
movq 0x2ca0(%rbx), %rsi
leaq 0x1(,%rax,8), %rdx
callq *0x8(%rcx)
movq %rax, 0x2... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyCheckUrl | void TY_(CheckUrl)( TidyDocImpl* doc, Node *node, AttVal *attval)
{
tmbchar c;
tmbstr dest, p;
uint escape_count = 0, backslash_count = 0, bad_codepoint_count = 0;
uint i, pos = 0;
uint len;
uint increment;
Bool isJavascript = no;
if (!AttrHasValue(attval))
{
TY_(ReportAttrE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rdi, %r15
testq %rdx, %rdx
je 0x3b6bd
movq 0x30(%r13), %r12
testq %r12, %r12
je 0x3b6bd
movq %rsi, 0x28(%rsp)
leaq 0x46db1(%rip), %rsi # 0x82414
movq %r12, %rdi
movl $0xb, %edx
callq 0x36de4
movl %eax, %ebp
xorl... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyIsAnchorElement | Bool TY_(IsAnchorElement)( TidyDocImpl* ARG_UNUSED(doc), Node* node)
{
TidyTagId tid = TagId( node );
if ( tid == TidyTag_A ||
tid == TidyTag_APPLET ||
tid == TidyTag_FORM ||
tid == TidyTag_FRAME ||
tid == TidyTag_IFRAME ||
tid == TidyTag_IMG ||
t... | testq %rsi, %rsi
je 0x3b9e5
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x3b9e5
movl (%rax), %ecx
decl %ecx
cmpl $0x3f, %ecx
ja 0x3b9e5
movl $0x1, %eax
movabsq $-0x7ff5ffcfffffffdf, %rdx # imm = 0x800A003000000021
btq %rcx, %rdx
jae 0x3b9e5
retq
xorl %eax, %eax
retq
| /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyIsCSS1Selector | Bool TY_(IsCSS1Selector)( ctmbstr buf )
{
Bool valid = yes;
int esclen = 0;
byte c;
int pos;
for ( pos=0; valid && (c = *buf++); ++pos )
{
if ( c == '\\' )
{
esclen = 1; /* ab\555\444 is 4 chars {'a', 'b', \555, \444} */
}
else if ( isdigit( c ) )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
movzbl (%rbx,%r14), %r15d
movl $0x1, %eax
cmpl $0x5c, %r15d
je 0x3ba53
testl %r15d, %r15d
je 0x3ba84
callq 0x30320
movq (%rax), %rax
movzwl (%rax,%r15,2), %eax
btl $0xb, %eax
jb 0x3ba5a
testl %ebp, %ebp
movl $0x0, %... | /geoffmcl[P]tidy-fork/src/attrs.c |
anchorNameHash | static uint anchorNameHash(ctmbstr s)
{
uint hashval = 0;
/* Issue #149 - an inferred name can be null. avoid crash */
if (s)
{
for ( ; *s != '\0'; s++) {
tmbchar c = TY_(ToLower)( *s );
hashval = c + 31*hashval;
}
}
return hashval % ANCHOR_HASH_SIZE;
} | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3bbbc
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
je 0x3bbbc
incq %r14
xorl %ebx, %ebx
movsbl %al, %edi
callq 0x45978
movsbl %al, %eax
movl %ebx, %ecx
shll $0x5, %ecx
subl %ebx, %ecx
movl %ecx, %ebx
addl %eax, %ebx
movb (%r14), %al
incq %r14
tes... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyFreeAnchors | void TY_(FreeAnchors)( TidyDocImpl* doc )
{
TidyAttribImpl* attribs = &doc->attribs;
Anchor* a;
uint h;
for (h = 0; h < ANCHOR_HASH_SIZE; h++) {
while (NULL != (a = attribs->anchor_hash[h]) )
{
attribs->anchor_hash[h] = a->next;
FreeAnchor(doc, a);
}
}... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0xcb0(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x3bc0c
movq (%r14), %rax
movq %rax, 0xcb0(%rbx,%r15,8)
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
movq 0x10(%r14), %rsi
callq *0x10(%rax)
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyFreeAttrTable | void TY_(FreeAttrTable)( TidyDocImpl* doc )
{
attrsEmptyHash( doc, &doc->attribs );
TY_(FreeAnchors)( doc );
FreeDeclaredAttributes( doc );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2cb0(%rdi), %r13
xorl %r14d, %r14d
movq (%r13,%r14,8), %rsi
testq %rsi, %rsi
je 0x3bc6c
movq 0x8(%rsi), %r15
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %r15, %rsi
testq %r15, %r15
jne 0x3bc53
movq $... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyAppendToClassAttr | void TY_(AppendToClassAttr)( TidyDocImpl* doc, AttVal *classattr, ctmbstr classname )
{
uint len = TY_(tmbstrlen)(classattr->value) +
TY_(tmbstrlen)(classname) + 2;
tmbstr s = (tmbstr) TidyDocAlloc( doc, len );
s[0] = '\0';
if (classattr->value)
{
TY_(tmbstrcpy)( s, classattr->value ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rdi
callq 0x36c57
movl %eax, %r12d
movq %r15, %rdi
callq 0x36c57
leal (%r12,%rax), %esi
addl $0x2, %esi
movq 0x3460(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r12
movb $0x0, (%rax)
movq ... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyRepairDuplicateAttributes | void TY_(RepairDuplicateAttributes)( TidyDocImpl* doc, Node *node, Bool isXml )
{
AttVal *first;
for (first = node->attributes; first != NULL;)
{
AttVal *second;
Bool firstRedefined = no;
if (!(first->asp == NULL && first->php == NULL))
{
first = first->next;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x24(%rsp)
movq 0x28(%rsi), %rbx
testq %rbx, %rbx
je 0x3c13c
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x10(%rbx)
je 0x3be40
movq (%rbx), %r13
jmp 0x3be4d
cmpq $0x0, 0x18(%rbx)
movq (%rbx), %rbp
je 0x3be5a
movq %rbp, %r13
mov... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyCheckAttribute | const Attribute* TY_(CheckAttribute)( TidyDocImpl* doc, Node *node, AttVal *attval )
{
const Attribute* attribute = attval->dict;
if ( attribute != NULL )
{
if (attrIsXML_LANG(attval) || attrIsXML_SPACE(attval))
{
doc->lexer->isvoyager = yes;
if (!cfgBool(doc, TidyHt... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rbx
testq %rbx, %rbx
je 0x3c1d5
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0xffffff5d, %eax # imm = 0xFFFFFF5D
addl (%rbx), %eax
cmpl $0x1, %eax
ja 0x3c1ac
movq 0x68(%r12), %rax
movl $0x1, 0x1c(%rax)
cmpl $0x0, 0x178(%r12)
jne 0x3c... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyattrIsEvent | Bool TY_(attrIsEvent)( AttVal* attval )
{
TidyAttrId atid = AttrId( attval );
return (atid == TidyAttr_OnAFTERUPDATE ||
atid == TidyAttr_OnBEFOREUNLOAD ||
atid == TidyAttr_OnBEFOREUPDATE ||
atid == TidyAttr_OnBLUR ||
atid == TidyAttr_OnCHANGE... | xorl %eax, %eax
testq %rdi, %rdi
je 0x3c236
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x3c236
movl (%rcx), %ecx
addl $-0x5d, %ecx
xorl %eax, %eax
cmpl $0x1b, %ecx
setb %al
retq
| /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyIsValidHTMLID | Bool TY_(IsValidHTMLID)(ctmbstr id)
{
ctmbstr s = id;
if (!s)
return no;
while (*s)
if (TY_(IsHTMLSpace)(*s++))
return no;
return yes;
} | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3c260
movq %rdi, %r14
movsbl (%r14), %edi
testl %edi, %edi
je 0x3c25b
incq %r14
callq 0x44c99
testl %eax, %eax
je 0x3c245
jmp 0x3c260
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidyIsValidXMLID | Bool TY_(IsValidXMLID)(ctmbstr id)
{
ctmbstr s = id;
tchar c;
if (!s)
return no;
c = *s++;
if (c > 0x7F)
s += TY_(GetUTF8)(s, &c);
if (!(TY_(IsXMLLetter)(c) || c == '_' || c == ':'))
return no;
while (*s)
{
c = (unsigned char)*s;
if (c > 0x7F)... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3c2f9
movq %rdi, %r14
movsbl (%rdi), %edi
incq %r14
movl %edi, 0xc(%rsp)
testl %edi, %edi
jns 0x3c2a3
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x37638
movl %eax, %eax
addq %rax, %r14
movl (%r15), %edi
callq 0x44cd9... | /geoffmcl[P]tidy-fork/src/attrs.c |
prvTidySortAttributes | void TY_(SortAttributes)(TidyDocImpl* doc, Node* node, TidyAttrSortStrategy strat)
{
while (node)
{
node->attributes = SortAttVal( doc, node->attributes, strat );
if (node->content)
TY_(SortAttributes)(doc, node->content, strat);
node = node->next;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
testq %rsi, %rsi
je 0x3c4fa
movl %edx, %ebp
movq %rsi, %r14
movl %edx, 0x8(%rsp)
movq 0x28(%r14), %r13
movq 0x10(%rsp), %rax
movq 0x2ca0(%rax), %rdx
leaq 0x1427(%rip), %r8 # 0x3d768
cmpl $0x1, %ebp
movq %r14, ... | /geoffmcl[P]tidy-fork/src/attrs.c |
CheckAlign | void CheckAlign( TidyDocImpl* doc, Node *node, AttVal *attval)
{
ctmbstr const values[] = {"left", "right", "center", "justify", NULL};
/* IMG, OBJECT, APPLET and EMBED use align for vertical position */
if (node->tag && (node->tag->model & CM_IMG))
{
CheckValign( doc, node, attval );
r... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x3c537
testb $0x1, 0x22(%rax)
jne 0x3c590
testq %rbx, %rbx
je 0x3c578
cmpq $0x0, 0x30(%rbx)
je 0x3c578
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3d378
movq 0x38(%r14), %rax
testq %ra... | /geoffmcl[P]tidy-fork/src/attrs.c |
CheckColor | void CheckColor( TidyDocImpl* doc, Node *node, AttVal *attval)
{
Bool valid = no;
tmbstr given;
if (!AttrHasValue(attval))
{
TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE);
return;
}
given = attval->value;
/* 727851 - add hash to hash-less color values */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %rbp
testq %rdx, %rdx
je 0x3c61d
movq 0x30(%rbx), %r15
testq %r15, %r15
je 0x3c61d
cmpb $0x23, (%r15)
jne 0x3c63e
leaq 0x1(%r15), %rdi
callq 0x3d446
testl %eax, %eax
jne 0x3c6b4
jmp 0x3c73f
movq %rbp,... | /geoffmcl[P]tidy-fork/src/attrs.c |
CheckNumber | void CheckNumber( TidyDocImpl* doc, Node *node, AttVal *attval)
{
tmbstr p;
if (!AttrHasValue(attval))
{
TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE);
return;
}
/* don't check <frameset cols=... rows=...> */
if ( nodeIsFRAMESET(node) &&
(attrIsCOLS(a... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x3c97e
movq 0x30(%rbx), %r12
testq %r12, %r12
je 0x3c97e
testq %r14, %r14
je 0x3c92a
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x3c92a
movl (%rax), %ecx
cmpl $0x27, %ecx
jne 0x3c913
movq 0x8(%rbx)... | /geoffmcl[P]tidy-fork/src/attrs.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.