Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
CheckLength
void CheckLength( TidyDocImpl* doc, Node *node, AttVal *attval) { tmbstr p; if (!AttrHasValue(attval)) { TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE); return; } /* don't check for <col width=...> and <colgroup width=...> */ if (attrIsWIDTH(attval) && (nodeIs...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 testq %rdx, %rdx je 0x3ca4d movq 0x30(%rbx), %r12 testq %r12, %r12 je 0x3ca4d movq 0x8(%rbx), %rax testq %rax, %rax je 0x3c9f8 testq %r14, %r14 je 0x3c9f8 cmpl $0xa1, (%rax) jne 0x3c9f8 movq 0x38(%r14), %rax testq %ra...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckClear
void CheckClear( TidyDocImpl* doc, Node *node, AttVal *attval) { ctmbstr const values[] = {"none", "left", "right", "all", NULL}; if (!AttrHasValue(attval)) { TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE); if (attval->value == NULL) attval->value = TY_(tmbstrdup)(...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 testq %rdx, %rdx je 0x3cace cmpq $0x0, 0x30(%rbx) je 0x3cace movq %r14, %rdi movq %r15, %rsi movq %rbx, %rdx callq 0x3d378 leaq 0x8ac06(%rip), %rsi # 0xc76b0 movq %rbx, %rdi callq 0x3d400 testl %eax, %eax jne 0x3caff movq %r14, %rdi mo...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckId
void CheckId( TidyDocImpl* doc, Node *node, AttVal *attval ) { Lexer* lexer = doc->lexer; Node *old; if (!AttrHasValue(attval)) { TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE); return; } if (!TY_(IsValidHTMLID)(attval->value)) { if (lexer->isvoyager &...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 testq %rdx, %rdx je 0x3cc0b movq 0x30(%rbx), %r12 testq %r12, %r12 je 0x3cc0b movq 0x68(%r15), %r13 movsbl (%r12), %edi testl %edi, %edi je 0x3cbd7 incq %r12 callq 0x44c99 testl %eax, %eax je 0x3cb96 cmpl $0x0, 0x1c(%...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckIs
void CheckIs( TidyDocImpl* doc, Node *node, AttVal *attval ) { const char *ptr; Bool go = yes; /* `is` MUST NOT be in an autonomous custom tag */ ptr = strchr(node->element, '-'); if ( ( ptr && (ptr - node->element > 0) ) ) { TY_(ReportAttrError)( doc, node, attval, ATTRIBUTE_IS_NOT_ALL...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq 0x40(%rsi), %r12 movq %r12, %rdi movl $0x2d, %esi callq 0x30110 testq %rax, %rax sete %cl subq %r12, %rax testq %rax, %rax setle %al orb %cl, %al jne 0x3cc97 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx movl $...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckName
void CheckName( TidyDocImpl* doc, Node *node, AttVal *attval) { Node *old; if (!AttrHasValue(attval)) { TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE); return; } if ( TY_(IsAnchorElement)(doc, node) ) { if (cfgBool(doc, TidyXmlOut) && !IsValidNMTOKEN(attva...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdx, %r14 movq %rsi, %rbx movq %rdi, %r15 testq %rdx, %rdx je 0x3cdfa movq 0x30(%r14), %r12 testq %r12, %r12 je 0x3cdfa testq %rbx, %rbx je 0x3ce43 movq 0x38(%rbx), %rax testq %rax, %rax je 0x3ce43 movl (%rax), %eax decl %eax cmpl $0x3f, %eax...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckTarget
void CheckTarget( TidyDocImpl* doc, Node *node, AttVal *attval) { ctmbstr const values[] = {"_blank", "_self", "_parent", "_top", NULL}; if (!AttrHasValue(attval)) { TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE); return; } /* target names must begin with A-Za-z ... *...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 testq %rdx, %rdx je 0x3ceb6 movq 0x30(%rbx), %rax testq %rax, %rax je 0x3ceb6 movsbl (%rax), %edi callq 0x44c80 testl %eax, %eax jne 0x3ceb0 leaq 0x8a91c(%rip), %rsi # 0xc77c0 movq %rbx, %rdi callq 0x3d400 testl %eax, %eax je 0x3cece p...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckType
void CheckType( TidyDocImpl* doc, Node *node, AttVal *attval) { ctmbstr const valuesINPUT[] = { "text", "password", "checkbox", "radio", "submit", "reset", "file", "hidden", "image", "button", "color", "date", "datetime", "datetime-local", "email", "month", "number", "range", "search", ...
pushq %r15 pushq %r14 pushq %rbx testq %rsi, %rsi je 0x3cf88 movq %rsi, %r14 movq 0x38(%rsi), %rax testq %rax, %rax je 0x3cf88 movq %rdx, %rbx movq %rdi, %r15 movl (%rax), %eax cmpl $0x3c, %eax jle 0x3cf24 cmpl $0x3d, %eax je 0x3cf37 cmpl $0x4d, %eax je 0x3cf69 cmpl $0x76, %eax jne 0x3cf88 leaq 0x8a9b1(%rip), %rcx ...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckValign
void CheckValign( TidyDocImpl* doc, Node *node, AttVal *attval) { ctmbstr const values[] = {"top", "middle", "bottom", "baseline", NULL}; ctmbstr const values2[] = {"left", "right", NULL}; ctmbstr const valuesp[] = {"texttop", "absmiddle", "absbottom", "textbottom", NULL}; ...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 testq %rdx, %rdx je 0x3d011 cmpq $0x0, 0x30(%rbx) je 0x3d011 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x3d378 leaq 0x8a911(%rip), %rsi # 0xc7910 movq %rbx, %rdi callq 0x3d400 testl %eax, %eax je 0x3d029 popq %rbx popq %r14...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckRDFaPrefix
void CheckRDFaPrefix ( TidyDocImpl* doc, Node *node, AttVal *attval) { if (!AttrHasValue(attval)) { TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE); return; } /* Copy the attribute value so we can split it */ if (attval->value) { tmbstr t, tPtr ; uint p...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdx, %rbx movq %rsi, 0x8(%rsp) movq %rdi, %r15 testq %rdx, %rdx je 0x3d1c2 movq 0x30(%rbx), %rdi testq %rdi, %rdi je 0x3d1c2 callq 0x36c57 movq 0x3460(%r15), %rdi movq (%rdi), %rcx leal 0x1(%rax), %esi callq *(%rcx) movq %rax, %r14...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckSvgAttr
static void CheckSvgAttr( TidyDocImpl* doc, Node *node, AttVal *attval) { if (!nodeIsSVG(node)) { TY_(ReportAttrError)(doc, node, attval, ATTRIBUTE_IS_NOT_ALLOWED); return; } /* Issue #903 - check SVG paint attributes */ if (IsSvgPaintAttr(attval)) { /* all valid paint a...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 testq %rsi, %rsi je 0x3d28a movq 0x38(%r14), %rax testq %rax, %rax je 0x3d28a cmpl $0x6a, (%rax) jne 0x3d28a testq %rbx, %rbx je 0x3d2b7 movq 0x8(%rbx), %rax testq %rax, %rax je 0x3d2b7 movl (%rax), %eax leal -0x14a(%rax), %ecx cmpl $0xe, ...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckLowerCaseAttrValue
static void CheckLowerCaseAttrValue( TidyDocImpl* doc, Node *node, AttVal *attval) { tmbstr p; Bool hasUpper = no; if (!AttrHasValue(attval)) return; p = attval->value; while (*p) { if (TY_(IsUpper)(*p)) /* #501230 - fix by Terry Teague - 09 Jan 02 */ { ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq 0x30(%rdx), %r12 testq %r12, %r12 je 0x3d3f4 movb (%r12), %al testb %al, %al je 0x3d3f4 movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 incq %r12 movsbl %al, %edi callq 0x4595e testl %eax, %eax jne 0x3d3b6 movb (%r12), %al incq %r12 testb %al, %al jne 0x3d39d ...
/geoffmcl[P]tidy-fork/src/attrs.c
IsValidColorCode
static Bool IsValidColorCode(ctmbstr color) { uint i; if (TY_(tmbstrlen)(color) != 6) return no; /* check if valid hex digits and letters */ for (i = 0; i < 6; i++) if (!TY_(IsDigit)(color[i]) && !strchr("abcdef", TY_(ToLower)(color[i]))) return no; return yes; }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx callq 0x36c57 cmpl $0x6, %eax jne 0x3d49e xorl %r15d, %r15d leaq 0x45b01(%rip), %r14 # 0x82f63 movsbl (%rbx,%r15), %edi callq 0x44c69 testl %eax, %eax jne 0x3d48e movsbl (%rbx,%r15), %edi callq 0x45978 movl $0x7, %edx movq %r14, %rdi movl %eax, %esi callq 0x30190 tes...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckAttrValidity
static void CheckAttrValidity( TidyDocImpl* doc, Node *node, AttVal *attval, ctmbstr const list[]) { if (!AttrHasValue(attval)) { TY_(ReportAttrError)( doc, node, attval, MISSING_ATTR_VALUE); return; } CheckLowerCaseAttrValue( doc, node, attval ); if ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 testq %rdx, %rdx je 0x3d4ef cmpq $0x0, 0x30(%rbx) je 0x3d4ef movq %rcx, %r12 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x3d378 movq %rbx, %rdi movq %r12, %rsi callq 0x3d400 testl %eax, %eax je 0x3d50d addq...
/geoffmcl[P]tidy-fork/src/attrs.c
GetNodeByAnchor
static Node* GetNodeByAnchor( TidyDocImpl* doc, ctmbstr name ) { TidyAttribImpl* attribs = &doc->attribs; Anchor *found; uint h; tmbstr lname = TY_(tmbstrdup)(doc->allocator, name); if (TY_(HTMLVersion)(doc) == HT50) { h = anchorNameHash5(name); } else { h = anchorNameHas...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rsi, %r15 movq %rdi, %rbx leaq 0xcb0(%rdi), %r12 movq 0x3460(%rdi), %rdi callq 0x36c18 movq %rax, %r14 movq %rbx, %rdi callq 0x44b08 cmpl $0x20000, %eax # imm = 0x20000 jne 0x3d59d xorl %ebp, %ebp testq %r15, %r15 je 0x3d5b2 movb (%r15), %al testb %a...
/geoffmcl[P]tidy-fork/src/attrs.c
AddAnchor
static Anchor* AddAnchor( TidyDocImpl* doc, ctmbstr name, Node *node ) { TidyAttribImpl* attribs = &doc->attribs; Anchor *a = NewAnchor( doc, name, node ); uint h; if (TY_(HTMLVersion)(doc) == HT50) h = anchorNameHash5(name); else h = anchorNameHash(name); if ( attribs->anchor_h...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, %r12 movq %rsi, %r14 movq %rdi, %r15 movq 0x3460(%rdi), %rdi movq (%rdi), %rax movl $0x18, %esi callq *(%rax) movq %rax, %rbx movq 0x3460(%r15), %rdi movq %r14, %rsi callq 0x36c18 movq %rax, 0x10(%rbx) movq %r15, %rdi callq 0x4422f testl %eax, %eax jne 0...
/geoffmcl[P]tidy-fork/src/attrs.c
CheckDecimal
static void CheckDecimal( TidyDocImpl* doc, Node *node, AttVal *attval) { tmbstr p; Bool hasPoint = no; p = attval->value; /* Allow leading sign */ if (*p == '+' || *p == '-') ++p; while (*p) { /* Allow a single decimal point */ if (*p == '.') { ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq 0x30(%rdx), %r12 movzbl (%r12), %eax cmpl $0x2d, %eax je 0x3d71e cmpl $0x2b, %eax jne 0x3d721 incq %r12 movzbl (%r12), %eax testl %eax, %eax je 0x3d75c cmpl $0x2e, %eax je 0x3d75c movsbl %al, %edi callq 0x44c69 i...
/geoffmcl[P]tidy-fork/src/attrs.c
AlphaComparator
static int AlphaComparator(AttVal *one, AttVal *two, ctmbstr *list) { int oneIndex = indexof( one->attribute, list ); int twoIndex = indexof( two->attribute, list ); /* If both on the list, the lower index has priority. */ if ( oneIndex >= 0 && twoIndex >= 0 ) return oneIndex < twoIndex ? -1 : ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movq 0x28(%rdi), %rdi movq %rdx, %rsi callq 0x3d855 movl %eax, %ebp movq 0x28(%rbx), %rdi movq %r15, %rsi callq 0x3d855 movl %eax, %ecx movl %ebp, %eax orl %ecx, %eax js 0x3d7a5 xorl %eax, %eax cmpl %ecx, %ebp sbbl %e...
/geoffmcl[P]tidy-fork/src/attrs.c
PriorityComparator
static int PriorityComparator(AttVal *one, AttVal *two, ctmbstr *list) { int oneIndex = indexof( one->attribute, list ); int twoIndex = indexof( two->attribute, list ); /* If both on the list, the lower index has priority. */ if ( oneIndex >= 0 && twoIndex >= 0 ) return oneIndex < twoIndex ? -1...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r14 movq %rsi, %r15 movq 0x28(%rdi), %rdi movq %rdx, %rsi callq 0x3d855 movl %eax, %ebx movq 0x28(%r15), %rdi movq %r14, %rsi callq 0x3d855 movl %ebx, %ecx orl %eax, %ecx js 0x3d827 xorl %ecx, %ecx cmpl %eax, %ebx sbbl %ecx, %ecx orl $0x1, %ecx jmp 0x3d84d testl %ebx, %ebx s...
/geoffmcl[P]tidy-fork/src/attrs.c
indexof
static int indexof( ctmbstr item, ctmbstr *list ) { if ( list ) { uint i = 0; while ( list[i] != NULL ) { if ( TY_(tmbstrcasecmp)(item, list[i]) == 0 ) return i; i++; } } return -1; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movl $0xffffffff, %ebx # imm = 0xFFFFFFFF testq %rsi, %rsi je 0x3d895 movq %rsi, %r14 movq (%rsi), %rsi testq %rsi, %rsi je 0x3d895 movq %rdi, %r15 xorl %r12d, %r12d movq %r15, %rdi callq 0x36d6b testl %eax, %eax je 0x3d892 incl %r12d movq (%r14,%r12,8), %rsi...
/geoffmcl[P]tidy-fork/src/attrs.c
prvTidyCoerceNode
void TY_(CoerceNode)(TidyDocImpl* doc, Node *node, TidyTagId tid, Bool obsolete, Bool unexpected) { const Dict* tag = TY_(LookupTagDef)(tid); Node* tmp = TY_(InferredTag)(doc, tag->id); if (obsolete) TY_(Report)(doc, node, tmp, OBSOLETE_ELEMENT); else if (unexpected) TY_(Report)(doc, no...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r8d, %ebp movl %ecx, %r13d movq %rsi, %rbx movq %rdi, %r14 movl %edx, %edi callq 0x43e6d movq %rax, %r15 movl (%rax), %esi movq %r14, %rdi callq 0x462eb movq %rax, %r12 cmpl $0x1, %ebp movl $0x274, %eax # imm = 0x274 sbbl $0x0...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyRemoveNode
Node *TY_(RemoveNode)(Node *node) { if (node->prev) node->prev->next = node->next; if (node->next) node->next->prev = node->prev; if (node->parent) { if (node->parent->content == node) node->parent->content = node->next; if (node->parent->last == node) ...
movq %rdi, %rax movq 0x8(%rdi), %rdx movq 0x10(%rdi), %rcx testq %rdx, %rdx je 0x3da1b movq %rcx, 0x10(%rdx) testq %rcx, %rcx je 0x3da24 movq %rdx, 0x8(%rcx) movq (%rax), %rdx testq %rdx, %rdx je 0x3da44 cmpq %rax, 0x18(%rdx) jne 0x3da36 movq %rcx, 0x18(%rdx) cmpq %rax, 0x20(%rdx) jne 0x3da44 movq 0x8(%rax), %rcx movq ...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyDiscardElement
Node *TY_(DiscardElement)( TidyDocImpl* doc, Node *element ) { Node *next = NULL; if (element) { next = element->next; TY_(RemoveNode)(element); TY_(FreeNode)( doc, element); } return next; }
pushq %r15 pushq %r14 pushq %rbx testq %rsi, %rsi je 0x3da7c movq %rsi, %r14 movq %rdi, %r15 movq 0x10(%rsi), %rbx movq %rsi, %rdi callq 0x3da07 movq %r15, %rdi movq %r14, %rsi callq 0x45aab jmp 0x3da7e xorl %ebx, %ebx movq %rbx, %rax popq %rbx popq %r14 popq %r15 retq
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyInsertNodeAtStart
void TY_(InsertNodeAtStart)(Node *element, Node *node) { node->parent = element; if (element->content == NULL) element->last = node; else element->content->prev = node; node->next = element->content; node->prev = NULL; element->content = node; }
movq %rdi, (%rsi) movq 0x18(%rdi), %rax leaq 0x8(%rax), %rcx leaq 0x20(%rdi), %rdx testq %rax, %rax cmoveq %rdx, %rcx movq %rsi, (%rcx) movq %rax, 0x10(%rsi) movq $0x0, 0x8(%rsi) movq %rsi, 0x18(%rdi) retq
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyInsertNodeAtEnd
void TY_(InsertNodeAtEnd)(Node *element, Node *node) { node->parent = element; node->prev = element->last; if (element->last != NULL) element->last->next = node; else element->content = node; element->last = node; }
movq %rdi, (%rsi) movq 0x20(%rdi), %rax movq %rax, 0x8(%rsi) leaq 0x18(%rdi), %rcx leaq 0x10(%rax), %rdx testq %rax, %rax cmoveq %rcx, %rdx movq %rsi, (%rdx) movq %rsi, 0x20(%rdi) retq
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyInsertNodeAfterElement
void TY_(InsertNodeAfterElement)(Node *element, Node *node) { Node *parent; parent = element->parent; node->parent = parent; /* AQ - 13 Jan 2000 fix for parent == NULL */ if (parent != NULL && parent->last == element) parent->last = node; else { node->next = element->next; ...
movq (%rdi), %rax movq %rax, (%rsi) testq %rax, %rax je 0x3db13 cmpq %rdi, 0x20(%rax) je 0x3db26 movq 0x10(%rdi), %rax movq %rax, 0x10(%rsi) testq %rax, %rax je 0x3db2d addq $0x8, %rax jmp 0x3db2a addq $0x20, %rax movq %rsi, (%rax) movq %rsi, 0x10(%rdi) movq %rdi, 0x8(%rsi) retq
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyTrimEmptyElement
Node *TY_(TrimEmptyElement)( TidyDocImpl* doc, Node *element ) { if ( CanPrune(doc, element) ) { if (element->type != TextNode) { doc->footnotes |= FN_TRIM_EMPTY_ELEMENT; TY_(Report)(doc, element, NULL, TRIM_EMPTY_ELEMENT); } return TY_(DiscardEle...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx cmpl $0x0, 0xe8(%rdi) je 0x3db90 movq %rdi, %r14 movq %rbx, %rdi callq 0x443ec testl %eax, %eax je 0x3db89 cmpl $0x4, 0x50(%rbx) je 0x3db77 orb $0x1, 0x3454(%r14) movq %r14, %rdi movq %rbx, %rsi xorl %edx, %edx movl $0x281, %ecx # imm = 0x281 xorl %eax, %eax c...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyDropEmptyElements
Node* TY_(DropEmptyElements)(TidyDocImpl* doc, Node* node) { Node* next; while (node) { next = node->next; if (node->content) TY_(DropEmptyElements)(doc, node->content); if (!TY_(nodeIsElement)(node) && !(TY_(nodeIsText)(node) && !(node->start < node->end))...
testq %rsi, %rsi je 0x3dd4b pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx movq 0x10(%r14), %r15 movq 0x18(%r14), %rsi testq %rsi, %rsi je 0x3dd0a movq %rbx, %rdi callq 0x3dce5 movq %r14, %rdi callq 0x4445a testl %eax, %eax je 0x3dd2e movq %rbx, %rdi movq %r14, %rsi callq 0x3db36 movq %rax, %r15 movq ...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseBlock
void TY_(ParseBlock)( TidyDocImpl* doc, Node *element, GetTokenMode mode) { #if defined(ENABLE_DEBUG_LOG) static int in_parse_block = 0; static int parse_block_cnt = 0; #endif Lexer* lexer = doc->lexer; Node *node; Bool checkstack = yes; uint istackbase = 0; #if defined(ENABLE_DEBUG_LOG) in_...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq 0x38(%rsi), %rcx movl 0x20(%rcx), %eax testb $0x1, %al jne 0x3e748 movl %edx, %ebp movq %rsi, %rbx movq %rdi, %r14 movq 0x68(%rdi), %r13 cmpl $0x25, (%rcx) jne 0x3ddfe movq (%rbx), %rcx testq %rcx, %rcx je 0x3ddfe movq 0x38(%rcx), %...
/geoffmcl[P]tidy-fork/src/parser.c
TrimSpaces
static void TrimSpaces( TidyDocImpl* doc, Node *element) { Node* text = element->content; if (nodeIsPRE(element) || IsPreDescendant(element)) return; if (TY_(nodeIsText)(text)) TrimInitialSpace(doc, element, text); text = element->last; if (TY_(nodeIsText)(text)) TrimTrai...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq 0x18(%rsi), %r15 movq 0x38(%rsi), %rax testq %rax, %rax je 0x3e7a9 cmpl $0x54, (%rax) je 0x3e83d movq (%rbx), %rax testq %rax, %rax je 0x3e7cf leaq 0x25a5(%rip), %rcx # 0x40d5d movq 0x38(%rax), %rdx testq %rdx, %rdx je 0x3e7c7 cmpq %rcx, 0x28(%r...
/geoffmcl[P]tidy-fork/src/parser.c
InsertMisc
static Bool InsertMisc(Node *element, Node *node) { if (node->type == CommentTag || node->type == ProcInsTag || node->type == CDATATag || node->type == SectionTag || node->type == AspTag || node->type == JsteTag || node->type == PhpTag ) { TY_(InsertNodeAt...
pushq %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movl 0x50(%rsi), %eax cmpl $0xd, %eax ja 0x3e8b6 movl $0x1f0c, %ecx # imm = 0x1F0C btl %eax, %ecx jae 0x3e88f movq %r14, (%rbx) leaq 0x20(%r14), %rax movq 0x20(%r14), %rcx movq %rcx, 0x8(%rbx) addq $0x18, %r14 leaq 0x10(%rcx), %rdx testq %rcx, %...
/geoffmcl[P]tidy-fork/src/parser.c
MoveToHead
static void MoveToHead( TidyDocImpl* doc, Node *element, Node *node ) { Node *head; TY_(RemoveNode)( node ); /* make sure that node is isolated */ if ( TY_(nodeIsElement)(node) ) { TY_(Report)(doc, element, node, TAG_NOT_ALLOWED_IN ); head = TY_(FindHEAD)(doc); assert(head !=...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 movq %rdx, %rdi callq 0x3da07 movq %rbx, %rdi callq 0x4445a movq %r14, %rdi movq %r15, %rsi movq %rbx, %rdx testl %eax, %eax je 0x3e9a0 movl $0x27e, %ecx # imm = 0x27E xorl %eax, %eax callq 0x50c58 movq %r14, %rdi callq 0x46077 ...
/geoffmcl[P]tidy-fork/src/parser.c
AddClassNoIndent
static void AddClassNoIndent( TidyDocImpl* doc, Node *node ) { ctmbstr sprop = "padding-left: 2ex; margin-left: 0ex" "; margin-top: 0ex; margin-bottom: 0ex"; if ( !cfgBool(doc, TidyDecorateInferredUL) ) return; if ( cfgBool(doc, TidyMakeClean) ) TY_(AddStyleAsClass)( doc, nod...
cmpl $0x0, 0xd0(%rdi) je 0x3e9ff cmpl $0x0, 0x1f0(%rdi) je 0x3ea00 leaq 0x45167(%rip), %rdx # 0x83b61 jmp 0x4daa9 retq leaq 0x4515a(%rip), %rdx # 0x83b61 jmp 0x4dc5b
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseList
void TY_(ParseList)(TidyDocImpl* doc, Node *list, GetTokenMode ARG_UNUSED(mode)) { #if defined(ENABLE_DEBUG_LOG) static int in_parse_list = 0; #endif Lexer* lexer = doc->lexer; Node *node, *parent, *lastli; Bool wasblock; Bool nodeisOL = nodeIsOL(list); #if defined(ENABLE_DEBUG_LOG) in_parse_li...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %rbx movq %rdi, %r14 testq %rsi, %rsi je 0x3ea32 movq 0x38(%rbx), %rax cmpl $0x4d, (%rax) sete %bpl jmp 0x3ea3c movq 0x38, %rax xorl %ebp, %ebp testb $0x1, 0x20(%rax) jne 0x3edcb movq 0x68(%r14), %r13 movq $0x0, 0x80(%r13) mov...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseNamespace
void TY_(ParseNamespace)(TidyDocImpl* doc, Node *basenode, GetTokenMode mode) { Lexer* lexer = doc->lexer; Node *node; Node *parent = basenode; uint istackbase; AttVal* av; /* #130 MathML attr and entity fix! */ /* a la <table>: defer popping elements off the inline stack */ TY_(DeferDup)( ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, %rbx movq %rdi, %r14 movq 0x68(%rdi), %r15 callq 0x560dd movl 0x94(%r15), %eax movl 0x98(%r15), %ecx movl %ecx, 0xc(%rsp) movl %eax, 0x98(%r15) movq %r14, %rdi movl $0x4, %esi callq 0x46c09 testq %rax, %rax je 0x3f011 movq %ra...
/geoffmcl[P]tidy-fork/src/parser.c
InsertNodeAsParent
static void InsertNodeAsParent(Node *element, Node *node) { node->content = element; node->last = element; node->parent = element->parent; element->parent = node; if (node->parent->content == element) node->parent->content = node; if (node->parent->last == element) node->parent...
movq %rdi, 0x18(%rsi) movq %rdi, 0x20(%rsi) movq (%rdi), %rax movq %rax, (%rsi) movq %rsi, (%rdi) movq (%rsi), %rax cmpq %rdi, 0x18(%rax) jne 0x3fe1d movq %rsi, 0x18(%rax) cmpq %rdi, 0x20(%rax) jne 0x3fe27 movq %rsi, 0x20(%rax) movq 0x8(%rdi), %rax movq %rax, 0x8(%rsi) movq $0x0, 0x8(%rdi) movq 0x8(%rsi), %rax testq %r...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseEmpty
void TY_(ParseEmpty)(TidyDocImpl* doc, Node *element, GetTokenMode mode) { Lexer* lexer = doc->lexer; if ( lexer->isvoyager ) { Node *node = TY_(GetToken)( doc, mode); if ( node ) { if ( !(node->type == EndTag && node->tag == element->tag) ) { ...
pushq %r14 pushq %rbx pushq %rax movq 0x68(%rdi), %rax cmpl $0x0, 0x1c(%rax) je 0x3fea1 movq %rsi, %r14 movq %rdi, %rbx movl %edx, %esi callq 0x46c09 testq %rax, %rax je 0x3fea1 cmpl $0x6, 0x50(%rax) jne 0x3fe92 movq 0x38(%rax), %rcx cmpq 0x38(%r14), %rcx je 0x3fea9 movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r14 j...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseDefList
void TY_(ParseDefList)(TidyDocImpl* doc, Node *list, GetTokenMode mode) { Lexer* lexer = doc->lexer; Node *node, *parent; if (list->tag->model & CM_EMPTY) return; lexer->insert = NULL; /* defer implicit inline start tags */ while ((node = TY_(GetToken)( doc, IgnoreWhitespace)) != NULL) ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq 0x38(%rsi), %rax testb $0x1, 0x20(%rax) jne 0x401cc movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx movq 0x68(%rdi), %r12 movq $0x0, 0x80(%r12) xorl %esi, %esi callq 0x46c09 testq %rax, %rax je 0x4016c movq %rax, %r15 leaq 0x18(%r14), %r1...
/geoffmcl[P]tidy-fork/src/parser.c
MoveBeforeTable
static void MoveBeforeTable( TidyDocImpl* ARG_UNUSED(doc), Node *row, Node *node ) { Node *table; /* first find the table element */ for (table = row->parent; table; table = table->parent) { if ( nodeIsTABLE(table) ) { TY_(InsertNodeBeforeElement...
movq (%rdi), %rcx testq %rcx, %rcx je 0x405c8 movq %rcx, %rdx movq 0x38(%rdx), %rax testq %rax, %rax je 0x405c0 cmpl $0x6b, (%rax) je 0x405f2 movq (%rdx), %rdx testq %rdx, %rdx jne 0x405b2 movq (%rcx), %rax movq %rax, (%rsi) movq %rcx, 0x10(%rsi) movq 0x8(%rcx), %rdx movq %rdx, 0x8(%rsi) movq %rsi, 0x8(%rcx) movq 0x8(%...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseRowGroup
void TY_(ParseRowGroup)(TidyDocImpl* doc, Node *rowgroup, GetTokenMode ARG_UNUSED(mode)) { Lexer* lexer = doc->lexer; Node *node, *parent; if (rowgroup->tag->model & CM_EMPTY) return; while ((node = TY_(GetToken)(doc, IgnoreWhitespace)) != NULL) { if (node->tag == rowgroup->tag) ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq 0x38(%rsi), %rax testb $0x1, 0x20(%rax) jne 0x408c6 movq %rsi, %r14 movq %rdi, %rbx movq 0x68(%rdi), %r12 xorl %esi, %esi callq 0x46c09 testq %rax, %rax je 0x408c6 movq %rax, %r15 leaq 0x18(%r14), %r13 movl $0x49, %ebp movq 0x38(%r15), %r...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseColGroup
void TY_(ParseColGroup)(TidyDocImpl* doc, Node *colgroup, GetTokenMode ARG_UNUSED(mode)) { Node *node, *parent; if (colgroup->tag->model & CM_EMPTY) return; while ((node = TY_(GetToken)(doc, IgnoreWhitespace)) != NULL) { if (node->tag == colgroup->tag && node->type == EndTag) {...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq 0x38(%rsi), %rax testb $0x1, 0x20(%rax) jne 0x40a4c movq %rsi, %rbx movq %rdi, %r14 xorl %esi, %esi callq 0x46c09 testq %rax, %rax je 0x40a4c movq %rax, %r15 leaq 0x18(%rbx), %r12 movq 0x38(%r15), %rax movl 0x50(%r15), %ecx cmpq 0x38(%rbx), %rax je 0x40986 cmp...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParsePre
void TY_(ParsePre)( TidyDocImpl* doc, Node *pre, GetTokenMode ARG_UNUSED(mode) ) { Node *node; if (pre->tag->model & CM_EMPTY) return; TY_(InlineDup)( doc, NULL ); /* tell lexer to insert inlines if needed */ while ((node = TY_(GetToken)(doc, Preformatted)) != NULL) { if ( node->t...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq 0x38(%rsi), %rax testb $0x1, 0x20(%rax) jne 0x41092 movq %rsi, %r14 movq %rdi, %rbx xorl %esi, %esi callq 0x560b0 movq %rbx, %rdi movl $0x2, %esi callq 0x46c09 testq %rax, %rax je 0x4109e movq %rax, %r15 cmpl $0x6, 0x50(%r15) jne 0x40dda movq 0x38(%r15), %rax ...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseScript
void TY_(ParseScript)(TidyDocImpl* doc, Node *script, GetTokenMode ARG_UNUSED(mode)) { Node *node; doc->lexer->parent = script; node = TY_(GetToken)(doc, CdataContent); doc->lexer->parent = NULL; if (node) { TY_(InsertNodeAtEnd)(script, node); } else { /* handle...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movq 0x68(%rdi), %rax movq %rsi, 0x58(%rax) movl $0x5, %esi callq 0x46c09 movq 0x68(%rbx), %rcx movq $0x0, 0x58(%rcx) testq %rax, %rax je 0x41964 movq %r14, (%rax) movq 0x20(%r14), %rcx movq %rcx, 0x8(%rax) leaq 0x18(%r14), %rdx leaq 0x10(%rcx), %rsi test...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseHead
void TY_(ParseHead)(TidyDocImpl* doc, Node *head, GetTokenMode ARG_UNUSED(mode)) { Lexer* lexer = doc->lexer; Node *node; int HasTitle = 0; int HasBase = 0; DEBUG_LOG(SPRTF("Enter ParseHead...\n")); while ((node = TY_(GetToken)(doc, IgnoreWhitespace)) != NULL) { if (node->tag == hea...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r14 movq %rdi, %rbx movq 0x68(%rdi), %r13 xorl %esi, %esi callq 0x46c09 testq %rax, %rax je 0x41c48 movq %rax, %r15 leaq 0x18(%r14), %rax movq %rax, 0x10(%rsp) leaq 0x420b9(%rip), %r12 # 0x83af0 xorl %ebp, %ebp movq $0x0,...
/geoffmcl[P]tidy-fork/src/parser.c
InsertDocType
static void InsertDocType( TidyDocImpl* doc, Node *element, Node *doctype ) { Node* existing = TY_(FindDocType)( doc ); if ( existing ) { TY_(Report)(doc, element, doctype, DISCARDING_UNEXPECTED ); TY_(FreeNode)( doc, doctype ); } else { TY_(Report)(doc, element, doctype,...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 callq 0x45fed testq %rax, %rax je 0x41c9d movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx movl $0x235, %ecx # imm = 0x235 xorl %eax, %eax callq 0x50c58 movq %r15, %rdi movq %rbx, %rsi popq %rbx popq %r14 popq %r15 jmp 0x45aab mo...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyFindNodeWithId
Bool TY_(FindNodeWithId)( Node *node, TidyTagId tid ) { Node *content; while (node) { if (TagIsId(node,tid)) return yes; /*\ * Issue #459 - Under certain circumstances, with many node this use of * 'for (content = node->content; content; content = content->...
pushq %rbp pushq %r14 pushq %rbx xorl %ebx, %ebx testq %rdi, %rdi je 0x41d3e movl %esi, %ebp movq %rdi, %r14 movq 0x38(%r14), %rax testq %rax, %rax je 0x41d1a cmpl %ebp, (%rax) je 0x41d39 movq 0x18(%r14), %rdi testq %rdi, %rdi je 0x41d2e movl %ebp, %esi callq 0x41cfd testl %eax, %eax jne 0x41d39 movq 0x10(%r14), %r14 t...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseBody
void TY_(ParseBody)(TidyDocImpl* doc, Node *body, GetTokenMode mode) { Lexer* lexer = doc->lexer; Node *node; Bool checkstack, iswhitenode; mode = IgnoreWhitespace; checkstack = yes; TY_(BumpObject)( doc, body->parent ); DEBUG_LOG(SPRTF("Enter ParseBody...\n")); while ((node = TY_(Get...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r14 movq %rdi, %rbx movq 0x68(%rdi), %r13 movq (%rsi), %rsi callq 0x4f196 movq %rbx, %rdi xorl %esi, %esi callq 0x46c09 testq %rax, %rax je 0x422ff movq %rax, %r15 leaq 0x18(%r14), %rax movq %rax, 0x10(%rsp) movl $0x1, 0xc(%r...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseHTML
void TY_(ParseHTML)(TidyDocImpl* doc, Node *html, GetTokenMode mode) { Node *node, *head; Node *frameset = NULL; Node *noframes = NULL; DEBUG_LOG(SPRTF("Entering ParseHTML...\n")); TY_(SetOptionBool)( doc, TidyXmlTags, no ); for (;;) { node = TY_(GetToken)(doc, IgnoreWhitespace); ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx movl $0x67, %esi xorl %edx, %edx callq 0x338d5 movq %rbx, %rdi xorl %esi, %esi callq 0x46c09 testq %rax, %rax je 0x428fa movq %rax, %r15 movq 0x38(%r15), %rax testq %rax, %rax je 0x4289b cm...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyParseDocument
void TY_(ParseDocument)(TidyDocImpl* doc) { Node *node, *html, *doctype = NULL; while ((node = TY_(GetToken)(doc, IgnoreWhitespace)) != NULL) { if (node->type == XmlDecl) { doc->xmlDetected = yes; if (TY_(FindXmlDecl)(doc) && doc->root.content) { ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx xorl %esi, %esi callq 0x46c09 testq %rax, %rax je 0x42f8e movq %rax, %r14 leaq 0x18(%rbx), %r15 xorl %r12d, %r12d cmpl $0xd, 0x50(%r14) jne 0x42dcb movl $0x1, 0x345c(%rbx) movq %rbx, %rdi callq 0x4605a testq %rax, %rax je 0x42d...
/geoffmcl[P]tidy-fork/src/parser.c
ReplaceObsoleteElements
static void ReplaceObsoleteElements(TidyDocImpl* doc, Node* node) { Node *next; while (node) { next = node->next; /* if (nodeIsDIR(node) || nodeIsMENU(node)) */ /* HTML5 - <menu ... > is no longer obsolete */ if (nodeIsDIR(node)) TY_(CoerceNode)(doc, node, TidyT...
testq %rsi, %rsi je 0x432e5 pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movabsq $0x400000000100001, %r15 # imm = 0x400000000100001 movq 0x10(%r14), %r12 movq 0x38(%r14), %rax testq %rax, %rax je 0x432c1 movl (%rax), %eax cmpl $0x1d, %eax jne 0x43298 movq %rbx, %rdi movq %r14, ...
/geoffmcl[P]tidy-fork/src/parser.c
CleanSpaces
static void CleanSpaces(TidyDocImpl* doc, Node* node) { Node* next; while (node) { next = node->next; if (TY_(nodeIsText)(node) && CleanLeadingWhitespace(doc, node)) while (node->start < node->end && TY_(IsWhite)(doc->lexer->lexbuf[node->start])) ++(node->start)...
testq %rsi, %rsi je 0x435cc pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x1a2b(%rip), %r13 # 0x418dc leaq -0x25b1(%rip), %rbp # 0x40d5d movq %r14, %r15 movq 0x10(%r14), %r14 movq %r15, %rdi callq 0x443ec testl %eax, %eax je 0x43336 movq %r15...
/geoffmcl[P]tidy-fork/src/parser.c
EncloseBlockText
static void EncloseBlockText(TidyDocImpl* doc, Node* node) { Node *next; Node *block; while (node) { next = node->next; if (node->content) EncloseBlockText(doc, node->content); if (!(nodeIsFORM(node) || nodeIsNOSCRIPT(node) || nodeIsBLOCKQUOTE(node)) ...
testq %rsi, %rsi je 0x4372b pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r15 movq %rdi, %rbx movq %r15, %r13 movq 0x10(%r13), %r15 movq 0x18(%r13), %rsi testq %rsi, %rsi je 0x435ff movq %rbx, %rdi callq 0x435cd movq 0x38(%r13), %rax testq %rax, %rax je 0x43714 movl (%rax), %e...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyXMLPreserveWhiteSpace
Bool TY_(XMLPreserveWhiteSpace)( TidyDocImpl* doc, Node *element) { AttVal *attribute; /* search attributes for xml:space */ for (attribute = element->attributes; attribute; attribute = attribute->next) { if (attrIsXML_SPACE(attribute)) { if (AttrValueIs(attribute, "preserve...
pushq %rbx movq %rsi, %rbx movq 0x28(%rsi), %rax testq %rax, %rax je 0x4374f movq 0x8(%rax), %rcx testq %rcx, %rcx je 0x4374a cmpl $0xa4, (%rcx) je 0x437a7 movq (%rax), %rax jmp 0x43734 cmpq $0x0, 0x40(%rbx) je 0x437c0 movq 0x38(%rbx), %rax testq %rax, %rax je 0x43778 movl (%rax), %ecx addl $-0x54, %ecx cmpl $0x13, %ec...
/geoffmcl[P]tidy-fork/src/parser.c
ParseXMLElement
static void ParseXMLElement(TidyDocImpl* doc, Node *element, GetTokenMode mode) { Lexer* lexer = doc->lexer; Node *node; /* if node is pre or has xml:space="preserve" then do so */ if ( TY_(XMLPreserveWhiteSpace)(doc, element) ) mode = Preformatted; while ((node = TY_(GetToken)(doc, mode)...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %edx, %r15d movq %rsi, %r14 movq %rdi, %rbx movq 0x68(%rdi), %r12 callq 0x4372c testl %eax, %eax movl $0x2, %ebp cmovel %r15d, %ebp movq %rbx, %rdi movl %ebp, %esi callq 0x46c09 testq %rax, %rax je 0x439f7 movq %rax, %r15 leaq 0x18(%r14),...
/geoffmcl[P]tidy-fork/src/parser.c
FindDescendant_cb
static NodeTraversalSignal FindDescendant_cb(TidyDocImpl* ARG_UNUSED(doc), Node* node, void *propagate) { struct MatchingDescendantData *cb_data = (struct MatchingDescendantData *)propagate; if (TagId(node) == cb_data->matching_tagId) { /* make sure we match up 'unknown' tags exactly! */ if...
pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 xorl %eax, %eax testq %rsi, %rsi je 0x43abe movq 0x38(%r14), %rcx testq %rcx, %rcx je 0x43abe movl (%rcx), %eax cmpl 0x10(%rbx), %eax jne 0x43af5 testl %eax, %eax je 0x43ad1 movq %r14, (%rbx) movl $0x5, %eax jmp 0x43b0f movq 0x40(%r14), %rsi testq %rsi, %...
/geoffmcl[P]tidy-fork/src/parser.c
prvTidyDeclareUserTag
void TY_(DeclareUserTag)( TidyDocImpl* doc, const TidyOptionImpl* opt, ctmbstr name ) { UserTagType tagType; switch ( opt->id ) { case TidyInlineTags: tagType = tagtype_inline; break; case TidyBlockTags: tagType = tagtype_block; break; case TidyEmptyTag...
movl (%rsi), %ecx cmpl $0x14, %ecx jle 0x43b6a cmpl $0x15, %ecx je 0x43b9b movl $0x2, %eax cmpl $0x27, %ecx je 0x43ba7 cmpl $0x41, %ecx jne 0x43b92 movl $0x8, %eax jmp 0x43ba7 cmpl $0x5, %ecx je 0x43ba2 cmpl $0xb, %ecx jne 0x43b92 movq 0x320(%rdi), %rax leaq -0x1(%rax), %rcx cmpq $0x4, %rcx jae 0x43b92 leaq 0x40268(%ri...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyDefineTag
void TY_(DefineTag)( TidyDocImpl* doc, UserTagType tagType, ctmbstr name ) { Parser* parser = 0; uint cm = CM_UNKNOWN; uint vers = VERS_PROPRIETARY; switch (tagType) { case tagtype_empty: cm = CM_EMPTY|CM_NO_INDENT|CM_NEW; parser = TY_(ParseBlock); break; case tagty...
decl %esi cmpl $0x7, %esi ja 0x43c94 movl $0x8b, %eax btl %esi, %eax jae 0x43c94 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 testq %rdx, %rdx je 0x43c86 movq %rdi, %rbx movl %esi, %eax leaq 0x4021a(%rip), %rcx # 0x83e04 movl (%rcx,%rax,4), %ebp leaq 0x83eac(%rip), %r...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyFindTag
Bool TY_(FindTag)( TidyDocImpl* doc, Node *node ) { const Dict *np = NULL; if ( cfgBool(doc, TidyXmlTags) ) { node->tag = doc->tags.xml_tags; return yes; } if ( node->element && (np = tagsLookup(doc, &doc->tags, node->element)) ) { node->tag = np; return yes; ...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 cmpl $0x0, 0x3a8(%rdi) je 0x43cc0 movq 0x710(%r14), %rax movq %rax, 0x38(%rbx) movl $0x1, %eax addq $0x8, %rsp popq %rbx popq %r14 retq movq 0x40(%rbx), %rdx testq %rdx, %rdx je 0x43cdd leaq 0x710(%r14), %rsi movq %r14, %rdi callq 0x43d37 testq %rax, %rax...
/geoffmcl[P]tidy-fork/src/tags.c
tagsLookup
static const Dict* tagsLookup( TidyDocImpl* doc, TidyTagImpl* tags, ctmbstr s ) { const Dict *np; const DictHash* p; if (!s) return NULL; /* this breaks if declared elements get changed between two */ /* parser runs since Tidy would use the cached version rather */ /* than the new on...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx testq %rdx, %rdx je 0x43dff movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movb (%rdx), %dl xorl %eax, %eax testb %dl, %dl je 0x43d8c leaq 0x1(%r15), %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/tags.c
prvTidynodeIsAutonomousCustomTag
Bool TY_(nodeIsAutonomousCustomFormat)( Node* node ) { if ( node->element ) return TY_(elementIsAutonomousCustomFormat)( node->element ); return no; }
pushq %r15 pushq %r14 pushq %rbx movq 0x40(%rsi), %r15 xorl %ebx, %ebx testq %r15, %r15 je 0x43e65 movq %rdi, %r14 movq %r15, %rdi movl $0x2d, %esi callq 0x30110 testq %rax, %rax sete %cl subq %r15, %rax testq %rax, %rax setle %al orb %cl, %al jne 0x43e65 xorl %ebx, %ebx cmpq $0x0, 0x320(%r14) setne %bl movl %ebx, %eax...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyInitTags
void TY_(InitTags)( TidyDocImpl* doc ) { Dict* xml; TidyTagImpl* tags = &doc->tags; TidyClearMemory( tags, sizeof(TidyTagImpl) ); /* create dummy entry for all xml tags */ xml = NewDict( doc, NULL ); xml->versions = VERS_XML; xml->model = CM_BLOCK; xml->parser = 0; xml->chkattrs =...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx addq $0x710, %rdi # imm = 0x710 xorl %r14d, %r14d movl $0x5a0, %edx # imm = 0x5A0 xorl %esi, %esi callq 0x30160 movq 0x3460(%rbx), %rdi movq (%rdi), %rax movl $0x40, %esi callq *(%rax) movl $0x0, (%rax) movq %r14, 0x8(%rax) movq %r14, 0x38(%rax) mov...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyFreeDeclaredTags
void TY_(FreeDeclaredTags)( TidyDocImpl* doc, UserTagType tagType ) { TidyTagImpl* tags = &doc->tags; Dict *curr, *next = NULL, *prev = NULL; for ( curr=tags->declared_tag_list; curr; curr = next ) { Bool deleteIt = yes; next = curr->next; switch ( tagType ) { ca...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, 0x8(%rsp) movq 0x718(%rdi), %rbp testq %rbp, %rbp je 0x44138 movl %esi, %ebx movq 0x8(%rsp), %rax leaq 0x718(%rax), %rcx movq %rcx, 0x20(%rsp) addq $0x720, %rax # imm = 0x720 movq %rax, 0x10(%rsp) movq $0x0, (%rsp) ...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyAdjustTags
void TY_(AdjustTags)( TidyDocImpl *doc ) { Dict *np = (Dict *)TY_(LookupTagDef)( TidyTag_A ); TidyTagImpl* tags = &doc->tags; if (np) { np->parser = TY_(ParseInline); np->model = CM_INLINE; } /*\ * Issue #196 * TidyTag_CAPTION allows %flow; in HTML5, * but only %inline; in HTML...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x9f7fa(%rip), %rcx # 0xe3950 leaq 0xa1df3(%rip), %rax # 0xe5f50 cmpl $0x1, (%rcx) je 0x4416d addq $0x40, %rcx cmpq %rax, %rcx jb 0x4415d jmp 0x4417f leaq -0x50f0(%rip), %rdx # 0x3f084 movq %rdx, 0x28(%rcx) movl $0x10, 0x20(%rcx) leaq 0x9f7ca(%rip), %rcx...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyResetTags
void TY_(ResetTags)( TidyDocImpl *doc ) { Dict *np = (Dict *)TY_(LookupTagDef)( TidyTag_A ); TidyTagImpl* tags = &doc->tags; if (np) { np->parser = TY_(ParseBlock); np->model = (CM_INLINE|CM_BLOCK|CM_MIXED); } np = (Dict *)TY_(LookupTagDef)( TidyTag_CAPTION ); if (np) {...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x9f70b(%rip), %rcx # 0xe3950 leaq 0xa1d04(%rip), %rax # 0xe5f50 cmpl $0x1, (%rcx) je 0x4425c addq $0x40, %rcx cmpq %rax, %rcx jb 0x4424c jmp 0x4426e leaq -0x64c9(%rip), %rdx # 0x3dd9a movq %rdx, 0x28(%rcx) movl $0x20018, 0x20(%rcx) # imm = 0x20018 le...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidynodeHasText
Bool TY_(nodeHasText)( TidyDocImpl* doc, Node* node ) { if ( doc && node ) { uint ix; Lexer* lexer = doc->lexer; for ( ix = node->start; ix < node->end; ++ix ) { /* whitespace */ if ( !TY_(IsWhite)( lexer->lexbuf[ix] ) ) return yes; } } return no; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl xorl %ebx, %ebx orb %al, %cl jne 0x4444c movq %rsi, %r14 movl 0x48(%rsi), %r15d cmpl 0x4c(%rsi), %r15d jae 0x4444c movq 0x68(%rdi), %r12 movq 0x68(%r12), %rax movsbl (%rax,%r15), %edi callq 0x44c35 testl %eax, %ea...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyelementIsAutonomousCustomFormat
Bool TY_(elementIsAutonomousCustomFormat)( ctmbstr element ) { if ( element ) { const char *ptr = strchr(element, '-'); /* Tag must contain hyphen not in first character. */ if ( ptr && (ptr - element > 0) ) { return yes; } } return no; }
testq %rdi, %rdi je 0x444a4 pushq %rbx movq %rdi, %rbx movl $0x2d, %esi callq 0x30110 testq %rax, %rax setne %cl subq %rbx, %rax testq %rax, %rax setg %dl movl $0x1, %eax testb %dl, %cl popq %rbx jne 0x444a6 xorl %eax, %eax retq
/geoffmcl[P]tidy-fork/src/tags.c
prvTidynodeIsHeader
Bool TY_(nodeIsHeader)( Node* node ) { TidyTagId tid = TagId( node ); return ( tid && ( tid == TidyTag_H1 || tid == TidyTag_H2 || tid == TidyTag_H3 || tid == TidyTag_H4 || tid == TidyTag_H5 || tid == TidyTag_H6 )); }
xorl %eax, %eax testq %rdi, %rdi je 0x4455b movq 0x38(%rdi), %rcx testq %rcx, %rcx je 0x4455b movl (%rcx), %eax leal -0x28(%rax), %ecx cmpl $0x5, %ecx jae 0x4455c movl $0x1, %eax retq testl %eax, %eax je 0x4455b xorl %ecx, %ecx cmpl $0x2d, %eax sete %cl movl %ecx, %eax retq
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyTraverseNodeTree
NodeTraversalSignal TY_(TraverseNodeTree)(TidyDocImpl* doc, Node* node, NodeTraversalCallBack *cb, void *propagate ) { while (node) { NodeTraversalSignal s = (*cb)(doc, node, propagate); if (node->content && (s == ContinueTraversal || s == SkipSiblings)) { s = TY_(TraverseNo...
testq %rsi, %rsi je 0x44604 pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 movq %r12, %rdi movq %r15, %rsi movq %rbx, %rdx callq *%r14 movq 0x18(%r15), %rsi testq %rsi, %rsi setne %cl testl $0xfffffffd, %eax # imm = 0xFFFFFFFD sete %dl andb %...
/geoffmcl[P]tidy-fork/src/tags.c
prvTidyHTMLVersion
int TY_(HTMLVersion)(TidyDocImpl* doc) { uint i; uint j = 0; uint score = 0; uint vers = doc->lexer->versions; uint dtver = doc->lexer->doctype; TidyDoctypeModes dtmode = (TidyDoctypeModes)cfg(doc, TidyDoctypeMode); Bool xhtml = (cfgBool(doc, TidyXmlOut) || doc->lexer->isvoyager) && ...
movq 0x68(%rdi), %rsi movl 0x24(%rsi), %r8d movl 0xe0(%rdi), %eax cmpl $0x0, 0x390(%rdi) jne 0x44b29 cmpl $0x0, 0x1c(%rsi) je 0x44c1d cmpl $0x0, 0x178(%rdi) sete %cl leal -0x3(%rax), %edx cmpl $0x2, %edx setb %dil testl $0x1ffc, %r8d # imm = 0x1FFC setne %dl orb %dil, %dl je 0x44b50 xorl %edi, %edi jmp 0x44b5...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyIsXMLLetter
Bool TY_(IsXMLLetter)(uint c) { return ((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || (c >= 0xc0 && c <= 0xd6) || (c >= 0xd8 && c <= 0xf6) || (c >= 0xf8 && c <= 0xff) || (c >= 0x100 && c <= 0x131) || (c >= 0x134 && c <= 0x13e) || (c >= 0x141 && c <= ...
movl %edi, %eax andl $-0x21, %eax movd %edi, %xmm1 movd %eax, %xmm2 pshufd $0x0, %xmm1, %xmm0 # xmm0 = xmm1[0,0,0,0] punpckldq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1] pshufd $0x4, %xmm1, %xmm2 # xmm2 = xmm1[0,1,0,0] paddd 0x3f134(%rip), %xmm2 # 0x83e30 movdqa 0x3f13c(%rip), %xmm3 # 0x83...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyIsXMLNamechar
Bool TY_(IsXMLNamechar)(uint c) { return (TY_(IsXMLLetter)(c) || c == '.' || c == '_' || c == ':' || c == '-' || (c >= 0x300 && c <= 0x345) || (c >= 0x360 && c <= 0x361) || (c >= 0x483 && c <= 0x486) || (c >= 0x591 && c <= 0x5a1) || (c >= 0x5a3 && c <= 0x5b9) ...
pushq %rbx movl %edi, %ebx callq 0x44cd9 movl %eax, %ecx movl $0x1, %eax testl %ecx, %ecx jne 0x454bb leal -0x2d(%rbx), %ecx cmpl $0x32, %ecx ja 0x454bd movabsq $0x4000000002003, %rdx # imm = 0x4000000002003 btq %rcx, %rdx jae 0x454bd popq %rbx retq movd %ebx, %xmm0 pshufd $0x0, %xmm0, %xmm1 # xmm1 = xmm0[0,0,0,0...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyNewLexer
Lexer* TY_(NewLexer)( TidyDocImpl* doc ) { Lexer* lexer = (Lexer*) TidyDocAlloc( doc, sizeof(Lexer) ); if ( lexer != NULL ) { TidyClearMemory( lexer, sizeof(Lexer) ); lexer->allocator = doc->allocator; lexer->lines = 1; lexer->columns = 1; lexer->state = LEX_CONTENT...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x3460(%rdi), %rdi movq (%rdi), %rax movl $0xb0, %esi callq *(%rax) movq %rax, %r14 testq %rax, %rax je 0x45a06 movl $0xb0, %edx movq %r14, %rdi xorl %esi, %esi callq 0x30160 movq 0x3460(%rbx), %rax movq %rax, 0xa8(%r14) movabsq $0x100000001, %rax # imm = 0x100...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyFreeLexer
void TY_(FreeLexer)( TidyDocImpl* doc ) { Lexer *lexer = doc->lexer; if ( lexer ) { TY_(FreeStyles)( doc ); /* See GetToken() */ if ( lexer->pushed || lexer->itoken ) { if (lexer->pushed) TY_(FreeNode)( doc, lexer->itoken ); TY_(FreeNo...
pushq %r14 pushq %rbx pushq %rax movq 0x68(%rdi), %r14 testq %r14, %r14 je 0x45aa3 movq %rdi, %rbx callq 0x4da38 cmpl $0x0, 0xc(%r14) movq 0x48(%r14), %rsi je 0x45a3f movq %rbx, %rdi callq 0x45aab jmp 0x45a44 testq %rsi, %rsi je 0x45a5c movq 0x40(%r14), %rsi movq %rbx, %rdi callq 0x45aab jmp 0x45a5c movq %rbx, %rdi xor...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyAddCharToLexer
void TY_(AddCharToLexer)( Lexer *lexer, uint c ) { int i, err, count = 0; tmbchar buf[10] = {0}; err = TY_(EncodeCharToUTF8Bytes)( c, buf, NULL, &count ); if (err) { /* replacement character 0xFFFD encoded as UTF-8 */ buf[0] = (byte) 0xEF; buf[1] = (byte) 0xBF; b...
pushq %r14 pushq %rbx subq $0x18, %rsp movl %esi, %eax movq %rdi, %rbx leaq 0x4(%rsp), %rcx movl $0x0, (%rcx) leaq 0x8(%rsp), %rsi movw $0x0, 0x8(%rsi) movq $0x0, (%rsi) movl %eax, %edi xorl %edx, %edx callq 0x37402 testl %eax, %eax je 0x45b62 movw $0xbfef, 0x8(%rsp) # imm = 0xBFEF movb $-0x43, 0xa(%rsp) movl $0x3...
/geoffmcl[P]tidy-fork/src/lexer.c
AddByte
static void AddByte( Lexer *lexer, tmbchar ch ) { if ( lexer->lexsize + 2 >= lexer->lexlength ) { tmbstr buf = NULL; uint allocAmt = lexer->lexlength; uint prev = allocAmt; /* Is. #761 */ while ( lexer->lexsize + 2 >= allocAmt ) { if ( allocAmt == 0 ) ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx movl 0x70(%rdi), %r12d movl 0x74(%rdi), %eax leal 0x2(%rax), %ecx cmpl %r12d, %ecx jb 0x45c25 movl $0x2000, %r13d # imm = 0x2000 leaq 0x3eb88(%rip), %r14 # 0x84743 movl %r12d, %r15d testl %r15d, %r1...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyNewNode
Node *TY_(NewNode)(TidyAllocator* allocator, Lexer *lexer) { Node* node = (Node*) TidyAlloc( allocator, sizeof(Node) ); TidyClearMemory( node, sizeof(Node) ); if ( lexer ) { node->line = lexer->lines; node->column = lexer->columns; } node->type = TextNode; #if defined(ENABLE_DEBU...
pushq %rbx movq %rsi, %rbx movq (%rdi), %rax movl $0x68, %esi callq *(%rax) xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x30(%rax) movups %xmm0, 0x40(%rax) movups %xmm0, 0x50(%rax) movq $0x0, 0x60(%rax) testq %rbx, %rbx je 0x45c8c movq (%rbx), %rcx movq %rcx, ...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyCloneNode
Node *TY_(CloneNode)( TidyDocImpl* doc, Node *element ) { Lexer* lexer = doc->lexer; Node *node = TY_(NewNode)( lexer->allocator, lexer ); node->start = lexer->lexsize; node->end = lexer->lexsize; if ( element ) { node->parent = element->parent; node->type = element...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movq 0x68(%rdi), %r12 movq 0xa8(%r12), %rdi movq (%rdi), %rax movl $0x68, %esi callq *(%rax) movq %rax, %r15 xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x30(%rax) movups %x...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyDetachAttribute
void TY_(DetachAttribute)( Node *node, AttVal *attr ) { AttVal *av, *prev = NULL; for ( av = node->attributes; av; av = av->next ) { if ( av == attr ) { if ( prev ) prev->next = attr->next; else node->attributes = attr->next; ...
addq $0x28, %rdi xorl %edx, %edx movq %rdi, %rcx movq (%rcx), %rcx testq %rcx, %rcx je 0x45e44 movq %rdx, %rax movq %rcx, %rdx cmpq %rsi, %rcx jne 0x45e24 testq %rax, %rax movq (%rsi), %rcx cmovneq %rax, %rdi movq %rcx, (%rdi) retq
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyTextToken
Node* TY_(TextToken)( Lexer *lexer ) { Node *node = TY_(NewNode)( lexer->allocator, lexer ); node->start = lexer->txtstart; node->end = lexer->txtend; return node; }
pushq %rbx movq %rdi, %rbx movq 0xa8(%rdi), %rdi movq (%rdi), %rax movl $0x68, %esi callq *(%rax) xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x30(%rax) movups %xmm0, 0x40(%rax) movups %xmm0, 0x50(%rax) movq $0x0, 0x60(%rax) movq (%rbx), %rcx movq %rcx, 0x54(%...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyNewLiteralTextNode
Node* TY_(NewLiteralTextNode)( Lexer *lexer, ctmbstr txt ) { Node *node = TY_(NewNode)( lexer->allocator, lexer ); node->start = lexer->lexsize; AddStringToLexer( lexer, txt ); node->end = lexer->lexsize; return node; }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx movq 0xa8(%rdi), %rdi movq (%rdi), %rax movl $0x68, %esi callq *(%rax) movq %rax, %r15 xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x30(%rax) movups %xmm0, 0x40(%rax) movups %xmm0, 0x50(%rax) mov...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyAddStringLiteral
void TY_(AddStringLiteral)( Lexer* lexer, ctmbstr str ) { byte c; while(0 != (c = *str++) ) { /*\ * Issue #286 * Previously this used TY_(AddCharToLexer)( lexer, c ); * which uses err = TY_(EncodeCharToUTF8Bytes)( c, buf, NULL, &count ); * But this is transferring...
movb (%rsi), %al testb %al, %al je 0x45fec pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 incq %rbx movsbl %al, %esi movq %r14, %rdi callq 0x45b8f movb (%rbx), %al incq %rbx testb %al, %al jne 0x45fd1 addq $0x8, %rsp popq %rbx popq %r14 retq
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyFindContainer
Node* TY_(FindContainer)( Node* node ) { for ( node = (node ? node->parent : NULL); node && TY_(nodeHasCM)(node, CM_INLINE); node = node->parent ) /**/; return node; }
pushq %rbx testq %rdi, %rdi je 0x4602e movq (%rdi), %rbx testq %rbx, %rbx je 0x4602e movq %rbx, %rdi movl $0x10, %esi callq 0x444d8 testl %eax, %eax je 0x46030 movq (%rbx), %rbx jmp 0x46013 xorl %ebx, %ebx movq %rbx, %rax popq %rbx retq
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyFindXmlDecl
Node *TY_(FindXmlDecl)(TidyDocImpl* doc) { Node *node; for ( node = (doc ? doc->root.content : NULL); node && !(node->type == XmlDecl); node = node->next ) /**/; return node; }
testq %rdi, %rdi je 0x46074 movq 0x18(%rdi), %rax testq %rax, %rax je 0x46074 cmpl $0xd, 0x50(%rax) je 0x46076 movq 0x10(%rax), %rax jmp 0x46063 xorl %eax, %eax retq
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyFindTITLE
Node *TY_(FindTITLE)(TidyDocImpl* doc) { Node *node = TY_(FindHEAD)(doc); if (node) for (node = node->content; node && !nodeIsTITLE(node); node = node->next) {} return node; }
pushq %rax callq 0x46077 testq %rax, %rax je 0x460e7 movq 0x18(%rax), %rax testq %rax, %rax je 0x460e7 movq 0x38(%rax), %rcx testq %rcx, %rcx je 0x460e1 cmpl $0x72, (%rcx) je 0x460e9 movq 0x10(%rax), %rax jmp 0x460ce xorl %eax, %eax popq %rcx retq
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyFindBody
Node *TY_(FindBody)( TidyDocImpl* doc ) { Node *node = ( doc ? doc->root.content : NULL ); while ( node && !nodeIsHTML(node) ) node = node->next; if (node == NULL) return NULL; node = node->content; while ( node && !nodeIsBODY(node) && !nodeIsFRAMESET(node) ) node = node->...
testq %rdi, %rdi je 0x46187 movq 0x18(%rdi), %rcx testq %rcx, %rcx je 0x46187 xorl %eax, %eax movq 0x38(%rcx), %rdx testq %rdx, %rdx je 0x46111 cmpl $0x30, (%rdx) je 0x4611b movq 0x10(%rcx), %rcx testq %rcx, %rcx jne 0x46103 retq movq 0x18(%rcx), %rax testq %rax, %rax je 0x46187 movq 0x38(%rax), %rcx testq %rcx, %rcx j...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyInferredTag
Node* TY_(InferredTag)(TidyDocImpl* doc, TidyTagId id) { Lexer *lexer = doc->lexer; Node *node = TY_(NewNode)( lexer->allocator, lexer ); const Dict* dict = TY_(LookupTagDef)(id); assert( dict != NULL ); node->type = StartTag; node->implicit = yes; node->element = TY_(tmbstrdup)(doc->alloc...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %esi, %ebp movq %rdi, %r14 movq 0x68(%rdi), %r12 movq 0xa8(%r12), %rdi movq (%rdi), %rax movl $0x68, %esi callq *(%rax) movq %rax, %rbx xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x30(%rax) movups %x...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyApparentVersion
uint TY_(ApparentVersion)( TidyDocImpl* doc ) { if ((doc->lexer->doctype == XH11 || doc->lexer->doctype == XB10) && (doc->lexer->versions & doc->lexer->doctype)) return doc->lexer->doctype; else return TY_(HTMLVersion)(doc); }
movq 0x68(%rdi), %rcx movl 0x24(%rcx), %eax cmpl $0x1000, %eax # imm = 0x1000 je 0x463c4 cmpl $0x800, %eax # imm = 0x800 jne 0x44b08 testl %eax, 0x20(%rcx) je 0x44b08 retq
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyWarnMissingSIInEmittedDocType
Bool TY_(WarnMissingSIInEmittedDocType)( TidyDocImpl* doc ) { Bool isXhtml = doc->lexer->isvoyager; Node* doctype; /* Do not warn in XHTML mode */ if ( isXhtml ) return no; /* Do not warn if emitted doctype is proprietary */ if ( TY_(HTMLVersionNameFromCode)(doc->lexer->versionEmit...
pushq %rbx movq 0x68(%rdi), %rax xorl %ebx, %ebx cmpl $0x0, 0x1c(%rax) je 0x46438 movl %ebx, %eax popq %rbx retq movl 0x28(%rax), %eax cmpl $0x1, %eax je 0x46472 xorl %esi, %esi leaq 0x81697(%rip), %rdx # 0xc7ae0 movl $0x2f8, %r8d # imm = 0x2F8 leaq (%rdx,%r8), %rcx leaq 0x28(%rsi), %r9 cmpq %r8, %r9 je ...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidySetXHTMLDocType
Bool TY_(SetXHTMLDocType)( TidyDocImpl* doc ) { Lexer *lexer = doc->lexer; Node *doctype = TY_(FindDocType)( doc ); TidyDoctypeModes dtmode = (TidyDoctypeModes)cfg(doc, TidyDoctypeMode); ctmbstr pub = "PUBLIC"; ctmbstr sys = "SYSTEM"; lexer->versionEmitted = TY_(ApparentVersion)( doc ); if...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdi, %r14 movq 0x18(%rdi), %rbx movq 0x68(%rdi), %r12 testq %rbx, %rbx je 0x464fe cmpl $0x1, 0x50(%rbx) je 0x46500 movq 0x10(%rbx), %rbx jmp 0x464ed xorl %ebx, %ebx movl 0xe0(%r14), %ebp movq %r14, %rdi callq 0x463ab movl %eax, 0x28(%r12) cmpl $0x5, %ebp je 0...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyFixDocType
Bool TY_(FixDocType)( TidyDocImpl* doc ) { Lexer* lexer = doc->lexer; Node* doctype = TY_(FindDocType)( doc ); uint dtmode = cfg( doc, TidyDoctypeMode ); uint guessed = VERS_UNKNOWN; Bool hadSI = no; /* Issue #167 - found doctype, and doctype is default VERS_HTML5, set VERS_HTML5 and return yes...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x18(%rdi), %rax movq 0x68(%rdi), %r12 testq %rax, %rax je 0x468c4 movq %rax, %r14 cmpl $0x1, 0x50(%r14) je 0x46937 movq 0x10(%r14), %r14 testq %r14, %r14 jne 0x468b4 movl 0xe0(%rbx), %ebp cmpl $0x1, %ebp je 0x4697e cmpl $...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyFixXmlDecl
Bool TY_(FixXmlDecl)( TidyDocImpl* doc ) { Node* xml; AttVal *version, *encoding; Lexer*lexer = doc->lexer; Node* root = &doc->root; if ( root->content && root->content->type == XmlDecl ) { xml = root->content; } else { xml = TY_(NewNode)(lexer->allocator, lexer); ...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx movq 0x18(%rdi), %r14 movq 0x68(%rdi), %r15 testq %r14, %r14 je 0x46b26 cmpl $0xd, 0x50(%r14) je 0x46b82 movq 0xa8(%r15), %rdi movq (%rdi), %rax movl $0x68, %esi callq *(%rax) movq %rax, %r14 xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, ...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyGetToken
Node* TY_(GetToken)( TidyDocImpl* doc, GetTokenMode mode ) { Node *node; Lexer* lexer = doc->lexer; if (lexer->pushed || lexer->itoken) { /* Deal with previously returned duplicate inline token */ if (lexer->itoken) { /* itoken rejected */ if (lexer->push...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %r14 movq 0x68(%rdi), %rbx cmpl $0x0, 0xc(%rbx) movq 0x48(%rbx), %r12 je 0x46c39 testq %r12, %r12 je 0x46c46 movl $0x0, 0xc(%rbx) jmp 0x47e61 testq %r12, %r12 je 0x46c86 movq $0x0, 0x48(%rbx) movl $0x0, 0xc(%rbx) movq 0x40(%rb...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyNewAttributeEx
AttVal* TY_(NewAttributeEx)( TidyDocImpl* doc, ctmbstr name, ctmbstr value, int delim ) { AttVal *av = TY_(NewAttribute)(doc); av->attribute = TY_(tmbstrdup)(doc->allocator, name); av->value = TY_(tmbstrdup)(doc->allocator, value); av->delim = delim; av->dict = TY_(FindA...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movl %ecx, %ebx movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %r14 movq 0x3460(%rdi), %rdi movq (%rdi), %rax movl $0x38, %esi callq *(%rax) movq %rax, %r13 xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, 0x20(%rax) movq $0x0, 0x30(%rax) ...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyInsertAttributeAtEnd
static void AddAttrToList( AttVal** list, AttVal* av ) { if ( *list == NULL ) *list = av; else { AttVal* here = *list; while ( here->next ) here = here->next; here->next = av; } }
movq 0x28(%rdi), %rax testq %rax, %rax je 0x48dbe movq %rax, %rdi movq (%rax), %rax testq %rax, %rax jne 0x48db1 jmp 0x48dc2 addq $0x28, %rdi movq %rsi, (%rdi) retq
/geoffmcl[P]tidy-fork/src/lexer.c
ParseEntity
static void ParseEntity( TidyDocImpl* doc, GetTokenMode mode ) { typedef enum { ENT_default, ENT_numdec, ENT_numhex } ENTState; typedef Bool (*ENTfn)(uint); const ENTfn entFn[] = { TY_(IsNamechar), TY_(IsDigit), IsDigitHex }; uint start; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movl %esi, 0x10(%rsp) movl 0x270(%rdi), %eax movq %rax, 0x48(%rsp) movl 0x3a8(%rdi), %eax movl %eax, 0x20(%rsp) movl $0x0, 0x30(%rsp) movq 0x68(%rdi), %rax movq %rax, 0x18(%rsp) movl 0x74(%rax), %eax movq %rax, 0x60(%rsp) decl %eax movl ...
/geoffmcl[P]tidy-fork/src/lexer.c
ParseTagName
static tmbchar ParseTagName( TidyDocImpl* doc ) { Lexer *lexer = doc->lexer; uint c = lexer->lexbuf[ lexer->txtstart ]; Bool xml = cfgBool(doc, TidyXmlTags); /* fold case of first character in buffer */ if (!xml && TY_(IsUpper)(c)) lexer->lexbuf[lexer->txtstart] = (tmbchar) TY_(ToLower)(c);...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdi, %r14 movq 0x68(%rdi), %rbx movl 0x3a8(%rdi), %r15d testq %r15, %r15 jne 0x495ac movq 0x68(%rbx), %rax movl 0x30(%rbx), %ecx movb (%rax,%rcx), %dl testb %dl, %dl js 0x495ac movzbl %dl, %edx leaq 0x9ca23(%rip), %rsi # 0xe5fc0 movl (%rsi,%rdx,4), %esi t...
/geoffmcl[P]tidy-fork/src/lexer.c
TagToken
static Node* TagToken( TidyDocImpl* doc, NodeType type ) { Lexer* lexer = doc->lexer; Node* node = TY_(NewNode)( lexer->allocator, lexer ); node->type = type; node->element = TY_(tmbstrndup)( doc->allocator, lexer->lexbuf + lexer->txtstart, ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx movq 0x68(%rdi), %r15 movq 0xa8(%r15), %rdi movq (%rdi), %rax movl $0x68, %esi callq *(%rax) movq %rax, %r14 xorps %xmm0, %xmm0 movups %xmm0, (%rax) movups %xmm0, 0x10(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x30(%rax) movups %x...
/geoffmcl[P]tidy-fork/src/lexer.c
ParseValue
static tmbstr ParseValue( TidyDocImpl* doc, ctmbstr name, Bool foldCase, Bool *isempty, int *pdelim) { Lexer* lexer = doc->lexer; int len = 0, start; Bool seen_gt = no; Bool munge = yes; uint c, lastc, delim, quotewarning; tmbstr value; delim = (tmbchar) 0; *pd...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %r8, %r15 movq %rcx, %rbp movl %edx, 0x3c(%rsp) movq %rsi, %r13 movq %rdi, %r14 movq 0x68(%rdi), %rax movq %rax, 0x10(%rsp) movl $0x22, (%r8) movl 0x1d0(%rdi), %eax movq %rax, 0x30(%rsp) leaq 0x9bfea(%rip), %r12 # 0xe5fc0 movq 0...
/geoffmcl[P]tidy-fork/src/lexer.c
prvTidyPFlushLineSmart
void TY_(PFlushLineSmart)( 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 ); pprint->line++; } ...
pushq %r14 pushq %rbx pushq %rax movl %esi, %ebx movq %rdi, %r14 cmpl $0x0, 0x33ac(%rdi) je 0x4a96e movq %r14, %rdi callq 0x4a89d cmpl $0x2, 0x328(%r14) je 0x4a990 movq 0x33e0(%r14), %rsi movl $0xa, %edi callq 0x3668b incl 0x33b4(%r14) cmpl %ebx, 0x33bc(%r14) je 0x4a9a0 movl %ebx, 0x33bc(%r14) addq $0x8, %rsp popq %rbx...
/geoffmcl[P]tidy-fork/src/pprint.c
prvTidyPPrintTree
void TY_(PPrintTree)( TidyDocImpl* doc, uint mode, uint indent, Node *node ) { Node *content, *last; uint spaces = cfg( doc, TidyIndentSpaces ); Bool xhtml = cfgBool( doc, TidyXhtmlOut ); if ( node == NULL ) return; if (doc->progressCallback) { doc->progressCallback( tidyImplTo...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp testq %rcx, %rcx je 0x4b25c movq %rcx, %r15 movl %edx, %ebx movl %esi, %ebp movq %rdi, %r14 movl 0x1a0(%rdi), %r12d movl 0x380(%rdi), %r13d movq 0x3420(%rdi), %rax testq %rax, %rax je 0x4aaab movl 0x54(%r15), %esi movl 0x58(%r15), %edx m...
/geoffmcl[P]tidy-fork/src/pprint.c
PPrintComment
static void PPrintComment( TidyDocImpl* doc, uint indent, Node* node ) { TidyPrintImpl* pprint = &doc->pprint; SetWrap( doc, indent ); AddString( pprint, "<!--" ); PPrintText(doc, COMMENT, 0, node); AddString(pprint, "--"); AddChar( pprint, '>' ); if ( node->linebreak && node->next ) ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r15 movl %esi, %ebx movq %rdi, %r14 leaq 0x3398(%rdi), %r12 movl 0x33ac(%rdi), %eax leal (%rax,%rbx), %ecx cmpq %rcx, 0x358(%rdi) jbe 0x4b44b cmpl $0x0, 0x33bc(%r14) jns 0x4b442 movl %ebx, 0x33bc(%r14) movl %eax, 0x33b0(%r14) jmp 0x4b467 cmpl $0x0, 0x33...
/geoffmcl[P]tidy-fork/src/pprint.c