mirror of
https://github.com/rkd77/elinks.git
synced 2024-09-29 03:17:53 -04:00
25e0a18b7f
- ensure done_dom_stack() is called after parsing is done - get_dom_select_data(): Use stack->current->data since it is used within dom_stack_callback_T - dom_select_pop_element(): Use stack->contexts since it is the select_data stack and it owns the first context - add the select_data context to the right stack - fix some comments
894 lines
22 KiB
C
894 lines
22 KiB
C
/* DOM node selection */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "elinks.h"
|
|
|
|
#include "document/css/scanner.h"
|
|
#include "document/dom/dom.h"
|
|
#include "document/dom/node.h"
|
|
#include "document/dom/select.h"
|
|
#include "document/dom/stack.h"
|
|
#include "util/memory.h"
|
|
#include "util/scanner.h"
|
|
#include "util/string.h"
|
|
|
|
|
|
static enum dom_select_pseudo
|
|
get_dom_select_pseudo(struct scanner_token *token)
|
|
{
|
|
static struct {
|
|
struct dom_string string;
|
|
enum dom_select_pseudo pseudo;
|
|
} pseudo_info[] = {
|
|
|
|
#define INIT_DOM_SELECT_PSEUDO_STRING(str, type) \
|
|
{ INIT_DOM_STRING(str, -1), DOM_SELECT_PSEUDO_##type }
|
|
|
|
INIT_DOM_SELECT_PSEUDO_STRING("first-line", FIRST_LINE),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("first-letter", FIRST_LETTER),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("selection", SELECTION),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("after", AFTER),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("before", BEFORE),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("link", LINK),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("visited", VISITED),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("active", ACTIVE),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("hover", HOVER),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("focus", FOCUS),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("target", TARGET),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("enabled", ENABLED),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("disabled", DISABLED),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("checked", CHECKED),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("indeterminate", INDETERMINATE),
|
|
|
|
/* Content pseudo-classes: */
|
|
|
|
INIT_DOM_SELECT_PSEUDO_STRING("contains", CONTAINS),
|
|
|
|
/* Structural pseudo-classes: */
|
|
|
|
INIT_DOM_SELECT_PSEUDO_STRING("nth-child", NTH_CHILD),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("nth-last-child", NTH_LAST_CHILD),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("first-child", FIRST_CHILD),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("last-child", LAST_CHILD),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("only-child", ONLY_CHILD),
|
|
|
|
INIT_DOM_SELECT_PSEUDO_STRING("nth-of-type", NTH_TYPE),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("nth-last-of-type",NTH_LAST_TYPE),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("first-of-type", FIRST_TYPE),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("last-of-type", LAST_TYPE),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("only-of-type", ONLY_TYPE),
|
|
|
|
INIT_DOM_SELECT_PSEUDO_STRING("root", ROOT),
|
|
INIT_DOM_SELECT_PSEUDO_STRING("empty", EMPTY),
|
|
|
|
#undef INIT_DOM_SELECT_PSEUDO_STRING
|
|
|
|
};
|
|
struct dom_string string;
|
|
int i;
|
|
|
|
set_dom_string(&string, token->string, token->length);
|
|
|
|
for (i = 0; i < sizeof_array(pseudo_info); i++)
|
|
if (!dom_string_casecmp(&pseudo_info[i].string, &string))
|
|
return pseudo_info[i].pseudo;
|
|
|
|
return DOM_SELECT_PSEUDO_UNKNOWN;
|
|
}
|
|
|
|
|
|
static enum dom_exception_code
|
|
parse_dom_select_attribute(struct dom_select_node *sel, struct scanner *scanner)
|
|
{
|
|
struct scanner_token *token = get_scanner_token(scanner);
|
|
|
|
if (token->type != '[')
|
|
return DOM_ERR_INVALID_STATE;
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token || token->type != CSS_TOKEN_IDENT)
|
|
return DOM_ERR_SYNTAX;
|
|
|
|
set_dom_string(&sel->node.string, token->string, token->length);
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token) return DOM_ERR_SYNTAX;
|
|
|
|
switch (token->type) {
|
|
case ']':
|
|
sel->match.attribute |= DOM_SELECT_ATTRIBUTE_ANY;
|
|
return DOM_ERR_NONE;
|
|
|
|
case CSS_TOKEN_SELECT_SPACE_LIST:
|
|
sel->match.attribute |= DOM_SELECT_ATTRIBUTE_SPACE_LIST;
|
|
break;
|
|
|
|
case CSS_TOKEN_SELECT_HYPHEN_LIST:
|
|
sel->match.attribute |= DOM_SELECT_ATTRIBUTE_HYPHEN_LIST;
|
|
break;
|
|
|
|
case CSS_TOKEN_SELECT_BEGIN:
|
|
sel->match.attribute |= DOM_SELECT_ATTRIBUTE_BEGIN;
|
|
break;
|
|
|
|
case CSS_TOKEN_SELECT_END:
|
|
sel->match.attribute |= DOM_SELECT_ATTRIBUTE_END;
|
|
break;
|
|
|
|
case CSS_TOKEN_SELECT_CONTAINS:
|
|
sel->match.attribute |= DOM_SELECT_ATTRIBUTE_CONTAINS;
|
|
break;
|
|
|
|
default:
|
|
return DOM_ERR_SYNTAX;
|
|
}
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token) return DOM_ERR_SYNTAX;
|
|
|
|
switch (token->type) {
|
|
case CSS_TOKEN_IDENT:
|
|
case CSS_TOKEN_STRING:
|
|
set_dom_string(&sel->node.data.attribute.value, token->string, token->length);
|
|
break;
|
|
|
|
default:
|
|
return DOM_ERR_SYNTAX;
|
|
}
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (token && token->type == ']')
|
|
return DOM_ERR_NONE;
|
|
|
|
return DOM_ERR_SYNTAX;
|
|
}
|
|
|
|
/* Parse:
|
|
*
|
|
* 0n+1 / 1
|
|
* 2n+0 / 2n
|
|
* 2n+1
|
|
* -0n+2
|
|
* -0n+1 / -1
|
|
* 1n+0 / n+0 / n
|
|
* 0n+0
|
|
*/
|
|
|
|
static size_t
|
|
get_scanner_token_number(struct scanner_token *token)
|
|
{
|
|
size_t number = 0;
|
|
|
|
while (token->length > 0 && isdigit(token->string[0])) {
|
|
size_t old_number = number;
|
|
|
|
number *= 10;
|
|
|
|
/* -E2BIG */
|
|
if (old_number > number)
|
|
return -1;
|
|
|
|
number += token->string[0] - '0';
|
|
token->string++, token->length--;
|
|
}
|
|
|
|
return number;
|
|
}
|
|
|
|
static enum dom_exception_code
|
|
parse_dom_select_nth_arg(struct dom_select_nth_match *nth, struct scanner *scanner)
|
|
{
|
|
struct scanner_token *token = get_next_scanner_token(scanner);
|
|
int sign = 1;
|
|
int number = -1;
|
|
|
|
if (!token || token->type != '(')
|
|
return DOM_ERR_SYNTAX;
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token)
|
|
return DOM_ERR_SYNTAX;
|
|
|
|
switch (token->type) {
|
|
case CSS_TOKEN_IDENT:
|
|
if (scanner_token_contains(token, "even")) {
|
|
nth->step = 2;
|
|
nth->index = 0;
|
|
|
|
} else if (scanner_token_contains(token, "odd")) {
|
|
nth->step = 2;
|
|
nth->index = 1;
|
|
|
|
} else {
|
|
/* Check for 'n' ident below. */
|
|
break;
|
|
}
|
|
|
|
if (skip_css_tokens(scanner, ')'))
|
|
return DOM_ERR_NONE;
|
|
|
|
return DOM_ERR_SYNTAX;
|
|
|
|
case '-':
|
|
sign = -1;
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token) return DOM_ERR_SYNTAX;
|
|
|
|
if (token->type != CSS_TOKEN_IDENT)
|
|
break;
|
|
|
|
if (token->type != CSS_TOKEN_NUMBER)
|
|
return DOM_ERR_SYNTAX;
|
|
/* Fall-through */
|
|
|
|
case CSS_TOKEN_NUMBER:
|
|
number = get_scanner_token_number(token);
|
|
if (number < 0)
|
|
return DOM_ERR_INVALID_STATE;
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token) return DOM_ERR_SYNTAX;
|
|
break;
|
|
|
|
default:
|
|
return DOM_ERR_SYNTAX;
|
|
}
|
|
|
|
/* The rest can contain n+ part */
|
|
switch (token->type) {
|
|
case CSS_TOKEN_IDENT:
|
|
if (!scanner_token_contains(token, "n"))
|
|
return DOM_ERR_SYNTAX;
|
|
|
|
nth->step = sign * number;
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token) return DOM_ERR_SYNTAX;
|
|
|
|
if (token->type != '+')
|
|
break;
|
|
|
|
token = get_next_scanner_token(scanner);
|
|
if (!token) return DOM_ERR_SYNTAX;
|
|
|
|
if (token->type != CSS_TOKEN_NUMBER)
|
|
break;
|
|
|
|
number = get_scanner_token_number(token);
|
|
if (number < 0)
|
|
return DOM_ERR_INVALID_STATE;
|
|
|
|
nth->index = sign * number;
|
|
break;
|
|
|
|
default:
|
|
nth->step = 0;
|
|
nth->index = sign * number;
|
|
}
|
|
|
|
if (skip_css_tokens(scanner, ')'))
|
|
return DOM_ERR_NONE;
|
|
|
|
return DOM_ERR_SYNTAX;
|
|
}
|
|
|
|
static enum dom_exception_code
|
|
parse_dom_select_pseudo(struct dom_select *select, struct dom_select_node *sel,
|
|
struct scanner *scanner)
|
|
{
|
|
struct scanner_token *token = get_scanner_token(scanner);
|
|
enum dom_select_pseudo pseudo;
|
|
enum dom_exception_code code;
|
|
|
|
/* Skip double :'s in front of some pseudo's */
|
|
do {
|
|
token = get_next_scanner_token(scanner);
|
|
} while (token && token->type == ':');
|
|
|
|
if (!token || token->type != CSS_TOKEN_IDENT)
|
|
return DOM_ERR_SYNTAX;
|
|
|
|
pseudo = get_dom_select_pseudo(token);
|
|
switch (pseudo) {
|
|
case DOM_SELECT_PSEUDO_UNKNOWN:
|
|
return DOM_ERR_NOT_FOUND;
|
|
|
|
case DOM_SELECT_PSEUDO_CONTAINS:
|
|
/* FIXME: E:contains("text") */
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_NTH_CHILD:
|
|
case DOM_SELECT_PSEUDO_NTH_LAST_CHILD:
|
|
code = parse_dom_select_nth_arg(&sel->nth_child, scanner);
|
|
if (code != DOM_ERR_NONE)
|
|
return code;
|
|
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_CHILD;
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_FIRST_CHILD:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_CHILD;
|
|
set_dom_select_nth_match(&sel->nth_child, 0, 1);
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_LAST_CHILD:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_CHILD;
|
|
set_dom_select_nth_match(&sel->nth_child, 0, -1);
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_ONLY_CHILD:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_CHILD;
|
|
set_dom_select_nth_match(&sel->nth_child, 0, 0);
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_NTH_TYPE:
|
|
case DOM_SELECT_PSEUDO_NTH_LAST_TYPE:
|
|
code = parse_dom_select_nth_arg(&sel->nth_type, scanner);
|
|
if (code != DOM_ERR_NONE)
|
|
return code;
|
|
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_TYPE;
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_FIRST_TYPE:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_TYPE;
|
|
set_dom_select_nth_match(&sel->nth_type, 0, 1);
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_LAST_TYPE:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_TYPE;
|
|
set_dom_select_nth_match(&sel->nth_type, 0, -1);
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_ONLY_TYPE:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_NTH_TYPE;
|
|
set_dom_select_nth_match(&sel->nth_type, 0, 0);
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_ROOT:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_ROOT;
|
|
break;
|
|
|
|
case DOM_SELECT_PSEUDO_EMPTY:
|
|
sel->match.element |= DOM_SELECT_ELEMENT_EMPTY;
|
|
break;
|
|
|
|
default:
|
|
/* It's a bitflag! */
|
|
select->pseudo |= pseudo;
|
|
}
|
|
|
|
return DOM_ERR_NONE;
|
|
}
|
|
|
|
#define get_element_relation(sel) \
|
|
((sel)->match.element & DOM_SELECT_RELATION_FLAGS)
|
|
|
|
static enum dom_exception_code
|
|
parse_dom_select(struct dom_select *select, struct dom_stack *stack,
|
|
unsigned char *string, int length)
|
|
{
|
|
struct scanner scanner;
|
|
struct dom_select_node sel;
|
|
|
|
init_scanner(&scanner, &css_scanner_info, string, string + length);
|
|
|
|
memset(&sel, 0, sizeof(sel));
|
|
|
|
while (scanner_has_tokens(&scanner)) {
|
|
struct scanner_token *token = get_scanner_token(&scanner);
|
|
enum dom_exception_code code;
|
|
struct dom_select_node *select_node;
|
|
|
|
assert(token);
|
|
|
|
if (token->type == '{'
|
|
|| token->type == '}'
|
|
|| token->type == ';'
|
|
|| token->type == ',')
|
|
break;
|
|
|
|
/* Examine the selector fragment */
|
|
|
|
switch (token->type) {
|
|
case CSS_TOKEN_IDENT:
|
|
sel.node.type = DOM_NODE_ELEMENT;
|
|
set_dom_string(&sel.node.string, token->string, token->length);
|
|
if (token->length == 1 && token->string[0] == '*')
|
|
sel.match.element |= DOM_SELECT_ELEMENT_UNIVERSAL;
|
|
break;
|
|
|
|
case CSS_TOKEN_HASH:
|
|
case CSS_TOKEN_HEX_COLOR:
|
|
/* ID fragment */
|
|
sel.node.type = DOM_NODE_ATTRIBUTE;
|
|
sel.match.attribute |= DOM_SELECT_ATTRIBUTE_ID;
|
|
/* Skip the leading '#'. */
|
|
token->string++, token->length--;
|
|
break;
|
|
|
|
case '[':
|
|
sel.node.type = DOM_NODE_ATTRIBUTE;
|
|
code = parse_dom_select_attribute(&sel, &scanner);
|
|
if (code != DOM_ERR_NONE)
|
|
return code;
|
|
break;
|
|
|
|
case '.':
|
|
token = get_next_scanner_token(&scanner);
|
|
if (!token || token->type != CSS_TOKEN_IDENT)
|
|
return DOM_ERR_SYNTAX;
|
|
|
|
sel.node.type = DOM_NODE_ATTRIBUTE;
|
|
sel.match.attribute |= DOM_SELECT_ATTRIBUTE_SPACE_LIST;
|
|
set_dom_string(&sel.node.string, "class", -1);
|
|
set_dom_string(&sel.node.data.attribute.value, token->string, token->length);
|
|
break;
|
|
|
|
case ':':
|
|
code = parse_dom_select_pseudo(select, &sel, &scanner);
|
|
if (code != DOM_ERR_NONE)
|
|
return code;
|
|
break;
|
|
|
|
case '>':
|
|
if (get_element_relation(&sel))
|
|
return DOM_ERR_SYNTAX;
|
|
sel.match.element |= DOM_SELECT_RELATION_DIRECT_CHILD;
|
|
break;
|
|
|
|
case '+':
|
|
if (get_element_relation(&sel))
|
|
return DOM_ERR_SYNTAX;
|
|
sel.match.element |= DOM_SELECT_RELATION_DIRECT_ADJACENT;
|
|
break;
|
|
|
|
case '~':
|
|
if (get_element_relation(&sel))
|
|
return DOM_ERR_SYNTAX;
|
|
sel.match.element |= DOM_SELECT_RELATION_INDIRECT_ADJACENT;
|
|
break;
|
|
|
|
default:
|
|
return DOM_ERR_SYNTAX;
|
|
}
|
|
|
|
skip_scanner_token(&scanner);
|
|
|
|
if (sel.node.type == DOM_NODE_UNKNOWN)
|
|
continue;
|
|
|
|
WDBG("Adding %s: %.*s", (sel.node.type == DOM_NODE_ELEMENT) ? "element" : "attr", sel.node.string.length, sel.node.string.string);
|
|
/* FIXME */
|
|
select_node = mem_calloc(1, sizeof(*select_node));
|
|
copy_struct(select_node, &sel);
|
|
|
|
if (select_node->node.parent) {
|
|
struct dom_node *node = &select_node->node;
|
|
struct dom_node *parent = node->parent;
|
|
struct dom_node_list **list = get_dom_node_list(parent, node);
|
|
int sort = (node->type == DOM_NODE_ATTRIBUTE);
|
|
int index;
|
|
|
|
assertm(list, "Adding node to bad parent",
|
|
get_dom_node_type_name(node->type),
|
|
get_dom_node_type_name(parent->type));
|
|
|
|
index = *list && (*list)->size > 0 && sort
|
|
? get_dom_node_map_index(*list, node) : -1;
|
|
|
|
if (!add_to_dom_node_list(list, node, index)) {
|
|
done_dom_node(node);
|
|
return DOM_ERR_INVALID_STATE;
|
|
}
|
|
} else {
|
|
assert(!select->selector);
|
|
select->selector = select_node;
|
|
}
|
|
|
|
memset(&sel, 0, sizeof(sel));
|
|
sel.node.parent = &select_node->node;
|
|
}
|
|
|
|
if (select->selector)
|
|
return DOM_ERR_NONE;
|
|
|
|
return DOM_ERR_INVALID_STATE;
|
|
}
|
|
|
|
struct dom_select *
|
|
init_dom_select(enum dom_select_syntax syntax,
|
|
unsigned char *string, int length)
|
|
{
|
|
struct dom_select *select = mem_calloc(1, sizeof(select));
|
|
struct dom_stack stack;
|
|
enum dom_exception_code code;
|
|
|
|
init_dom_stack(&stack, DOM_STACK_KEEP_NODES);
|
|
|
|
code = parse_dom_select(select, &stack, string, length);
|
|
done_dom_stack(&stack);
|
|
|
|
if (code == DOM_ERR_NONE)
|
|
return select;
|
|
|
|
done_dom_select(select);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
done_dom_select(struct dom_select *select)
|
|
{
|
|
if (select->selector) {
|
|
struct dom_node *node = (struct dom_node *) select->selector;
|
|
|
|
done_dom_node(node);
|
|
}
|
|
|
|
mem_free(select);
|
|
}
|
|
|
|
|
|
struct dom_select_data {
|
|
struct dom_stack stack;
|
|
struct dom_select *select;
|
|
struct dom_node_list *list;
|
|
};
|
|
|
|
struct dom_select_state {
|
|
struct dom_node *node;
|
|
};
|
|
|
|
|
|
static int
|
|
compare_element_type(struct dom_node *node1, struct dom_node *node2)
|
|
{
|
|
/* Assuming the same document type */
|
|
if (node1->data.element.type
|
|
&& node2->data.element.type
|
|
&& node1->data.element.type == node2->data.element.type)
|
|
return 0;
|
|
|
|
return dom_string_casecmp(&node1->string, &node2->string);
|
|
}
|
|
|
|
static struct dom_select_node *
|
|
get_child_dom_select_node(struct dom_select_node *selector,
|
|
enum dom_node_type type)
|
|
{
|
|
struct dom_node_list *children = selector->node.data.element.children;
|
|
struct dom_node *node;
|
|
int index;
|
|
|
|
if (!children)
|
|
return NULL;
|
|
|
|
foreach_dom_node (children, node, index) {
|
|
if (node->type == type)
|
|
return (struct dom_select_node *) node;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
#define has_attribute_match(selector, name) \
|
|
((selector)->match.attribute & (name))
|
|
|
|
static int
|
|
match_attribute_selectors(struct dom_select_node *base, struct dom_node *node)
|
|
{
|
|
struct dom_node_list *attrs = node->data.element.map;
|
|
struct dom_node_list *selnodes = base->node.data.element.map;
|
|
struct dom_node *selnode;
|
|
size_t index;
|
|
|
|
assert(base->node.type == DOM_NODE_ELEMENT
|
|
&& node->type == DOM_NODE_ELEMENT);
|
|
|
|
if (!selnodes)
|
|
return 1;
|
|
|
|
if (!attrs)
|
|
return 0;
|
|
|
|
foreach_dom_node (selnodes, selnode, index) {
|
|
struct dom_select_node *selector = (void *) selnode;
|
|
struct dom_node *attr;
|
|
struct dom_string *value;
|
|
struct dom_string *selvalue;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_ID)) {
|
|
size_t idindex;
|
|
|
|
attr = NULL;
|
|
foreach_dom_node (attrs, attr, idindex) {
|
|
if (attr->data.attribute.id)
|
|
break;
|
|
}
|
|
|
|
if (!is_dom_node_list_member(attrs, idindex))
|
|
attr = NULL;
|
|
|
|
} else {
|
|
attr = get_dom_node_map_entry(attrs, DOM_NODE_ATTRIBUTE,
|
|
selnode->data.attribute.type,
|
|
&selnode->string);
|
|
}
|
|
|
|
if (!attr)
|
|
return 0;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_ANY))
|
|
continue;
|
|
|
|
value = &attr->data.attribute.value;
|
|
selvalue = &selnode->data.attribute.value;
|
|
|
|
if (value->length < selvalue->length)
|
|
return 0;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_EXACT)
|
|
&& dom_string_casecmp(value, selvalue))
|
|
return 0;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_BEGIN))
|
|
return 0;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_END))
|
|
return 0;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_SPACE_LIST))
|
|
return 0;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_HYPHEN_LIST))
|
|
return 0;
|
|
|
|
if (has_attribute_match(selector, DOM_SELECT_ATTRIBUTE_CONTAINS))
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
#define has_element_match(selector, name) \
|
|
((selector)->match.element & (name))
|
|
|
|
#define get_dom_select_data(stack) ((stack)->current->data)
|
|
|
|
static void
|
|
dom_select_push_element(struct dom_stack *stack, struct dom_node *node, void *data)
|
|
{
|
|
struct dom_select_data *select_data = get_dom_select_data(stack);
|
|
struct dom_stack_state *state;
|
|
int pos;
|
|
|
|
WDBG("Push element %.*s.", node->string.length, node->string.string);
|
|
|
|
foreach_dom_stack_state(&select_data->stack, state, pos) {
|
|
struct dom_select_node *selector = (void *) state->node;
|
|
|
|
/* Match the node. */
|
|
if (!has_element_match(selector, DOM_SELECT_ELEMENT_UNIVERSAL)
|
|
&& compare_element_type(&selector->node, node))
|
|
continue;
|
|
|
|
switch (get_element_relation(selector)) {
|
|
case DOM_SELECT_RELATION_DIRECT_CHILD: /* E > F */
|
|
/* node->parent */
|
|
/* Check all states to see if node->parent is there
|
|
* and for the right reasons. */
|
|
break;
|
|
|
|
case DOM_SELECT_RELATION_DIRECT_ADJACENT: /* E + F */
|
|
/* Get preceding node to see if it is on the stack. */
|
|
break;
|
|
|
|
case DOM_SELECT_RELATION_INDIRECT_ADJACENT: /* E ~ F */
|
|
/* Check all states with same depth? */
|
|
break;
|
|
|
|
case DOM_SELECT_RELATION_DESCENDANT: /* E F */
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Roots don't have parent nodes. */
|
|
if (has_element_match(selector, DOM_SELECT_ELEMENT_ROOT)
|
|
&& node->parent)
|
|
continue;
|
|
|
|
if (has_element_match(selector, DOM_SELECT_ELEMENT_EMPTY)
|
|
&& node->data.element.map->size > 0)
|
|
continue;
|
|
|
|
if (has_element_match(selector, DOM_SELECT_ELEMENT_NTH_CHILD)) {
|
|
/* FIXME */
|
|
continue;
|
|
}
|
|
|
|
if (has_element_match(selector, DOM_SELECT_ELEMENT_NTH_TYPE)) {
|
|
/* FIXME */
|
|
continue;
|
|
}
|
|
|
|
/* Check attribute selectors. */
|
|
if (selector->node.data.element.map
|
|
&& !match_attribute_selectors(selector, node))
|
|
continue;
|
|
|
|
WDBG("Matched element: %.*s.", node->string.length, node->string.string);
|
|
/* This node is matched, so push the next selector node to
|
|
* match on the stack. */
|
|
selector = get_child_dom_select_node(selector, DOM_NODE_ELEMENT);
|
|
if (selector)
|
|
push_dom_node(&select_data->stack, &selector->node);
|
|
}
|
|
}
|
|
|
|
static void
|
|
dom_select_pop_element(struct dom_stack *stack, struct dom_node *node, void *data)
|
|
{
|
|
struct dom_select_data *select_data = get_dom_select_data(stack);
|
|
struct dom_stack_state *state;
|
|
int index;
|
|
|
|
WDBG("Pop element: %.*s", node->string.length, node->string.string);
|
|
stack = &select_data->stack;
|
|
|
|
foreachback_dom_stack_state (stack, state, index) {
|
|
struct dom_select_node *selector = (void *) state->node;
|
|
struct dom_select_state *select_state;
|
|
|
|
/* XXX: Assume that it is the first stack context! */
|
|
select_state = get_dom_stack_state_data(stack->contexts, state);
|
|
if (select_state->node == node) {
|
|
pop_dom_state(stack, state);
|
|
WDBG("Remove element.");
|
|
continue;
|
|
}
|
|
|
|
/* FIXME: Pop states that no longer lives up to a relation. */
|
|
switch (get_element_relation(selector)) {
|
|
case DOM_SELECT_RELATION_DIRECT_CHILD: /* E > F */
|
|
case DOM_SELECT_RELATION_DIRECT_ADJACENT: /* E + F */
|
|
case DOM_SELECT_RELATION_INDIRECT_ADJACENT: /* E ~ F */
|
|
case DOM_SELECT_RELATION_DESCENDANT: /* E F */
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
dom_select_push_text(struct dom_stack *stack, struct dom_node *node, void *data)
|
|
{
|
|
struct dom_select_data *select_data = get_dom_select_data(stack);
|
|
struct dom_stack_state *state = get_dom_stack_top(&select_data->stack);
|
|
struct dom_select_node *selector = (void *) state->node;
|
|
struct dom_select_node *text_sel = get_child_dom_select_node(selector, DOM_NODE_TEXT);
|
|
struct dom_string *text;
|
|
|
|
WDBG("Text node: %d chars", node->string.length);
|
|
|
|
if (!text_sel)
|
|
return;
|
|
|
|
text = &text_sel->node.string;
|
|
|
|
switch (node->type) {
|
|
case DOM_NODE_TEXT:
|
|
case DOM_NODE_CDATA_SECTION:
|
|
case DOM_NODE_ENTITY_REFERENCE:
|
|
break;
|
|
default:
|
|
ERROR("Unhandled type");
|
|
}
|
|
}
|
|
|
|
static struct dom_stack_context_info dom_select_context_info = {
|
|
/* Object size: */ 0,
|
|
/* Push: */
|
|
{
|
|
/* */ NULL,
|
|
/* DOM_NODE_ELEMENT */ dom_select_push_element,
|
|
/* DOM_NODE_ATTRIBUTE */ NULL,
|
|
/* DOM_NODE_TEXT */ dom_select_push_text,
|
|
/* DOM_NODE_CDATA_SECTION */ dom_select_push_text,
|
|
/* DOM_NODE_ENTITY_REFERENCE */ dom_select_push_text,
|
|
/* DOM_NODE_ENTITY */ NULL,
|
|
/* DOM_NODE_PROC_INSTRUCTION */ NULL,
|
|
/* DOM_NODE_COMMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT_TYPE */ NULL,
|
|
/* DOM_NODE_DOCUMENT_FRAGMENT */ NULL,
|
|
/* DOM_NODE_NOTATION */ NULL,
|
|
},
|
|
/* Pop: */
|
|
{
|
|
/* */ NULL,
|
|
/* DOM_NODE_ELEMENT */ dom_select_pop_element,
|
|
/* DOM_NODE_ATTRIBUTE */ NULL,
|
|
/* DOM_NODE_TEXT */ NULL,
|
|
/* DOM_NODE_CDATA_SECTION */ NULL,
|
|
/* DOM_NODE_ENTITY_REFERENCE */ NULL,
|
|
/* DOM_NODE_ENTITY */ NULL,
|
|
/* DOM_NODE_PROC_INSTRUCTION */ NULL,
|
|
/* DOM_NODE_COMMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT_TYPE */ NULL,
|
|
/* DOM_NODE_DOCUMENT_FRAGMENT */ NULL,
|
|
/* DOM_NODE_NOTATION */ NULL,
|
|
}
|
|
};
|
|
|
|
static struct dom_stack_context_info dom_select_data_context_info = {
|
|
/* Object size: */ sizeof(struct dom_select_state),
|
|
/* Push: */
|
|
{
|
|
/* */ NULL,
|
|
/* DOM_NODE_ELEMENT */ NULL,
|
|
/* DOM_NODE_ATTRIBUTE */ NULL,
|
|
/* DOM_NODE_TEXT */ NULL,
|
|
/* DOM_NODE_CDATA_SECTION */ NULL,
|
|
/* DOM_NODE_ENTITY_REFERENCE */ NULL,
|
|
/* DOM_NODE_ENTITY */ NULL,
|
|
/* DOM_NODE_PROC_INSTRUCTION */ NULL,
|
|
/* DOM_NODE_COMMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT_TYPE */ NULL,
|
|
/* DOM_NODE_DOCUMENT_FRAGMENT */ NULL,
|
|
/* DOM_NODE_NOTATION */ NULL,
|
|
},
|
|
/* Pop: */
|
|
{
|
|
/* */ NULL,
|
|
/* DOM_NODE_ELEMENT */ NULL,
|
|
/* DOM_NODE_ATTRIBUTE */ NULL,
|
|
/* DOM_NODE_TEXT */ NULL,
|
|
/* DOM_NODE_CDATA_SECTION */ NULL,
|
|
/* DOM_NODE_ENTITY_REFERENCE */ NULL,
|
|
/* DOM_NODE_ENTITY */ NULL,
|
|
/* DOM_NODE_PROC_INSTRUCTION */ NULL,
|
|
/* DOM_NODE_COMMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT */ NULL,
|
|
/* DOM_NODE_DOCUMENT_TYPE */ NULL,
|
|
/* DOM_NODE_DOCUMENT_FRAGMENT */ NULL,
|
|
/* DOM_NODE_NOTATION */ NULL,
|
|
}
|
|
};
|
|
|
|
struct dom_node_list *
|
|
select_dom_nodes(struct dom_select *select, struct dom_node *root)
|
|
{
|
|
struct dom_select_data select_data;
|
|
struct dom_stack stack;
|
|
|
|
memset(&select_data, 0, sizeof(select_data));
|
|
|
|
select_data.select = select;;
|
|
|
|
init_dom_stack(&stack, DOM_STACK_KEEP_NODES);
|
|
add_dom_stack_context(&stack, &select_data,
|
|
&dom_select_context_info);
|
|
|
|
init_dom_stack(&select_data.stack, DOM_STACK_KEEP_NODES);
|
|
add_dom_stack_context(&select_data.stack, &select_data,
|
|
&dom_select_data_context_info);
|
|
|
|
if (push_dom_node(&select_data.stack, &select->selector->node)) {
|
|
get_dom_stack_top(&select_data.stack)->immutable = 1;
|
|
walk_dom_nodes(&stack, root);
|
|
}
|
|
|
|
done_dom_stack(&select_data.stack);
|
|
done_dom_stack(&stack);
|
|
|
|
return select_data.list;
|
|
}
|