name string | code string | asm string | file string |
|---|---|---|---|
PPrintDocType | static void PPrintDocType( TidyDocImpl* doc, uint indent, Node *node )
{
TidyPrintImpl* pprint = &doc->pprint;
uint wraplen = cfg( doc, TidyWrapLen );
uint spaces = cfg( doc, TidyIndentSpaces );
AttVal* fpi = TY_(GetAttrByName)(node, "PUBLIC");
AttVal* sys = TY_(GetAttrByName)(node, "SYSTEM");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3398(%rdi), %r15
movl 0x1a0(%rdi), %eax
movq %rax, 0x10(%rsp)
movl 0x358(%rdi), %eax
movl %eax, 0xc(%rsp)
leaq 0x6362d(%rip), %rsi # 0xaeb39
movq %rdx, %rdi
callq 0x3b2ce
movq %r... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintPI | static void PPrintPI( TidyDocImpl* doc, uint indent, Node *node )
{
TidyPrintImpl* pprint = &doc->pprint;
tchar c;
tmbstr s;
SetWrap( doc, indent );
AddString( pprint, "<?" );
s = node->element;
while (s && *s)
{
c = (unsigned char)*s;
if (c > 0x7F)
s += TY... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3398(%rdi), %r15
movl 0x33ac(%rdi), %eax
leal (%rax,%rbx), %ecx
cmpq %rcx, 0x358(%rdi)
jbe 0x4b7f1
cmpl $0x0, 0x33bc(%r14)
jns 0x4b7e8
movl %ebx, 0x33bc(%r14)
movl %eax, 0x33b0(%r14)
jmp 0... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintCDATA | static void PPrintCDATA( TidyDocImpl* doc, uint indent, Node *node )
{
uint saveWrap;
TidyPrintImpl* pprint = &doc->pprint;
Bool indentCData = cfgBool( doc, TidyIndentCdata );
if ( !indentCData )
indent = 0;
PCondFlushLineSmart( doc, indent );
saveWrap = WrapOff( doc ); /* disabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl 0x190(%rdi), %eax
testl %eax, %eax
cmovel %eax, %ebp
leaq 0x3398(%rdi), %r12
movl %ebp, %esi
callq 0x4bd50
movl 0x358(%rbx), %r14d
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0x5d, %esi
... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintAsp | static void PPrintAsp( TidyDocImpl* doc, uint indent, Node *node )
{
TidyPrintImpl* pprint = &doc->pprint;
Bool wrapAsp = cfgBool( doc, TidyWrapAsp );
Bool wrapJste = cfgBool( doc, TidyWrapJste );
uint saveWrap = WrapOffCond( doc, !wrapAsp || !wrapJste );
AddString( pprint, "<%" );
PPrintText(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl 0x340(%rdi), %r13d
movl 0x358(%rdi), %r14d
testq %r13, %r13
je 0x4bb8d
movl 0x350(%rbx), %eax
testq %rax, %rax
jne 0x4bb9f
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movq %rbx, %rdi
mov... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintPhp | static void PPrintPhp( TidyDocImpl* doc, uint indent, Node *node )
{
TidyPrintImpl* pprint = &doc->pprint;
Bool wrapPhp = cfgBool( doc, TidyWrapPhp );
/* uint saveWrap = WrapOffCond( doc, !wrapPhp ); */
AddString( pprint, "<?" );
PPrintText( doc, CDATA, indent, node );
AddString( pprint, "?>" ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3398(%rdi), %r12
movl 0x360(%rdi), %ebp
leaq 0x39c10(%rip), %rsi # 0x858c3
movq %r12, %rdi
callq 0x4cfc6
movq %r14, %rdi
movl $0x10, %esi
movl %ebx, %edx
movq %r15, %rcx
callq 0x4b291
leaq 0xbd37(%rip), %rs... | /geoffmcl[P]tidy-fork/src/pprint.c |
PCondFlushLineSmart | static void PCondFlushLineSmart( TidyDocImpl* doc, uint indent )
{
TidyPrintImpl* pprint = &doc->pprint;
if ( pprint->linelen > 0 )
{
PFlushLineImpl( doc );
/* Issue #228 - cfgBool( doc, TidyVertSpace ); */
if(TidyAddVS) {
TY_(WriteChar)( '\n', doc->docOut );
... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x33ac(%rdi)
je 0x4bd8c
movq %r14, %rdi
callq 0x4a89d
cmpl $0x2, 0x328(%r14)
je 0x4bd8c
movq 0x33e0(%r14), %rsi
movl $0xa, %edi
callq 0x3668b
incl 0x33b4(%r14)
cmpl %ebx, 0x33bc(%r14)
je 0x4bd9c
movl %ebx, 0x33bc(%r14)
addq $0x8, %rsp
popq %rbx... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintTag | static void PPrintTag( TidyDocImpl* doc,
uint mode, uint indent, Node *node )
{
TidyPrintImpl* pprint = &doc->pprint;
Bool uc = cfgBool( doc, TidyUpperCaseTags );
Bool xhtmlOut = cfgBool( doc, TidyXhtmlOut );
Bool xmlOut = cfgBool( doc, TidyXmlOut );
tchar c;
tmbstr s = no... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, %ebp
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x3398(%rdi), %r12
movl 0x318(%rdi), %r15d
movl 0x380(%rdi), %eax
movq %rax, 0x10(%rsp)
movl 0x390(%rdi), %eax
movq %rax, 0x8(%rsp)
movq 0x40(%rcx), %r13
movq %r12... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintEndTag | static void PPrintEndTag( TidyDocImpl* doc, uint ARG_UNUSED(mode),
uint ARG_UNUSED(indent), Node *node )
{
TidyPrintImpl* pprint = &doc->pprint;
Bool uc = cfgBool( doc, TidyUpperCaseTags );
tmbstr s = node->element;
tchar c;
AddString( pprint, "</" );
if (s)
{
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x318(%rdi), %r12d
addq $0x3398, %rbx # imm = 0x3398
leaq 0x3984b(%rip), %rsi # 0x858fb
movq %rbx, %rdi
callq 0x4cfc6
testq %r14, %r14
je 0x4c110
movb (%r14), %al
testb %al, %al
je 0x4c110
leaq 0x4(%rsp), %r15
movz... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintScriptStyle | static
void PPrintScriptStyle( TidyDocImpl* doc, uint mode, uint indent, Node *node )
{
TidyPrintImpl* pprint = &doc->pprint;
Node* content;
ctmbstr commentStart = DEFAULT_COMMENT_START;
ctmbstr commentEnd = DEFAULT_COMMENT_END;
Bool hasCData = no;
int contentIndent = -1;
Bool xh... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x3398(%rdi), %r12
movl 0x380(%rdi), %r13d
movq %rcx, %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x4c160
cmpl $0x2e, (%rcx)
je 0x4c16a
movq (%rax), %rax
testq %rax,... | /geoffmcl[P]tidy-fork/src/pprint.c |
ShouldIndent | static Bool ShouldIndent( TidyDocImpl* doc, Node *node )
{
TidyTriState indentContent = cfgAutoBool( doc, TidyIndentContent );
if ( indentContent == TidyNoState )
return no;
if ( nodeIsTEXTAREA(node) )
return no;
if ( indentContent == TidyAutoState )
{
if ( node->content &&... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testl %edi, %edi
je 0x4c5ab
movq %rsi, %r14
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x4c4c7
cmpl $0x6e, (%rax)
je 0x4c5ab
cmpl $0x2, %edi
jne 0x4c567
cmpq $0x0, 0x18(%r14)
je 0x4c50c
movq %r14, %rdi
movl $0x40000, %esi # imm = 0x40000
callq 0x444d8
testl %eax,... | /geoffmcl[P]tidy-fork/src/pprint.c |
prvTidyPPrintXMLTree | void TY_(PPrintXMLTree)( TidyDocImpl* doc, uint mode, uint indent, Node *node )
{
Bool xhtmlOut = cfgBool( doc, TidyXhtmlOut );
if (node == NULL)
return;
if (doc->progressCallback)
{
doc->progressCallback( tidyImplToDoc(doc), node->line, node->column, doc->pprint.line + 1 );
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x4c634
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movl 0x380(%rdi), %r12d
movq 0x3420(%rdi), %rax
testq %rax, %rax
je 0x4c5f8
movl 0x54(%r14), %esi
movl 0x58(%r14), %edx
movl 0x33b4(%r15), %ecx
incl %e... | /geoffmcl[P]tidy-fork/src/pprint.c |
WantIndent | static Bool WantIndent( TidyDocImpl* doc )
{
TidyPrintImpl* pprint = &doc->pprint;
Bool wantIt = GetSpaces(pprint) > 0;
if ( wantIt )
{
Bool indentAttrs = cfgBool( doc, TidyIndentAttributes );
wantIt = ( ( !IsWrapInAttrVal(pprint) || indentAttrs ) &&
!IsWrapInString(pp... | cmpl $0x0, 0x33bc(%rdi)
jle 0x4c8e6
movl 0x188(%rdi), %edx
movl 0x33b0(%rdi), %ecx
movl 0x33c0(%rdi), %esi
xorl %eax, %eax
testl %esi, %esi
je 0x4c8c5
jle 0x4c8d2
cmpl %ecx, %esi
setge %sil
jmp 0x4c8c7
xorl %esi, %esi
testb %sil, %sil
jne 0x4c8d2
testq %rdx, %rdx
jne 0x4c8d2
retq
movl 0x33c4(%rdi), %edx
testl %edx, %ed... | /geoffmcl[P]tidy-fork/src/pprint.c |
WriteIndentChar | static void WriteIndentChar(TidyDocImpl* doc )
{
TidyPrintImpl* pprint = &doc->pprint;
uint i;
uint spaces = GetSpaces(pprint);
uint tabsize = cfg(doc, TidyTabSize);
if (spaces && (indent_char == '\t') && tabsize)
{
spaces /= tabsize; // set number of tabs to output
if (spaces =... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x33bc(%rdi), %eax
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
movq 0x308(%rdi), %rcx
setg %al
andb 0x998ad(%rip), %al # 0xe61c0
testl %ecx, %ecx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x4c930
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
cmpl %ecx, %ebp... | /geoffmcl[P]tidy-fork/src/pprint.c |
ResetLine | static void ResetLine( TidyPrintImpl* pprint )
{
TidyIndent* ind = pprint->indent + 0;
if ( pprint->ixInd > 0 )
{
ind[0] = ind[1];
InitIndent( &ind[1] );
}
if ( pprint->wraphere > 0 )
{
int wrap = (int) pprint->wraphere;
if ( ind[0].attrStringStart > wrap )
... | cmpl $0x0, 0x20(%rdi)
je 0x4c982
movl 0x38(%rdi), %eax
movl %eax, 0x2c(%rdi)
movq 0x30(%rdi), %rax
movq %rax, 0x24(%rdi)
movq $-0x1, 0x30(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movl 0x18(%rdi), %eax
movl 0x2c(%rdi), %ecx
testl %eax, %eax
je 0x4c99f
subl %eax, %ecx
jle 0x4c993
movl %ecx, 0x2c(%rdi)
movl 0... | /geoffmcl[P]tidy-fork/src/pprint.c |
WrapLine | static void WrapLine( TidyDocImpl* doc )
{
TidyPrintImpl* pprint = &doc->pprint;
uint i;
if ( pprint->wraphere == 0 )
return;
if ( WantIndent(doc) )
WriteIndentChar(doc);
for ( i = 0; i < pprint->wraphere; ++i )
TY_(WriteChar)( pprint->linebuf[i], doc->docOut );
if ( ... | cmpl $0x0, 0x33b0(%rdi)
je 0x4ca14
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4c89a
testl %eax, %eax
je 0x4c9ea
movq %rbx, %rdi
callq 0x4c8ef
cmpl $0x0, 0x33b0(%rbx)
je 0x4ca15
xorl %r14d, %r14d
movq 0x33a0(%rbx), %rax
movq 0x33e0(%rbx), %rsi
movl (%rax,%r14,4), %edi
callq 0x3668b
incq %r14
movl 0x33b0(%r... | /geoffmcl[P]tidy-fork/src/pprint.c |
ResetLineAfterWrap | static void ResetLineAfterWrap( TidyPrintImpl* pprint )
{
if ( pprint->linelen > pprint->wraphere )
{
uint *p = pprint->linebuf;
uint *q = p + pprint->wraphere;
uint *end = p + pprint->linelen;
if ( ! IsWrapInAttrVal(pprint) )
{
while ( q < end && *q == ' ' )... | movl 0x14(%rdi), %eax
movl 0x18(%rdi), %edx
xorl %ecx, %ecx
cmpl %edx, %eax
jbe 0x4cacc
movq 0x8(%rdi), %rcx
leaq (%rcx,%rdx,4), %rsi
leaq (%rcx,%rax,4), %r8
movl 0x28(%rdi), %r9d
testl %r9d, %r9d
je 0x4caac
setg %r10b
cmpl %edx, %r9d
setl %r9b
testb %r9b, %r10b
jne 0x4caac
cmpl $0x20, (%rsi)
jne 0x4caac
addq $0x4, %rs... | /geoffmcl[P]tidy-fork/src/pprint.c |
TextEndsWithNewline | static int TextEndsWithNewline(Lexer *lexer, Node *node, uint mode )
{
if ( (mode & (CDATA|COMMENT)) && TY_(nodeIsText)(node) && node->end > node->start )
{
uint ch, ix = node->end - 1;
/*\
* Skip non-newline whitespace.
* Issue #379 - Only if ix is GT start can it be decrem... | pushq %r15
pushq %r14
pushq %rbx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testb $0x12, %dl
je 0x4cb60
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x443ec
testl %eax, %eax
je 0x4cb60
movl 0x48(%r15), %ecx
movl 0x4c(%r15), %eax
cmpl %ecx, %eax
jbe 0x4cb60
leal -0x1(%rax), %edi
movq 0x68(%r14), %rdx
cmpl ... | /geoffmcl[P]tidy-fork/src/pprint.c |
TextStartsWithWhitespace | static int TextStartsWithWhitespace( Lexer *lexer, Node *node, uint start, uint mode )
{
assert( node != NULL );
if ( (mode & (CDATA|COMMENT)) && TY_(nodeIsTextLike)(node) && node->end > node->start && start >= node->start )
{
uint ch, ix = start;
/* Skip whitespace. */
while ( ix < ... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4cbf8
testb $0x12, %cl
je 0x4cbed
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x443ec
testl %eax, %eax
je 0x4cbdf
movl 0x48(%r15), %eax
movl 0x4c(%r15), %ecx
cmpl %eax, %ecx
setbe %dl
cmpl %ebx, %eax
seta %al
cmpl %ebx, %ecx
setbe %sil
orb... | /geoffmcl[P]tidy-fork/src/pprint.c |
CheckWrapIndent | static Bool CheckWrapIndent( TidyDocImpl* doc, uint indent )
{
TidyPrintImpl* pprint = &doc->pprint;
if ( GetSpaces(pprint) + pprint->linelen >= cfg(doc, TidyWrapLen) )
{
WrapLine( doc );
if ( pprint->indent[ 0 ].spaces < 0 )
{
#if defined(ENABLE_DEBUG_LOG) && defined(DEBUG_INDENT)
... | movl 0x33bc(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
addl 0x33ac(%rdi), %ecx
cmpq %rcx, 0x358(%rdi)
ja 0x4cc59
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x4c9c0
cmpl $0x0, 0x33bc(%r14)
jns 0x4cc52
movl %ebx, 0x33bc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintChar | static void PPrintChar( TidyDocImpl* doc, uint c, uint mode )
{
tmbchar entity[128];
ctmbstr p;
TidyPrintImpl* pprint = &doc->pprint;
uint outenc = cfg( doc, TidyOutCharEncoding );
Bool qmark = cfgBool( doc, TidyQuoteMarks );
if ( c == ' ' && !(mode & (PREFORMATTED | COMMENT | ATTRIBVALUE | CD... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x3398(%rdi), %rbx
movl 0x250(%rdi), %eax
movl 0x2a0(%rdi), %ecx
movl %esi, %edx
xorl $0x20, %edx
movl %ebp, %esi
andl $0x17, %esi
orl %edx, %esi
jne 0x4cca8
testb $0x8, %bpl
jne 0x4cd81
movl 0x33ac(%r15),... | /geoffmcl[P]tidy-fork/src/pprint.c |
expand | static void expand( TidyPrintImpl* pprint, uint len )
{
uint* ip;
uint buflen = pprint->lbufsize;
if ( buflen == 0 )
buflen = 256;
while ( len >= buflen )
buflen *= 2;
ip = (uint*) TidyRealloc( pprint->allocator, pprint->linebuf, buflen*sizeof(uint) );
if ( ip )
{
Tid... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
movl $0x100, %eax # imm = 0x100
cmovnel %ecx, %eax
movl %eax, %r15d
leal (%r15,%r15), %eax
cmpl %esi, %r15d
jbe 0x4d067
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq (%rdi), %rax
movl %r15d, %edx
shlq $0x2, %rdx
callq *0x8(... | /geoffmcl[P]tidy-fork/src/pprint.c |
PCondFlushLine | static void PCondFlushLine( TidyDocImpl* doc, uint indent )
{
TidyPrintImpl* pprint = &doc->pprint;
if ( pprint->linelen > 0 )
{
PFlushLineImpl( doc );
TY_(WriteChar)( '\n', doc->docOut );
pprint->line++;
}
/* Issue #390 - Whether chars to flush or not, set new indent *... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x33ac(%rdi)
je 0x4d0e6
movq %r14, %rdi
callq 0x4a89d
movq 0x33e0(%r14), %rsi
movl $0xa, %edi
callq 0x3668b
incl 0x33b4(%r14)
cmpl %ebx, 0x33bc(%r14)
je 0x4d0f6
movl %ebx, 0x33bc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintAttribute | static void PPrintAttribute( TidyDocImpl* doc, uint indent,
Node *node, AttVal *attr )
{
TidyPrintImpl* pprint = &doc->pprint;
Bool xmlOut = cfgBool( doc, TidyXmlOut );
Bool xhtmlOut = cfgBool( doc, TidyXhtmlOut );
Bool wrapAttrs = cfgBool( doc, TidyWrapAttVals );
ui... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movl 0x390(%rdi), %eax
movq %rax, 0x38(%rsp)
movl 0x380(%rdi), %eax
movq %rax, 0x40(%rsp)
movl 0x348(%rdi), %eax
movl %eax, 0x1c(%rsp)
movl 0x310(%rdi), %r12d
movl 0x188(%rdi), %esi
mo... | /geoffmcl[P]tidy-fork/src/pprint.c |
PPrintAttrValue | static void PPrintAttrValue( TidyDocImpl* doc, uint indent,
ctmbstr value, uint delim, Bool wrappable, Bool scriptAttr )
{
TidyPrintImpl* pprint = &doc->pprint;
Bool scriptlets = cfgBool(doc, TidyWrapScriptlets);
uint mode = PREFORMATTED | ATTRIBVALUE;
if ( wrappable )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
leaq 0x3398(%rdi), %rax
movq %rax, 0x28(%rsp)
movl 0x368(%rdi), %eax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpl $0x1, %r8d
adcl $0x4, ... | /geoffmcl[P]tidy-fork/src/pprint.c |
AfterSpace | static Bool AfterSpace(Lexer *lexer, Node *node)
{
return AfterSpaceImp(lexer, node, TY_(nodeCMIsEmpty)(node));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x44525
movl %eax, %ebp
movq %r15, %rdi
callq 0x4450b
movl $0x1, %ebx
testl %eax, %eax
je 0x4da26
testl %ebp, %ebp
sete %bpl
movq %r15, %r12
movq 0x8(%r12), %r13
testq %r13, %r13
jne 0x4d9f... | /geoffmcl[P]tidy-fork/src/pprint.c |
prvTidyFreeStyles | void TY_(FreeStyles)( TidyDocImpl* doc )
{
Lexer* lexer = doc->lexer;
if ( lexer )
{
TagStyle *style, *next;
for ( style = lexer->styles; style; style = next )
{
next = style->next;
TidyDocFree( doc, style->tag );
TidyDocFree( doc, style->tag_class... | movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x4daa8
pushq %r15
pushq %r14
pushq %rbx
movq 0xa0(%rax), %r14
testq %r14, %r14
je 0x4daa3
movq %rdi, %rbx
movq (%r14), %rsi
movq 0x18(%r14), %r15
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x3460(%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%r14), %rsi
callq *0... | /geoffmcl[P]tidy-fork/src/clean.c |
FindStyle | static ctmbstr FindStyle( TidyDocImpl* doc, ctmbstr tag, ctmbstr properties )
{
Lexer* lexer = doc->lexer;
TagStyle* style;
for (style = lexer->styles; style; style=style->next)
{
if (TY_(tmbstrcmp)(style->tag, tag) == 0 &&
TY_(tmbstrcmp)(style->properties, properties) == 0)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x68(%rdi), %r13
movq 0xa0(%r13), %rbp
testq %rbp, %rbp
je 0x4db53
movq (%rbp), %rdi
movq %r12, %rsi
callq 0x36d3b
testl %eax, %eax
jne 0x4db4d
movq 0x10(%rbp... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyFixNodeLinks | void TY_(FixNodeLinks)(Node *node)
{
Node *child;
if (node->prev)
node->prev->next = node;
else
node->parent->content = node;
if (node->next)
node->next->prev = node;
else
node->parent->last = node;
for (child = node->content; child; child = child->next)
... | movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4dc25
addq $0x10, %rax
jmp 0x4dc2c
movq (%rdi), %rax
addq $0x18, %rax
movq %rdi, (%rax)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x4dc3e
addq $0x8, %rax
jmp 0x4dc45
movq (%rdi), %rax
addq $0x20, %rax
movq %rdi, (%rax)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4dc5a
movq %rd... | /geoffmcl[P]tidy-fork/src/clean.c |
MergeProperties | static tmbstr MergeProperties( TidyDocImpl* doc, ctmbstr s1, ctmbstr s2 )
{
tmbstr s;
StyleProp *prop;
prop = CreateProps(doc, NULL, s1);
prop = CreateProps(doc, prop, s2);
s = CreatePropString(doc, prop);
FreeStyleProps(doc, prop);
return s;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x4feca
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4feca
movq %rax, %r14
testq %rax, %rax
je 0x4dd64
movq %r14, %r12
movq (%r12), %rdi
callq 0x36c57
addl %eax, %r15... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyCleanDocument | void TY_(CleanDocument)( TidyDocImpl* doc )
{
/* placeholder. CleanTree()/CleanNode() will not
** zap root element
*/
CleanTree( doc, &doc->root );
if ( cfgBool(doc, TidyMakeClean) )
{
DefineStyleRules( doc, &doc->root );
CreateStyleElement( doc );
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rdi, %rsi
callq 0x4e2b1
cmpl $0x0, 0x1f0(%rbx)
je 0x4e2a2
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x4e2e9
movq 0x68(%rbx), %r14
cmpq $0x0, 0xa0(%r14)
jne 0x4df0d
movq %rbx, %rdi
callq 0x460eb
testq %rax, %rax
je 0x4e2... | /geoffmcl[P]tidy-fork/src/clean.c |
CleanTree | static Node* CleanTree( TidyDocImpl* doc, Node *node )
{
if (node->content)
{
Node *child;
for (child = node->content; child != NULL; child = child->next)
{
child = CleanTree( doc, child );
if ( !child )
break;
}
}
return CleanNode... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x4e2d7
movq %r14, %rdi
callq 0x4e2b1
testq %rax, %rax
je 0x4e2d7
movq 0x10(%rax), %rsi
jmp 0x4e2bf
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x500bf
| /geoffmcl[P]tidy-fork/src/clean.c |
DefineStyleRules | static void DefineStyleRules( TidyDocImpl* doc, Node *node )
{
Node *child;
if (node->content)
{
for (child = node->content;
child != NULL; child = child->next)
{
DefineStyleRules( doc, child );
}
}
Style2Rule( doc, node );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x4e311
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e2e9
movq 0x10(%r14), %r14
jmp 0x4e2fb
movq %r15, %rdi
movl $0x91, %esi
callq 0x3b16a
testq %rax, %rax
je 0x4e3c7
movq %rax, %r14
movq 0x30(%r... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyNestedEmphasis | void TY_(NestedEmphasis)( TidyDocImpl* doc, Node* node )
{
Node *next;
while (node)
{
next = node->next;
if ( (nodeIsB(node) || nodeIsI(node))
&& node->parent && node->parent->tag == node->tag)
{
/* strip redundant inner element */
DiscardContai... | testq %rsi, %rsi
je 0x4e44b
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq 0x10(%rsi), %r15
movq %r15, 0x8(%rsp)
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x4e415
movl (%rax), %ecx
cmpl $0x31, %ecx
je 0x4e407
cmpl $0x8, %ecx
jne 0x4e415
movq (%rsi), %rcx
testq %rcx, %rcx
je ... | /geoffmcl[P]tidy-fork/src/clean.c |
DiscardContainer | static void DiscardContainer( TidyDocImpl* doc, Node *element, Node **pnode)
{
if (element->content)
{
Node *node, *parent = element->parent;
element->last->next = element->next;
if (element->next)
{
element->next->prev = element->last;
}
else
... | pushq %rbx
movq %rdx, %rbx
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x4e491
movq (%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x20(%rsi), %r8
leaq 0x20(%rax), %r9
leaq 0x8(%rdx), %r10
testq %rdx, %rdx
cmoveq %r9, %r10
movq %rdx, 0x10(%r8)
movq %r8, (%r10)
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4e49b
movq %rdx, 0x8(%rcx... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyEmFromI | void TY_(EmFromI)( TidyDocImpl* doc, Node* node )
{
while (node)
{
if ( nodeIsI(node) )
RenameElem( doc, node, TidyTag_EM );
else if ( nodeIsB(node) )
RenameElem( doc, node, TidyTag_STRONG );
if ( node->content )
TY_(EmFromI)( doc, node->content );
... | testq %rsi, %rsi
je 0x4e52e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x4e50d
movl (%rax), %eax
cmpl $0x31, %eax
je 0x4e4fd
cmpl $0x8, %eax
jne 0x4e50d
movl $0x66, %edx
jmp 0x4e502
movl $0x21, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e52f
movq 0x18(%... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyList2BQ | void TY_(List2BQ)( TidyDocImpl* doc, Node* node )
{
while (node)
{
if (node->content)
TY_(List2BQ)( doc, node->content );
if ( node->tag && node->tag->parser == TY_(ParseList) &&
HasOneChild(node) && node->content->implicit )
{
StripOnlyChild( doc, n... | testq %rsi, %rsi
je 0x4e5f4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xfb7e(%rip), %r15 # 0x3ea0c
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x4e59b
movq %r14, %rdi
callq 0x4e573
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x4e5aa
cmpq %r15, 0x28(%rax)
je 0x4e5b5
movq 0x10(%rbx), %rbx
tes... | /geoffmcl[P]tidy-fork/src/clean.c |
StripOnlyChild | static void StripOnlyChild(TidyDocImpl* doc, Node *node)
{
Node *child;
child = node->content;
node->content = child->content;
node->last = child->last;
child->content = NULL;
TY_(FreeNode)(doc, child);
for (child = node->content; child; child = child->next)
child->parent = node;
} | pushq %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %rsi
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rbx)
movq $0x0, 0x18(%rsi)
callq 0x45aab
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x4e624
movq %rbx, (%rax)
movq 0x10(%rax), %rax
jmp 0x4e616
popq %rbx
retq
| /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyBQ2Div | void TY_(BQ2Div)( TidyDocImpl* doc, Node *node )
{
tmbchar indent_buf[ 32 ];
uint indent;
while (node)
{
if ( nodeIsBLOCKQUOTE(node) && node->implicit )
{
indent = 1;
while( HasOneChild(node) &&
nodeIsBLOCKQUOTE(node->content) &&
... | testq %rsi, %rsi
je 0x4e703
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x372e6(%rip), %r15 # 0x8592e
movq %rsp, %r12
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x4e69b
cmpl $0xf, (%rax)
jne 0x4e69b
cmpl $0x0, 0x60(%rbx)
je 0x4e69b
movq 0x18(%rbx), %rs... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyDropSections | void TY_(DropSections)( TidyDocImpl* doc, Node* node )
{
Lexer* lexer = doc->lexer;
while (node)
{
if (node->type == SectionTag)
{
/* prune up to matching endif */
if ((TY_(tmbstrncmp)(lexer->lexbuf + node->start, "if", 2) == 0) &&
(TY_(tmbstrncmp)(lex... | testq %rsi, %rsi
je 0x4e7a7
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %r13
leaq 0x3741c(%rip), %r15 # 0x85b43
leaq 0x37212(%rip), %r12 # 0x85940
cmpl $0x9, 0x50(%r14)
jne 0x4e75b
movl 0x48(%r14), %edi
addq 0x68(%r13), %rdi
movq %r15, %rsi
movl $0x2, ... | /geoffmcl[P]tidy-fork/src/clean.c |
PruneSection | static Node* PruneSection( TidyDocImpl* doc, Node *node )
{
Lexer* lexer = doc->lexer;
for (;;)
{
if (node == NULL)
return NULL;
ctmbstr lexbuf = lexer->lexbuf + node->start;
if ( TY_(tmbstrncmp)(lexbuf, "if !supportEmptyParas", 21) == 0 )
{
No... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4e89b
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %r15
leaq 0x3735b(%rip), %r12 # 0x85b28
leaq 0x3736f(%rip), %rbp # 0x85b43
leaq 0x37365(%rip), %r13 # 0x85b40
movl 0x48(%r14), %edi
addq 0x68(%r15), %rdi
... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyNormalizeSpaces | void TY_(NormalizeSpaces)(Lexer *lexer, Node *node)
{
while ( node )
{
if ( node->content )
TY_(NormalizeSpaces)( lexer, node->content );
if (TY_(nodeIsText)(node))
{
uint i, c;
tmbstr p = lexer->lexbuf + node->start;
for (i = node->start... | testq %rsi, %rsi
je 0x4e98b
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x4e8f7
movq %r14, %rdi
callq 0x4e8c5
movq %rbx, %rdi
callq 0x443ec
testl %eax, %eax
je 0x4e971
movq 0x68(%r14), %rax
movl 0x... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyCleanWord2000 | void TY_(CleanWord2000)( TidyDocImpl* doc, Node *node)
{
/* used to a list from a sequence of bulletted p's */
Lexer* lexer = doc->lexer;
Node* list = NULL;
AttVal *next_attr, *attval;
while ( node )
{
/* get rid of Word's xmlns attributes */
if ( nodeIsHTML(node) )
{
... | testq %rsi, %rsi
je 0x4eea7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x68(%rdi), %r14
leaq 0x33eab(%rip), %rbp # 0x8285f
movq $0x0, (%rsp)
movq 0x38(%r12), %rax
testq %rax, %rax
je 0x4eaf5
movl (%rax), %eax
cmpl $0x30, %eax
jne 0x4ea3a
m... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyIsWord2000 | Bool TY_(IsWord2000)( TidyDocImpl* doc )
{
AttVal *attval;
Node *node, *head;
Node *html = TY_(FindHTML)( doc );
if (html && TY_(GetAttrByName)(html, "xmlns:o"))
return yes;
/* search for <meta name="GENERATOR" content="Microsoft ..."> */
head = TY_(FindHEAD)( doc );
if (head)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x46035
testq %rax, %rax
je 0x4eeda
leaq 0x36ab9(%rip), %rsi # 0x8597d
movq %rax, %rdi
callq 0x3b2ce
movl $0x1, %ebx
testq %rax, %rax
jne 0x4ef71
movq %r14, %rdi
callq 0x46077
xorl %ebx, %ebx
testq %rax, %rax
je 0x4ef71
movq 0x18(%rax), %r... | /geoffmcl[P]tidy-fork/src/clean.c |
NoMargins | static Bool NoMargins(Node *node)
{
AttVal *attval = TY_(AttrGetById)(node, TidyAttr_STYLE);
if ( !AttrHasValue(attval) )
return no;
/* search for substring "margin-top: 0" */
if (!TY_(tmbsubstr)(attval->value, "margin-top: 0"))
return no;
/* search for substring "margin-bottom: 0... | pushq %r14
pushq %rbx
pushq %rax
movl $0x91, %esi
callq 0x3b16a
xorl %ebx, %ebx
testq %rax, %rax
je 0x4efc9
movq %rax, %r14
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x4efc9
leaq 0x36b9f(%rip), %rsi # 0x85b46
callq 0x36f49
testq %rax, %rax
je 0x4efc9
movq 0x30(%r14), %rdi
leaq 0x36b98(%rip), %rsi # 0x85b54
call... | /geoffmcl[P]tidy-fork/src/clean.c |
StripSpan | static Node* StripSpan( TidyDocImpl* doc, Node* span )
{
Node *node, *prev = NULL, *content;
/*
deal with span elements that have content
by splicing the content in place of the span
after having processed it
*/
TY_(CleanWord2000)( doc, span->content );
content = span->content;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x4e98c
movq 0x8(%rbx), %r12
movq 0x18(%rbx), %r15
testq %r12, %r12
jne 0x4f135
testq %r15, %r15
je 0x4f163
movq 0x10(%r15), %r13
movq %r15, %rdi
callq 0x3da07
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3dad3... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyBumpObject | void TY_(BumpObject)( TidyDocImpl* doc, Node *html )
{
Node *node, *next, *head = NULL, *body = NULL;
if (!html)
return;
for ( node = html->content; node != NULL; node = node->next )
{
if ( nodeIsHEAD(node) )
head = node;
if ( nodeIsBODY(node) )
body = ... | testq %rsi, %rsi
je 0x4f260
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x4f260
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %eax, %eax
movq 0x38(%rcx), %rdx
testq %rdx, %rdx
je 0x4f1d6
movl (%rdx), %edx
cmpl $0x2e, %edx
cmoveq %rcx, %rax
cmpl $0x10, %edx
cmoveq %rcx, %r14... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyTidyMetaCharset | Bool TY_(TidyMetaCharset)(TidyDocImpl* doc)
{
AttVal *charsetAttr;
AttVal *contentAttr;
AttVal *httpEquivAttr;
Bool charsetFound = no;
uint outenc = cfg(doc, TidyOutCharEncoding);
ctmbstr enc = TY_(GetEncodingNameFromTidyId)(outenc);
Node *currentNode;
Node *head = TY_(FindHEAD)(doc);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl 0x250(%rdi), %r12d
movl %r12d, %edi
callq 0x36b77
movq %rax, %r15
movq %rbx, %rdi
callq 0x46077
movq %rax, %r14
testq %rax, %rax
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
xorl %ebp, %ebp
cmpb $0x1, %cl
jne 0... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyDropComments | void TY_(DropComments)(TidyDocImpl* doc, Node* node)
{
Node* next;
while (node)
{
next = node->next;
if (node->type == CommentTag)
{
TY_(RemoveNode)(node);
TY_(FreeNode)(doc, node);
node = next;
continue;
}
if (node->... | testq %rsi, %rsi
je 0x4f713
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %r14, %r15
movq 0x10(%r14), %r14
cmpl $0x2, 0x50(%r15)
jne 0x4f6f8
movq %r15, %rdi
callq 0x3da07
movq %rbx, %rdi
movq %r15, %rsi
callq 0x45aab
jmp 0x4f709
movq 0x18(%r15), %rsi
testq %rsi, %rsi
je 0x4f709
movq %rbx, %rdi
c... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyDropFontElements | void TY_(DropFontElements)(TidyDocImpl* doc, Node* node, Node **ARG_UNUSED(pnode))
{
Node* next;
while (node)
{
next = node->next;
if (nodeIsFONT(node))
{
DiscardContainer(doc, node, &next);
node = next;
continue;
}
if (node->con... | testq %rsi, %rsi
je 0x4f775
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq 0x10(%rsi), %r15
movq %r15, 0x8(%rsp)
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x4f753
cmpl $0x24, (%rax)
jne 0x4f753
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4e44c
movq 0x8(%rsp), %r15
jmp 0x4f764
mo... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyWbrToSpace | void TY_(WbrToSpace)(TidyDocImpl* doc, Node* node)
{
Node* next;
while (node)
{
next = node->next;
if (nodeIsWBR(node))
{
Node* text;
text = TY_(NewLiteralTextNode)(doc->lexer, " ");
TY_(InsertNodeAfterElement)(node, text);
TY_(Remove... | testq %rsi, %rsi
je 0x4f7f4
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2a5e1(%rip), %r15 # 0x79d71
movq %r14, %r12
movq 0x10(%r14), %r14
movq 0x38(%r12), %rax
testq %rax, %rax
je 0x4f7d2
cmpl $0x78, (%rax)
jne 0x4f7d2
movq 0x68(%rbx), %rdi
movq %r15, %rsi
callq 0x4... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyDowngradeTypography | void TY_(DowngradeTypography)(TidyDocImpl* doc, Node* node)
{
Node* next;
Lexer* lexer = doc->lexer;
while (node)
{
next = node->next;
if (TY_(nodeIsText)(node))
{
uint i, c;
tmbstr p = lexer->lexbuf + node->start;
for (i = node->start; i < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testq %rsi, %rsi
je 0x4f909
movq %rsi, %r15
movq 0x10(%rsp), %rax
movq 0x68(%rax), %r13
movl $0xe0, %ebp
movq 0x10(%r15), %rbx
movq %r15, %rdi
callq 0x443ec
testl %eax, %eax
je 0x4f8ea
movq 0x68(%r13), %rax
movl 0x4... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyReplacePreformattedSpaces | void TY_(ReplacePreformattedSpaces)(TidyDocImpl* doc, Node* node)
{
Node* next;
while (node)
{
next = node->next;
if (node->tag && node->tag->parser == TY_(ParsePre))
{
TY_(NormalizeSpaces)(doc->lexer, node->content);
node = next;
continue;
... | testq %rsi, %rsi
je 0x4f96f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xebd2(%rip), %r15 # 0x40d5d
movq %r14, %rax
movq 0x10(%r14), %r14
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x4f945
cmpq %r15, 0x28(%rcx)
je 0x4f958
movq 0x18(%rax), %rsi
testq %rsi, %rsi
je 0x4f965
movq %rbx, %rdi
c... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyFixLanguageInformation | void TY_(FixLanguageInformation)(TidyDocImpl* doc, Node* node, Bool wantXmlLang, Bool wantLang)
{
Node* next;
while (node)
{
next = node->next;
/* todo: report modifications made here to the report system */
if (TY_(nodeIsElement)(node))
{
AttVal* lang = TY_(At... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
testq %rsi, %rsi
je 0x4faf0
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movq 0x10(%r13), %rbx
movq %r13, %rdi
callq 0x4445a
testl %eax, %eax
je 0x4facd
movq %r13, %rdi
movl $0x49, %esi
callq 0x3b16a
movq %rax, %r15
mov... | /geoffmcl[P]tidy-fork/src/clean.c |
prvTidyFixXhtmlNamespace | void TY_(FixXhtmlNamespace)(TidyDocImpl* doc, Bool wantXmlns)
{
Node* html = TY_(FindHTML)(doc);
AttVal* xmlns;
if (!html)
return;
xmlns = TY_(AttrGetById)(html, TidyAttr_XMLNS);
if (wantXmlns)
{
if (!AttrValueIs(xmlns, XHTML_NAMESPACE))
TY_(RepairAttrValue)(doc, h... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x46035
testq %rax, %rax
je 0x4fb78
movq %rax, %r14
movq %rax, %rdi
movl $0xa5, %esi
callq 0x3b16a
testl %ebp, %ebp
je 0x4fb61
testq %rax, %rax
je 0x4fb44
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x4fb44
leaq 0x33fc4(%rip), %rsi # 0x83aff
callq... | /geoffmcl[P]tidy-fork/src/clean.c |
StyleToHead | static void StyleToHead(TidyDocImpl* doc, Node *head, Node *node, Bool fix, int indent)
{
Node *next;
while (node)
{
next = node->next; /* get 'next' now , in case the node is moved */
/* dbg_show_node(doc, node, 0, indent); */
if (nodeIsSTYLE(node))
{
if (fix)
{
TY_(RemoveNode)(node); /* unhook st... | testq %rdx, %rdx
je 0x4fec9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
incl %ebx
movq %r15, %r13
movq 0x10(%r15), %r15
movq 0x38(%r13), %rax
testq %rax, %rax
je 0x4fe86
cmpl $0x67, (%rax)
jne 0x4fe86
testl ... | /geoffmcl[P]tidy-fork/src/clean.c |
MergeNestedElements | static Bool MergeNestedElements( TidyDocImpl* doc,
TidyTagId Id, TidyTriState state, Node *node,
Node **ARG_UNUSED(pnode))
{
Node *child;
if ( state == TidyNoState
|| !TagIsId(node, Id) )
return no;
child = node->content;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
testl %edx, %edx
sete %al
testq %rcx, %rcx
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x506f4
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x506f4
cmpl %esi, (%rax)
jne 0x506f4
movq 0x18(%r14), %r12
testq %r12, %r12
je 0x506f4
cmpq $0x0, 0x10(%r12)
je 0... | /geoffmcl[P]tidy-fork/src/clean.c |
CopyAttrs | static Bool CopyAttrs( TidyDocImpl* doc, Node *node, Node *child)
{
AttVal *av1, *av2;
TidyAttrId id;
/* Detect attributes that cannot be merged or overwritten. */
if (TY_(AttrGetById)(child, TidyAttr_ID) != NULL
&& TY_(AttrGetById)(node, TidyAttr_ID) != NULL)
return no;
/* Move ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
movl $0x40, %esi
callq 0x3b16a
testq %rax, %rax
je 0x50784
movq %r14, %rdi
movl $0x40, %esi
callq 0x3b16a
xorl %ebp, %ebp
testq %rax, %rax
jne 0x507fa
movq 0x28(%rbx), %r12
movl $... | /geoffmcl[P]tidy-fork/src/clean.c |
MergeStyles | static void MergeStyles(TidyDocImpl* doc, Node *node, Node *child)
{
AttVal *av;
tmbstr s1, s2, style;
/*
the child may have a class attribute used
for attaching styles, if so the class name
needs to be copied to node's class
*/
MergeClasses(doc, node, child);
for (s2 = NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdx), %rax
xorl %r12d, %r12d
testq %rax, %rax
je 0x50845
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x5083c
cmpl $0x1a, (%rcx)
je 0x50841
movq (%rax), %rax
jmp 0x50829
movq 0x30(%r... | /geoffmcl[P]tidy-fork/src/clean.c |
AddFontStyles | static void AddFontStyles( TidyDocImpl* doc, Node *node, AttVal *av)
{
while (av)
{
if (AttrHasValue(av))
{
if (attrIsFACE(av))
AddFontFace( doc, node, av->value );
else if (attrIsSIZE(av))
AddFontSize( doc, node, av->value );
e... | testq %rdx, %rdx
je 0x50bc7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r13
movq 0x30(%rbx), %r12
testq %r12, %r12
je 0x50b77
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x50b77
movl (%rax), %eax
cm... | /geoffmcl[P]tidy-fork/src/clean.c |
vReport | static void vReport(TidyDocImpl* doc, Node *element, Node *node, uint code, va_list args)
{
int i = 0;
va_list args_copy;
while ( dispatchTable[i].code != 0 )
{
if ( dispatchTable[i].code == code )
{
TidyMessageImpl *message;
messageFormatter *handler = dispatchT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x78bcd(%rip), %rax # 0xc98c0
cmpl $0x222, %ecx # imm = 0x222
je 0x50d0a
movl 0x18(%rax), %edx
testl %edx, %edx
je 0x50d5f
addq $0x18, %rax
cmpl %ecx, %edx
jne 0x50c... | /geoffmcl[P]tidy-fork/src/message.c |
formatDialogue | TidyMessageImpl *formatDialogue( TidyDocImpl* doc, uint code, TidyReportLevel level, va_list args )
{
switch (code)
{
case TEXT_SGML_CHARS:
case TEXT_VENDOR_CHARS:
{
ctmbstr str = va_arg(args, ctmbstr);
return TY_(tidyMessageCreate)( doc, code, level, str );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x21a, %esi # imm = 0x21A
jg 0x50e8f
cmpl $0x212, %ebp # imm = 0x212
je 0x50e72
cmpl $0x219, %ebp # imm = 0x219
jne 0x50ef4
movl (%rcx), %edx
cmpq $0x28, %r... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidyDialogue | void TY_(Dialogue)(TidyDocImpl* doc, uint code, ...)
{
int i = 0;
va_list args;
while ( dialogueDispatchTable[i].code != 0 )
{
if ( dialogueDispatchTable[i].code == code )
{
TidyMessageImpl *message;
TidyReportLevel level = dialogueDispatchTable[i].level;
... | subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x50f91
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0x... | /geoffmcl[P]tidy-fork/src/message.c |
messageOut | static void messageOut( TidyMessageImpl *message )
{
TidyDocImpl *doc;
Bool go = yes;
if ( !message )
return;
doc = message->tidyDoc;
/* The filter has had a chance to suppress *any* message from output. */
go = message->allowMessage;
/* Update the count of each report type. */
... | testq %rdi, %rdi
je 0x51042
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x20(%rdi), %edx
movl 0x1c(%rdi), %eax
leal -0x15e(%rax), %ecx
cmpl $0x5, %ecx
ja 0x51184
leaq 0x34b40(%rip), %rsi # 0x85b70
movslq (%rsi,%rcx,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
incl 0x3438(%r1... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidyErrorSummary | void TY_(ErrorSummary)( TidyDocImpl* doc )
{
ctmbstr encnam = tidyLocalizedString(STRING_SPECIFIED);
int charenc = cfg( doc, TidyCharEncoding );
if ( charenc == WIN1252 )
encnam = "Windows-1252";
else if ( charenc == MACROMAN )
encnam = "MacRoman";
else if ( charenc == IBM858 )
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1fe, %edi # imm = 0x1FE
callq 0x37dcf
movq %rax, %r14
movl 0xb0(%rbx), %eax
addl $-0x2, %eax
cmpl $0x6, %eax
ja 0x5120b
movl $0x71, %ecx
btl %eax, %ecx
jae 0x5120b
movl %eax, %eax
leaq 0x34e40(%rip), %rcx # 0x86044
movslq (%rcx,%rax,4), %r14
addq %... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidyReportMarkupVersion | void TY_(ReportMarkupVersion)( TidyDocImpl* doc )
{
if ( doc->givenDoctype )
TY_(Report)( doc, NULL, NULL, STRING_DOCTYPE_GIVEN, doc->givenDoctype );
if ( ! cfgBool(doc, TidyXmlTags) )
{
Bool isXhtml = doc->lexer->isvoyager;
uint apparentVers = TY_(ApparentVersion)( doc );
c... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3488(%rdi), %r8
testq %r8, %r8
je 0x51458
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x278, %ecx # imm = 0x278
xorl %eax, %eax
callq 0x50c58
cmpl $0x0, 0x3a8(%rbx)
je 0x51468
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x68(%rbx), %rax
movl... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidyReportNumWarnings | void TY_(ReportNumWarnings)( TidyDocImpl* doc )
{
if ( doc->warnings > 0 || doc->errors > 0 )
{
if ( doc->errors > cfg(doc, TidyShowErrors) || !cfgBool(doc, TidyShowWarnings) )
{
TY_(Dialogue)( doc, STRING_NOT_ALL_SHOWN );
}
else
{
TY_(Dialogue)( d... | movl 0x342c(%rdi), %eax
movl $0x21d, %esi # imm = 0x21D
movl 0x3430(%rdi), %ecx
orl %eax, %ecx
je 0x51504
movl %eax, %eax
movl $0x21e, %esi # imm = 0x21E
cmpq %rax, 0x2b8(%rdi)
jb 0x51504
xorl %eax, %eax
cmpl $0x0, 0x2e0(%rdi)
sete %al
leal (%rax,%rax,2), %esi
addl $0x21b, %esi # imm = ... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidyDefineMutedMessage | void TY_(DefineMutedMessage)(TidyDocImpl* doc, const TidyOptionImpl* opt, ctmbstr name)
{
enum { capacity = 10 };
TidyMutedMessages *list = &(doc->muted);
tidyStrings message = TY_(tidyErrorCodeFromKey)( name );
if ( message <= REPORT_MESSAGE_FIRST || message >= REPORT_MESSAGE_LAST)
{
TY_(R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x34c4a(%rip), %rdi # 0x8618d
movq %rdx, %rsi
callq 0x301b0
testl %eax, %eax
je 0x5157f
movl $0x1, %ebp
leaq 0x76a15(%rip), %r12 # 0xc7f70
movl %ebp, %r13d
shlq $0x4, %r13
movq (%r13... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidytidyErrorCodeFromKey | uint TY_(tidyErrorCodeFromKey)(ctmbstr code)
{
uint i = 0;
while (tidyStringsKeys[i].key) {
if ( strcmp(tidyStringsKeys[i].key, code) == 0 )
return tidyStringsKeys[i].value;
i++;
}
return UINT_MAX;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x34afb(%rip), %rdi # 0x8618d
movq %rbx, %rsi
callq 0x301b0
testl %eax, %eax
je 0x516cd
movl $0x1, %ebp
leaq 0x768c6(%rip), %r14 # 0xc7f70
movl %ebp, %r15d
shlq $0x4, %r15
movq (%r15,%r14), %rdi
testq %rdi, %rdi
je 0x516da
movq %rbx, %r... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidygetNextMutedMessage | ctmbstr TY_(getNextMutedMessage)( TidyDocImpl* doc, TidyIterator* iter )
{
TidyMutedMessages *list = &(doc->muted);
size_t index;
ctmbstr result = NULL;
assert( iter != NULL );
index = (size_t)*iter;
if ( index > 0 && index <= list->count )
{
result = TY_(tidyErrorCodeAsKey)(list->l... | testq %rsi, %rsi
je 0x51776
movq (%rsi), %rcx
movl 0x3390(%rdi), %edx
testq %rcx, %rcx
je 0x5172b
cmpq %rdx, %rcx
ja 0x5172d
movq 0x3388(%rdi), %rax
movl -0x4(%rax,%rcx,4), %edi
cmpl $0x12d, %edi # imm = 0x12D
jne 0x51731
leaq 0x34a64(%rip), %rax # 0x8618d
jmp 0x51766
xorl %ecx, %ecx
xorl %eax, %eax
jmp ... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidytidyErrorCodeAsKey | ctmbstr TY_(tidyErrorCodeAsKey)(uint code)
{
uint i = 0;
while (tidyStringsKeys[i].key) {
if ( tidyStringsKeys[i].value == code )
return tidyStringsKeys[i].key;
i++;
}
return "UNDEFINED";
} | cmpl $0x12d, %edi # imm = 0x12D
jne 0x517a6
leaq 0x349e8(%rip), %rax # 0x8618d
retq
movl $0x1, %ecx
leaq 0x767be(%rip), %rsi # 0xc7f70
leaq 0x34e1b(%rip), %rdx # 0x865d4
movl %ecx, %r8d
shlq $0x4, %r8
movq (%r8,%rsi), %rax
testq %rax, %rax
je 0x517d5
addq %rsi, %r8
incl %ecx
cmpl %edi, 0x8(%r8)
j... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidygetNextErrorCode | uint TY_(getNextErrorCode)( TidyIterator* iter )
{
const tidyStringsKeyItem *item = NULL;
size_t itemIndex;
assert( iter != NULL );
itemIndex = (size_t)*iter;
if ( itemIndex > 0 && itemIndex <= tidyErrorCodeListSize() )
{
item = &tidyStringsKeys[itemIndex - 1];
itemInde... | pushq %rax
testq %rdi, %rdi
je 0x51879
movq (%rdi), %rax
movl 0x949d2(%rip), %ecx # 0xe61c4
testq %rax, %rax
je 0x51823
testl %ecx, %ecx
jne 0x5181a
xorl %ecx, %ecx
leaq 0x7676c(%rip), %rdx # 0xc7f70
incl %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
cmpq $0x0, (%rsi,%rdx)
jne 0x51804
movl %ecx, 0x949aa(%rip) # 0xe6... | /geoffmcl[P]tidy-fork/src/message.c |
prvTidyOptGetDocDesc | const TidyOptionDoc* TY_(OptGetDocDesc)( TidyOptionId optId )
{
uint i = 0;
while( docs_xrefs[i].opt != N_TIDY_OPTIONS )
{
if ( docs_xrefs[i].opt == optId )
return &docs_xrefs[i];
++i;
}
return NULL;
} | cmpl $0x4, %edi
jne 0x518a5
leaq 0x77e7c(%rip), %rax # 0xc9720
retq
xorl %eax, %eax
leaq 0x77e72(%rip), %rcx # 0xc9720
xorl %esi, %esi
leaq 0x10(%rsi), %rdx
cmpq $0x190, %rdx # imm = 0x190
je 0x518cc
cmpl %edi, 0x10(%rsi,%rcx)
movq %rdx, %rsi
jne 0x518b0
addq %rdx, %rcx
movq %rcx, %rax
retq
| /geoffmcl[P]tidy-fork/src/message.c |
formatStandardDynamic | TidyMessageImpl *formatStandardDynamic(TidyDocImpl* doc, Node *element, Node *node, uint code, uint level, va_list args)
{
char nodedesc[ 256 ] = {0};
TagToString(node, nodedesc, sizeof(nodedesc));
switch (code)
{
case DISCARDING_UNEXPECTED:
/* Force error if in a bad form, or Issu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %r12
xorl %r15d, %r15d
movl $0x100, %edx # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x30160
movl $0x100, %edx # imm = 0x100
movq %rb... | /geoffmcl[P]tidy-fork/src/message.c |
formatEncodingReport | TidyMessageImpl *formatEncodingReport(TidyDocImpl* doc, Node *element, Node *node, uint code, uint level, va_list args)
{
char buf[ 32 ] = {'\0'};
uint c = va_arg( args, uint );
Bool discarded = va_arg( args, Bool );
ctmbstr action = tidyLocalizedString(discarded ? STRING_DISCARDING : STRING_REPLACING);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movl %ecx, %r15d
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl (%r9), %ecx
cmpq $0x29, %rcx
jae 0x52084
movq 0x10(%r9), %rdx
movq %rcx, %rax
addq $0x8, %rax
movl %eax, (%r9)
movl (%rdx,%rcx), ... | /geoffmcl[P]tidy-fork/src/message.c |
formatAccessReport | TidyMessageImpl *formatAccessReport(TidyDocImpl* doc, Node *element, Node *node, uint code, uint level, va_list args)
{
doc->badAccess |= BA_WAI;
/* Currently *all* cases are handled in the default, but maintain this
structure for possible future cases. */
switch (code)
{
default:
... | orb $-0x80, 0x3447(%rdi)
movq %rdx, %rsi
movl %ecx, %edx
movl %r8d, %ecx
xorl %eax, %eax
jmp 0x3aaf8
| /geoffmcl[P]tidy-fork/src/message.c |
TagToString | static char* TagToString(Node* tag, char* buf, size_t count)
{
*buf = 0;
if (tag)
{
if (TY_(nodeIsElement)(tag))
TY_(tmbsnprintf)(buf, count, "<%s>", tag->element);
else if (tag->type == EndTag)
TY_(tmbsnprintf)(buf, count, "</%s>", tag->element);
else if (tag... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movb $0x0, (%rsi)
testq %rdi, %rdi
je 0x5221a
movq %rdx, %r14
movq %rdi, %r15
callq 0x4445a
testl %eax, %eax
je 0x52227
movq 0x40(%r15), %rcx
leaq 0x5376(%rip), %rdx # 0x57583
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x37051
movq %rbx, %rdi
popq %rbx
po... | /geoffmcl[P]tidy-fork/src/message.c |
HTMLVersion | static ctmbstr HTMLVersion( TidyDocImpl* doc )
{
uint versionEmitted = doc->lexer->versionEmitted;
uint declared = doc->lexer->doctype;
uint version = versionEmitted == 0 ? declared : versionEmitted;
ctmbstr result = TY_(HTMLVersionNameFromCode)(version, 0);
if (!result)
result = tidyLocaliz... | pushq %rax
testl %esi, %esi
cmovnel %esi, %edi
xorl %esi, %esi
callq 0x463ce
testq %rax, %rax
je 0x522b3
popq %rcx
retq
movl $0x1fb, %edi # imm = 0x1FB
popq %rax
jmp 0x37dcf
| /geoffmcl[P]tidy-fork/src/message.c |
CheckObject | static void CheckObject( TidyDocImpl* doc, Node* node )
{
Bool HasAlt = no;
Bool HasDescription = no;
if (Level1_Enabled( doc ))
{
if ( node->content != NULL)
{
if ( node->content->type != TextNode )
{
Node* tnode = node->content;
... | pushq %r15
pushq %r14
pushq %rbx
movl 0x3240(%rdi), %eax
addl $-0x4, %eax
cmpl $-0x3, %eax
jae 0x54416
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x5446e
cmpl $0x4, 0x50(%rdi)
jne 0x54483
callq 0x443ec
movq 0x18(%rbx), %rsi
testl %eax, %eax
jne 0x5444d
m... | /geoffmcl[P]tidy-fork/src/access.c |
CheckFrame | static void CheckFrame( TidyDocImpl* doc, Node* node )
{
Bool HasTitle = no;
AttVal* av;
doc->access.numFrames++;
if (Level1_Enabled( doc ))
{
/* Checks for attributes within the FRAME element */
for (av = node->attributes; av != NULL; av = av->next)
{
/* Checks... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
incl 0x3348(%rdi)
movl 0x3240(%rdi), %eax
addl $-0x4, %eax
cmpl $-0x3, %eax
jb 0x5467e
movq %rdi, %rbx
movq %rsi, %r14
movq 0x28(%rsi), %r15
testq %r15, %r15
je 0x54639
xorl %r12d, %r12d
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x54621
movl (%rax), %eax
cmpl $0x96,... | /geoffmcl[P]tidy-fork/src/access.c |
CheckTable | static void CheckTable( TidyDocImpl* doc, Node* node )
{
Node* TNode;
Node* temp;
tmbstr word = NULL;
int numTR = 0;
Bool HasSummary = no;
Bool HasCaption = no;
if (Level3_Enabled( doc ))
{
AttVal* av;
/* Table must have a 'SUMMARY' describing the purpose of the table... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r13
movl 0x3240(%rdi), %eax
movb $0x1, %bpl
cmpl $0x3, %eax
jne 0x5485c
movq %r13, %r14
movq 0x28(%r15), %r13
testq %r13, %r13
je 0x54847
xorl %r12d, %r12d
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x54833
cmpl... | /geoffmcl[P]tidy-fork/src/access.c |
CheckASCII | static void CheckASCII( TidyDocImpl* doc, Node* node )
{
Node* temp1;
Node* temp2;
tmbstr skipOver = NULL;
Bool IsAscii = no;
int HasSkipOverLink = 0;
uint i, x;
int newLines = -1;
tmbchar compareLetter;
int matchingCount = 0;
AttVal* av;
if (Level1_Enabled( do... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x3240(%rdi), %eax
leal -0x4(%rax), %ecx
cmpl $-0x3, %ecx
jb 0x54d15
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x54d15
movl 0x48(%rcx), %r10d
movl 0x4c(%rcx), %ecx
leal 0x1(%r10), %esi
cmpl %ecx, %esi
jae 0... | /geoffmcl[P]tidy-fork/src/access.c |
CheckLabel | static void CheckLabel( TidyDocImpl* doc, Node* node )
{
if (Level2_Enabled( doc ))
{
/* Checks for valid 'FOR' attribute */
AttVal* av = attrGetFOR( node );
if ( hasValue(av) )
doc->access.HasValidFor = yes;
if ( ++doc->access.ForID == 2 )
{
... | pushq %r14
pushq %rbx
pushq %rax
movl 0x3240(%rdi), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x54e75
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x34, %esi
callq 0x3b16a
movq %rax, %rdi
callq 0x5340e
testl %eax, %eax
je 0x54e43
movl $0x1, 0x336c(%r14)
movl 0x3384(%r14), %eax
incl %eax
movl %eax, 0x3384(%r14)... | /geoffmcl[P]tidy-fork/src/access.c |
CheckInputLabel | static void CheckInputLabel( TidyDocImpl* doc, Node* node )
{
if (Level2_Enabled( doc ))
{
AttVal* av;
/* Checks attributes within the INPUT element */
for (av = node->attributes; av != NULL; av = av->next)
{
/* Must have valid 'ID' value */
if ( attrIsID... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x3240(%rdi), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x54f18
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %r15
testq %r15, %r15
je 0x54ee2
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x54edd
cmpl $0x40, (%rax)
jne 0x54edd
movq 0x30(%r15), %r12
testq %r12, ... | /geoffmcl[P]tidy-fork/src/access.c |
CheckInputAttributes | static void CheckInputAttributes( TidyDocImpl* doc, Node* node )
{
Bool HasAlt = no;
Bool MustHaveAlt = no;
AttVal* av;
/* Checks attributes within the INPUT element */
for (av = node->attributes; av != NULL; av = av->next)
{
/* 'VALUE' must be found if the 'TYPE' is 'text' or 'checkbox... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rsi), %r12
testq %r12, %r12
je 0x54ffc
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x54fe0
movl (%rax), %eax
cmpl $0x99, %eax
jne 0x54fb7
movq 0x30(%r12), %r15
testq %r1... | /geoffmcl[P]tidy-fork/src/access.c |
CheckFrameSet | static void CheckFrameSet( TidyDocImpl* doc, Node* node )
{
Node* temp;
Bool HasNoFrames = no;
if (Level1_Enabled( doc ))
{
if ( doc->badAccess & BA_INVALID_LINK_NOFRAMES )
{
TY_(ReportAccessError)( doc, node, NOFRAMES_INVALID_LINK);
doc->badAccess &= ~BA_INVALID_L... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x3240(%rdi), %eax
addl $-0x4, %eax
cmpl $-0x3, %eax
jb 0x55195
movq %rsi, %rbx
movq %rdi, %r14
testb $0x40, 0x3444(%rdi)
je 0x5506d
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2de, %edx # imm = 0x2DE
callq 0x50d6c
andb $-0x41, 0x3... | /geoffmcl[P]tidy-fork/src/access.c |
CheckBlink | static void CheckBlink( TidyDocImpl* doc, Node* node )
{
if (Level2_Enabled( doc ))
{
/* Checks to see if text is found within the BLINK element. */
if ( TY_(nodeIsText)(node->content) )
{
ctmbstr word = textFromOneNode( doc, node->content );
if ( !IsWhitespa... | pushq %r15
pushq %r14
pushq %rbx
movl 0x3240(%rdi), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x55220
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rdi
callq 0x443ec
testl %eax, %eax
je 0x55220
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x53445
movq %rax, %r15
movsbl (%r15), %edi
testl %edi, %edi
je 0x55220
callq ... | /geoffmcl[P]tidy-fork/src/access.c |
CheckMarquee | static void CheckMarquee( TidyDocImpl* doc, Node* node )
{
if (Level2_Enabled( doc ))
{
/* Checks to see if there is text in between the MARQUEE element */
if ( TY_(nodeIsText)(node) )
{
ctmbstr word = textFromOneNode( doc, node->content);
if ( !IsWhitespace(word)... | pushq %r15
pushq %r14
pushq %rbx
movl 0x3240(%rdi), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x55283
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x443ec
testl %eax, %eax
je 0x55283
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x53445
movq %rax, %r15
movsbl (%r15), %edi
testl %edi, %edi
je 0x55283
callq 0x44c3... | /geoffmcl[P]tidy-fork/src/access.c |
PopIStack | static void PopIStack( TidyDocImpl* doc )
{
Lexer* lexer = doc->lexer;
IStack *istack;
AttVal *av;
--(lexer->istacksize);
istack = &(lexer->istack[lexer->istacksize]);
while (istack->attributes)
{
av = istack->attributes;
istack->attributes = av->next;
TY_(FreeAttri... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movl 0x94(%rax), %ecx
decl %ecx
movl %ecx, 0x94(%rax)
movq 0x88(%rax), %rax
shlq $0x5, %rcx
leaq (%rax,%rcx), %r14
movq 0x18(%rax,%rcx), %rsi
testq %rsi, %rsi
je 0x56037
movq (%rsi), %rax
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x45dc0
movq 0x18... | /geoffmcl[P]tidy-fork/src/istack.c |
prvTidyIsPushedLast | Bool TY_(IsPushedLast)( TidyDocImpl* doc, Node *element, Node *node )
{
Lexer* lexer = doc->lexer;
if ( element && !IsNodePushable(element) )
return no;
if (lexer->istacksize > 0) {
if (lexer->istack[lexer->istacksize - 1].tag == node->tag) {
return yes;
}
}
re... | movq 0x68(%rdi), %rcx
testq %rsi, %rsi
je 0x56085
movq 0x38(%rsi), %rsi
xorl %eax, %eax
testq %rsi, %rsi
je 0x560a9
movl $0x810, %edi # imm = 0x810
andl 0x20(%rsi), %edi
cmpl $0x10, %edi
jne 0x560a9
movl (%rsi), %esi
cmpl $0x1b, %esi
je 0x560a9
cmpl $0x36, %esi
je 0x560a9
movl 0x94(%rcx), %eax
testl %eax, %e... | /geoffmcl[P]tidy-fork/src/istack.c |
prvTidyInlineDup | int TY_(InlineDup)( TidyDocImpl* doc, Node* node )
{
Lexer* lexer = doc->lexer;
int n;
if ((n = lexer->istacksize - lexer->istackbase) > 0)
{
lexer->insert = &(lexer->istack[lexer->istackbase]);
lexer->inode = node;
}
return n;
} | movq 0x68(%rdi), %rcx
movl 0x94(%rcx), %eax
movl 0x98(%rcx), %edx
subl %edx, %eax
testl %eax, %eax
jle 0x560dc
shlq $0x5, %rdx
addq 0x88(%rcx), %rdx
movq %rdx, 0x80(%rcx)
movq %rsi, 0x78(%rcx)
retq
| /geoffmcl[P]tidy-fork/src/istack.c |
prvTidyInsertedToken | Node *TY_(InsertedToken)( TidyDocImpl* doc )
{
Lexer* lexer = doc->lexer;
Node *node;
IStack *istack;
uint n;
/* this will only be NULL if inode != NULL */
if (lexer->insert == NULL)
{
node = lexer->inode;
lexer->inode = NULL;
return node;
}
/*
If this... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rbx
cmpq $0x0, 0x80(%rbx)
movq 0x78(%rbx), %r14
je 0x561bb
movq %rdi, %r15
testq %r14, %r14
jne 0x56127
movq 0x33d8(%r15), %rax
movq 0x128(%rax), %xmm0
pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movq %xmm0, (%rbx)
movq 0x3460(%r15), %rd... | /geoffmcl[P]tidy-fork/src/istack.c |
read_callback | static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *userp)
{
struct WriteThis *pooh = (struct WriteThis *)userp;
const char *data;
if(size*nmemb < 1)
return 0;
data = post[pooh->counter];
if(data) {
size_t len = strlen(data);
memcpy(ptr, data, len);
pooh->counter++; /* a... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
imulq %rdx, %rsi
testq %rsi, %rsi
je 0x13fb
movq %rcx, %rbx
movslq (%rcx), %rax
cmpq $0x4, %rax
jne 0x1400
xorl %r14d, %r14d
jmp 0x1429
movq %rdi, %r15
leaq 0x2966(%rip), %rcx # 0x3d70
movq (%rcx,%rax,8), %r12
movq %r12, %rdi
callq 0x1070
movq %rax, %r14
movq ... | /xyzz[P]vita-curl/tests/libtest/lib510.c |
cJSON_Delete | CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
{
cJSON *next = NULL;
while (item != NULL)
{
next = item->next;
if (!(item->type & cJSON_IsReference) && (item->child != NULL))
{
cJSON_Delete(item->child);
}
if (!(item->type & cJSON_IsReference) && (item->valu... | testq %rdi, %rdi
je 0x33a5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rbx, %r14
movq (%rbx), %rbx
movl 0x18(%r14), %eax
btl $0x8, %eax
jb 0x3362
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x3362
callq 0x3334
movl 0x18(%r14), %eax
btl $0x8, %eax
jb 0x337b
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x337b
callq... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_ParseWithOpts | CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
{
parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
cJSON *item = NULL;
/* reset error position */
global_error.json = NULL;
global_error.position = 0;
if (value == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
xorl %r15d, %r15d
movq %r15, 0x18(%rsp)
movq %r15, 0x8cda(%rip) # 0xc0d8
movq %r15, 0x8cdb(%rip) # 0xc0e0
testq %rdi, %rdi
je 0x3543
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rs... | /FSMaxB[P]cJSON/tests/../cJSON.c |
buffer_skip_whitespace | static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
if ((buffer == NULL) || (buffer->content == NULL))
{
return NULL;
}
while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
{
buffer->offset++;
}
if (buffer->offset == buffer->le... | testq %rdi, %rdi
je 0x398e
movq %rdi, %rax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x398e
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
cmpq %rcx, %rdx
jae 0x3991
cmpb $0x20, (%rsi,%rdx)
ja 0x3991
incq %rdx
movq %rdx, 0x10(%rax)
cmpq %rdx, %rcx
jne 0x397a
jmp 0x3996
xorl %eax, %eax
retq
cmpq %rcx, %rdx
jne 0x3990
decq %rcx
... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_PrintPreallocated | CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt)
{
printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
if ((len < 0) || (buf == NULL))
{
return false;
}
p.buffer = (unsigned char*)buf;
p.length = (size_t)len;
p.offset = 0;... | subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x18(%rsp)
testl %edx, %edx
sets %r8b
testq %rsi, %rsi
sete %r9b
xorl %eax, %eax
orb %r8b, %r9b
jne 0x3f88
movq %rsp, %rax
movq %rsi, (%rax)
movl %edx, %edx
movq %rdx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0x1, 0x20(%rax)
movl %ecx, 0x24(%rax)
movups... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_AddFalseToObject | CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)
{
cJSON *false_item = cJSON_CreateFalse();
if (add_item_to_object(object, name, false_item, &global_hooks, false))
{
return false_item;
}
cJSON_Delete(false_item);
return NULL;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x40, %edi
callq *0x7c8e(%rip) # 0xc0b8
movq %rax, %rbx
testq %rax, %rax
je 0x444b
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, (%rbx)
movl $0x1, 0x18(%rbx)
movq %r15, %rdi
mov... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_AddNumberToObject | CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)
{
cJSON *number_item = cJSON_CreateNumber(number);
if (add_item_to_object(object, name, number_item, &global_hooks, false))
{
return number_item;
}
cJSON_Delete(number_item);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movl $0x40, %edi
callq *0x7b57(%rip) # 0xc0b8
movq %rax, %rbx
testq %rax, %rax
je 0x45bb
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, (%rbx)
m... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_DetachItemFromObjectCaseSensitive | CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)
{
cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string);
return cJSON_DetachItemViaPointer(object, to_detach);
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %edx
callq 0x3ff1
testq %rbx, %rbx
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x4a10
xorl %eax, %eax
jmp 0x4a38
movq (%rax), %rcx
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x4a1f
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x4a28
movq %rdx, 0x8(%rcx)
cmpq %rax, 0x10(%rbx)
jne 0x4a... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_ReplaceItemViaPointer | CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
{
if ((parent == NULL) || (replacement == NULL) || (item == NULL))
{
return false;
}
if (replacement == item)
{
return true;
}
replacement->next = item->next;... | pushq %rbx
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x4b21
testq %rdi, %rdi
je 0x4b21
testq %rdx, %rdx
je 0x4b21
movl $0x1, %ebx
cmpq %rsi, %rdx
je 0x4b21
movq (%rsi), %rcx
movq %rcx, (%rdx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdx)
testq %rcx, %rcx
je 0x4b01
movq %rdx, 0x8(%rcx)
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x4... | /FSMaxB[P]cJSON/tests/../cJSON.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.