src/select/select.c

Bug Summary

File:	select/select.c
Warning:	line 2100, column 12 Called function pointer is an uninitialized pointer value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name select.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/scan-build-libcss -fcoverage-compilation-dir=/var/lib/jenkins/workspace/scan-build-libcss -resource-dir /usr/lib/llvm-19/lib/clang/19 -D _BSD_SOURCE -D _DEFAULT_SOURCE -I /var/lib/jenkins/workspace/scan-build-libcss/include/ -I /var/lib/jenkins/workspace/scan-build-libcss/src -D _ALIGNED=__attribute__((aligned)) -D STMTEXPR=1 -D DEBUG -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Og -Wwrite-strings -Wno-error -std=c99 -fconst-strings -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-display-progress -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /var/lib/jenkins/workspace/scan-build-libcss/clangScanBuildReports/2025-11-29-162650-2786852-1 -x c src/select/select.c
1/*
* This file is part of LibCSS
* Licensed under the MIT License,
*                http://www.opensource.org/licenses/mit-license.php
* Copyright 2009 John-Mark Bell <jmb@netsurf-browser.org>
*/

8#include <assert.h>
9#include <string.h>

11#include <libwapcaplet/libwapcaplet.h>

13#include <libcss/select.h>

15#include "bytecode/bytecode.h"
16#include "bytecode/opcodes.h"
17#include "stylesheet.h"
18#include "select/arena.h"
19#include "select/calc.h"
20#include "select/computed.h"
21#include "select/dispatch.h"
22#include "select/hash.h"
23#include "select/mq.h"
24#include "select/propset.h"
25#include "select/font_face.h"
26#include "select/select.h"
27#include "select/strings.h"
28#include "select/unit.h"
29#include "utils/parserutilserror.h"
30#include "utils/utils.h"

32/* Define this to enable verbose messages when matching selector chains */
33#undef DEBUG_CHAIN_MATCHING

35/* Define this to enable verbose messages when attempting to share styles */
36#undef DEBUG_STYLE_SHARING

38/**
* Container for stylesheet selection info
*/
41typedef struct css_select_sheet {
const css_stylesheet *sheet;	/**< Stylesheet */
css_origin origin;		/**< Stylesheet origin */
css_mq_query *media;		/**< Applicable media */
45} css_select_sheet;

47/**
* CSS selection context
*/
50struct css_select_ctx {
uint32_t n_sheets;		/**< Number of sheets */

css_select_sheet *sheets;	/**< Array of sheets */

void *pw;	/**< Client's private selection context */

bool_Bool uses_revert;  /**< A sheet used revert property value */

css_select_strings str;

css_calculator *calc; /**< A calculator to hand off to computed styles */

/* Interned default style */
css_computed_style *default_style;
65};

67/**
* Container for selected font faces
*/
70typedef struct css_select_font_faces_list {
const css_font_face **font_faces;
size_t count;
73} css_select_font_faces_list;

75/**
* Font face selection state
*/
78typedef struct css_select_font_faces_state {
lwc_string *font_family;
const css_media *media;
const css_unit_ctx *unit_ctx;

css_select_font_faces_list ua_font_faces;
css_select_font_faces_list user_font_faces;
css_select_font_faces_list author_font_faces;
86} css_select_font_faces_state;

88/**
* CSS rule source
*/
91typedef struct css_select_rule_source {
enum {
CSS_SELECT_RULE_SRC_ELEMENT,
CSS_SELECT_RULE_SRC_CLASS,
CSS_SELECT_RULE_SRC_ID,
CSS_SELECT_RULE_SRC_UNIVERSAL
} source;
uint32_t class;
99} css_select_rule_source;


102static css_error set_hint(css_select_state *state, css_hint *hint);
103static css_error set_initial(css_select_state *state,
uint32_t prop, css_pseudo_element pseudo,
void *parent);

107static css_error select_from_sheet(css_select_ctx *ctx,
const css_stylesheet *sheet, css_origin origin,
css_select_state *state);
110static css_error match_selectors_in_sheet(css_select_ctx *ctx,
const css_stylesheet *sheet, css_select_state *state);
112static css_error match_selector_chain(css_select_ctx *ctx,
const css_selector *selector, css_select_state *state);
114static css_error match_named_combinator(css_select_ctx *ctx,
css_combinator type, const css_selector *selector,
css_select_state *state, void *node, void **next_node);
117static css_error match_universal_combinator(css_select_ctx *ctx,
css_combinator type, const css_selector *selector,
css_select_state *state, void *node, bool_Bool may_optimise,
bool_Bool *rejected_by_cache, void **next_node);
121static css_error match_details(css_select_ctx *ctx, void *node,
const css_selector_detail *detail, css_select_state *state,
bool_Bool *match, css_pseudo_element *pseudo_element);
124static css_error match_detail(css_select_ctx *ctx, void *node,
const css_selector_detail *detail, css_select_state *state,
bool_Bool *match, css_pseudo_element *pseudo_element);
127static css_error cascade_style(const css_style *style, css_select_state *state);

129static css_error select_font_faces_from_sheet(
const css_stylesheet *sheet,
css_origin origin,
css_select_font_faces_state *state,
const css_select_strings *str);

135#ifdef DEBUG_CHAIN_MATCHING
136static void dump_chain(const css_selector *selector);
137#endif


140static css_bloom *css__get_empty_bloom(void)
141{
static css_bloom empty_bloom[CSS_BLOOM_SIZE4];
return empty_bloom;
144}


147static css_error css__create_node_data(struct css_node_data **node_data)
148{
struct css_node_data *nd;

nd = calloc(1, sizeof(struct css_node_data));
if (nd == NULL((void*)0)) {
return CSS_NOMEM;
}

*node_data = nd;

return CSS_OK;
159}

161static void css__destroy_node_data(struct css_node_data *node_data)
162{
int i;

assert(node_data != NULL)((node_data != ((void*)0)) ? (void) (0) : __assert_fail ("node_data != NULL"
, "src/select/select.c", 165, __extension__ __PRETTY_FUNCTION__
));

if (node_data->bloom != NULL((void*)0) &&
	node_data->bloom != css__get_empty_bloom()) {
free(node_data->bloom);
}

for (i = 0; i < CSS_PSEUDO_ELEMENT_COUNT; i++) {
if (node_data->partial.styles[i] != NULL((void*)0)) {
	css_computed_style_destroy(
			node_data->partial.styles[i]);
}
}

free(node_data);
180}


183/* Exported function documented in public select.h header. */
184css_error css_libcss_node_data_handler(css_select_handler *handler,
css_node_data_action action, void *pw, void *node,
void *clone_node, void *libcss_node_data)
187{
struct css_node_data *node_data = libcss_node_data;
css_error error;

UNUSED(clone_node)((void)(clone_node));

if (handler == NULL((void*)0) || libcss_node_data == NULL((void*)0) ||
   handler->handler_version != CSS_SELECT_HANDLER_VERSION_1) {
return CSS_BADPARM;
}

switch (action) {
case CSS_NODE_DELETED:
css__destroy_node_data(node_data);
break;

case CSS_NODE_MODIFIED:
case CSS_NODE_ANCESTORS_MODIFIED:
if (node == NULL((void*)0)) {
	return CSS_BADPARM;
}

css__destroy_node_data(node_data);

/* Don't bother rebuilding node_data, it can be done
 * when the node is selected for.  Just ensure the
 * client drops its reference to the libcss_node_data. */
error = handler->set_libcss_node_data(pw, node, NULL((void*)0));
if (error != CSS_OK) {
	return error;
}
break;

case CSS_NODE_CLONED:
/* TODO: is it worth cloning libcss data?  We only store
 *       data on the nodes as an optimisation, which is
 *       unlikely to be valid for most cloning cases.
 */
break;

default:
return CSS_BADPARM;
}

return CSS_OK;
232}

234/**
* Create a selection context
*
* \param result  Pointer to location to receive created context
* \return CSS_OK on success, appropriate error otherwise.
*/
240css_error css_select_ctx_create(css_select_ctx **result)
241{
css_select_ctx *c;
css_error error;

if (result == NULL((void*)0))
return CSS_BADPARM;

c = calloc(1, sizeof(css_select_ctx));
if (c == NULL((void*)0))
return CSS_NOMEM;

error = css_calculator_create(&c->calc);
if (error != CSS_OK) {
free(c);
return error;
}

error = css_select_strings_intern(&c->str);
if (error != CSS_OK) {
css_calculator_unref(c->calc);
free(c);
return error;
}

*result = c;

return CSS_OK;
268}

270/**
* Destroy a selection context
*
* \param ctx  The context to destroy
* \return CSS_OK on success, appropriate error otherwise
*/
276css_error css_select_ctx_destroy(css_select_ctx *ctx)
277{
if (ctx == NULL((void*)0))
return CSS_BADPARM;

css_select_strings_unref(&ctx->str);

if (ctx->default_style != NULL((void*)0))
css_computed_style_destroy(ctx->default_style);

if (ctx->sheets != NULL((void*)0)) {
for (uint32_t index = 0; index < ctx->n_sheets; index++) {
	css__mq_query_destroy(ctx->sheets[index].media);
}
free(ctx->sheets);
}

css_calculator_unref(ctx->calc);

free(ctx);

return CSS_OK;
298}

300/**
* Append a stylesheet to a selection context
*
* \param ctx     The context to append to
* \param sheet   The sheet to append
* \param origin  Origin of the sheet
* \param media   Media string for the stylesheet
* \return CSS_OK on success, appropriate error otherwise
*/
309css_error css_select_ctx_append_sheet(css_select_ctx *ctx,
const css_stylesheet *sheet, css_origin origin,
const char *media)
312{
if (ctx == NULL((void*)0) || sheet == NULL((void*)0))
return CSS_BADPARM;

return css_select_ctx_insert_sheet(ctx, sheet, ctx->n_sheets,
	origin, media);
318}

320/**
* Insert a stylesheet into a selection context
*
* \param ctx    The context to insert into
* \param sheet  Sheet to insert
* \param index  Index in context to insert sheet
* \param origin  Origin of the sheet
* \param media   Media string for the stylesheet
* \return CSS_OK on success, appropriate error otherwise
*/
330css_error css_select_ctx_insert_sheet(css_select_ctx *ctx,
const css_stylesheet *sheet, uint32_t index,
css_origin origin, const char *media)
333{
css_select_sheet *temp;
css_mq_query *mq;
css_error error;

if (ctx == NULL((void*)0) || sheet == NULL((void*)0))
return CSS_BADPARM;

/* Inline styles cannot be inserted into a selection context */
if (sheet->inline_style)
return CSS_INVALID;

/* Index must be in the range [0, n_sheets]
* The latter being equivalent to append */
if (index > ctx->n_sheets)
return CSS_INVALID;

temp = realloc(ctx->sheets,
	(ctx->n_sheets + 1) * sizeof(css_select_sheet));
if (temp == NULL((void*)0))
return CSS_NOMEM;

ctx->sheets = temp;

if (index < ctx->n_sheets) {
memmove(&ctx->sheets[index + 1], &ctx->sheets[index],
	(ctx->n_sheets - index) * sizeof(css_select_sheet));
}

error = css_parse_media_query(sheet->propstrings,
	(const uint8_t *)media,
	(media == NULL((void*)0)) ? 0 : strlen(media), &mq);
if (error == CSS_NOMEM) {
return error;
} else if (error != CSS_OK) {
/* Fall back to default media: "all". */
mq = calloc(1, sizeof(*mq));
if (mq == NULL((void*)0)) {
	return CSS_NOMEM;
}
mq->type = CSS_MEDIA_ALL;
}

ctx->sheets[index].sheet = sheet;
ctx->sheets[index].origin = origin;
ctx->sheets[index].media = mq;

ctx->uses_revert |= sheet->uses_revert;

ctx->n_sheets++;

return CSS_OK;
385}

387/**
* Remove a sheet from a selection context
*
* \param ctx    The context to remove from
* \param sheet  Sheet to remove
* \return CSS_OK on success, appropriate error otherwise
*/
394css_error css_select_ctx_remove_sheet(css_select_ctx *ctx,
const css_stylesheet *sheet)
396{
uint32_t index;

if (ctx == NULL((void*)0) || sheet == NULL((void*)0))
return CSS_BADPARM;

for (index = 0; index < ctx->n_sheets; index++) {
if (ctx->sheets[index].sheet == sheet)
	break;
}

if (index == ctx->n_sheets)
return CSS_INVALID;

css__mq_query_destroy(ctx->sheets[index].media);

ctx->n_sheets--;

memmove(&ctx->sheets[index], &ctx->sheets[index + 1],
	(ctx->n_sheets - index) * sizeof(css_select_sheet));

return CSS_OK;

419}

421/**
* Count the number of top-level sheets in a selection context
*
* \param ctx    Context to consider
* \param count  Pointer to location to receive count of sheets
* \return CSS_OK on success, appropriate error otherwise
*/
428css_error css_select_ctx_count_sheets(css_select_ctx *ctx, uint32_t *count)
429{
if (ctx == NULL((void*)0) || count == NULL((void*)0))
return CSS_BADPARM;

*count = ctx->n_sheets;

return CSS_OK;
436}

438/**
* Retrieve a sheet from a selection context
*
* \param ctx    Context to look in
* \param index  Index in context to look
* \param sheet  Pointer to location to receive sheet
* \return CSS_OK on success, appropriate error otherwise
*/
446css_error css_select_ctx_get_sheet(css_select_ctx *ctx, uint32_t index,
const css_stylesheet **sheet)
448{
if (ctx == NULL((void*)0) || sheet == NULL((void*)0))
return CSS_BADPARM;

if (index > ctx->n_sheets)
return CSS_INVALID;

*sheet = ctx->sheets[index].sheet;

return CSS_OK;
458}


461/**
* Create a default style on the selection context
*
* \param ctx		Context to create default style in
* \param handler	Dispatch table of handler functions
* \param pw		Client-specific private data for handler functions
* \return CSS_OK on success, appropriate error otherwise
*/
469static css_error css__select_ctx_create_default_style(css_select_ctx *ctx,
css_select_handler *handler, void *pw)
471{
css_computed_style *style;
css_error error;

/* Need to construct the default style */
error = css__computed_style_create(&style, ctx->calc);
if (error != CSS_OK)
return error;

error = css__computed_style_initialise(style, handler, pw);
if (error != CSS_OK) {
css_computed_style_destroy(style);
return error;
}

/* Neither create nor initialise intern the style, so intern it now */
error = css__arena_intern_style(&style);
if (error != CSS_OK)
return error;

/* Store it on the ctx */
ctx->default_style = style;

return CSS_OK;
495}


498/**
* Get a default style, e.g. for an implied element's anonymous box
*
* \param ctx		Selection context (used to avoid recreating default)
* \param handler	Dispatch table of handler functions
* \param pw		Client-specific private data for handler functions
* \param style		Pointer to location to receive default style
* \return CSS_OK on success, appropriate error otherwise.
*/
507css_error css_select_default_style(css_select_ctx *ctx,
css_select_handler *handler, void *pw,
css_computed_style **style)
510{
css_error error;

if (ctx == NULL((void*)0) || style == NULL((void*)0) || handler == NULL((void*)0) ||
	handler->handler_version !=
			CSS_SELECT_HANDLER_VERSION_1)
return CSS_BADPARM;

/* Ensure the ctx has a default style */
if (ctx->default_style == NULL((void*)0)) {
error = css__select_ctx_create_default_style(ctx, handler, pw);
if (error != CSS_OK) {
	return error;
}
}

/* Pass a ref back to the client */
*style = css__computed_style_ref(ctx->default_style);
return CSS_OK;
529}


532/**
* Get a bloom filter for the parent node
*
* \param parent        Parent node to get bloom filter for
* \param handler       Dispatch table of handler functions
* \param pw            Client-specific private data for handler functions
* \param parent_bloom  Updated to parent bloom to use.
*                      Note: if there's no parent, the caller must free
*                      the returned parent bloom, since it has no node to
*                      own it.
* \return CSS_OK on success, appropriate error otherwise.
*/
544static css_error css__get_parent_bloom(void *parent,
css_select_handler *handler, void *pw,
css_bloom **parent_bloom)
547{
struct css_node_data *node_data = NULL((void*)0);
css_bloom *bloom = NULL((void*)0);
css_error error;

/* Get parent node's bloom filter */
if (parent != NULL((void*)0)) {
/* Get parent bloom filter */
struct css_node_data *node_data;

/* Hideous casting to avoid warnings on all platforms
 * we build for. */
error = handler->get_libcss_node_data(pw, parent,
		(void **) (void *) &node_data);
if (error != CSS_OK) {
	return error;
}
if (node_data != NULL((void*)0)) {
	bloom = node_data->bloom;
}
}

if (bloom == NULL((void*)0)) {
uint32_t i;
/* Need to create parent bloom */

if (parent != NULL((void*)0)) {
	/* TODO:
	 * Build & set the parent node's bloom properly.
	 * This will speed up the case where DOM change
	 * has caused bloom to get deleted.  For now we
	 * fall back to a fully saturated bloom filter,
	 * which is slower but perfectly valid.
	 */
	bloom = malloc(sizeof(css_bloom) * CSS_BLOOM_SIZE4);
	if (bloom == NULL((void*)0)) {
		return CSS_NOMEM;
	}

	for (i = 0; i < CSS_BLOOM_SIZE4; i++) {
		bloom[i] = ~0;
	}

	if (node_data == NULL((void*)0)) {
		error = css__create_node_data(&node_data);
		if (error != CSS_OK) {
			free(bloom);
			return error;
		}
		node_data->bloom = bloom;

		/* Set parent node bloom filter */
		error = handler->set_libcss_node_data(pw,
				parent, node_data);
		if (error != CSS_OK) {
			css__destroy_node_data(node_data);
			return error;
		}
	}
} else {
	/* No ancestors; empty bloom filter */
	/* The parent bloom is owned by the parent node's
	 * node data.  However, for the root node, there is
	 * no parent node to own the bloom filter.
	 * As such, we just use a pointer to static storage
	 * so calling code doesn't need to worry about
	 * whether the returned parent bloom is owned
	 * by something or not.
	 * Note, parent bloom is only read from, and not
	 * written to. */
	bloom = css__get_empty_bloom();
}
}

*parent_bloom = bloom;
return CSS_OK;
623}

625static css_error css__create_node_bloom(
css_bloom **node_bloom, css_select_state *state)
627{
css_error error;
css_bloom *bloom;
lwc_hash hash;

*node_bloom = NULL((void*)0);

/* Create the node's bloom */
bloom = calloc(CSS_BLOOM_SIZE4, sizeof(css_bloom));
if (bloom == NULL((void*)0)) {
return CSS_NOMEM;
}

/* Add node name to bloom */
if (lwc_string_caseless_hash_value(state->element.name,
	&hash) != lwc_error_ok) {
error = CSS_NOMEM;
goto cleanup;
}
css_bloom_add_hash(bloom, hash);

/* Add id name to bloom */
if (state->id != NULL((void*)0)) {
if (lwc_string_caseless_hash_value(state->id,
		&hash) != lwc_error_ok) {
	error = CSS_NOMEM;
	goto cleanup;
}
css_bloom_add_hash(bloom, hash);
}

/* Add class names to bloom */
if (state->classes != NULL((void*)0)) {
for (uint32_t i = 0; i < state->n_classes; i++) {
	lwc_string *s = state->classes[i];
	if (lwc_string_caseless_hash_value(s,
			&hash) != lwc_error_ok) {
		error = CSS_NOMEM;
		goto cleanup;
	}
	css_bloom_add_hash(bloom, hash);
}
}

/* Merge parent bloom into node bloom */
css_bloom_merge(state->node_data->bloom, bloom);
*node_bloom = bloom;

return CSS_OK;

677cleanup:
free(bloom);

return error;
681}

683/**
* Set a node's data
*
* \param node     Node to set node data for
* \param state    Selection state for node
* \param handler  Dispatch table of handler functions
* \param pw       Client-specific private data for handler functions
* \return CSS_OK on success, appropriate error otherwise.
*/
692static css_error css__set_node_data(void *node, css_select_state *state,
css_select_handler *handler, void *pw)
694{
int i;
css_error error;
css_bloom *bloom;
css_select_results *results;

struct css_node_data *node_data = state->node_data;

/* Set node bloom filter */
error = css__create_node_bloom(&bloom, state);
if (error != CSS_OK) {
return error;
}
node_data->bloom = bloom;

/* Set selection results */
results = state->results;
for (i = 0; i < CSS_PSEUDO_ELEMENT_COUNT; i++) {
node_data->partial.styles[i] =
		css__computed_style_ref(results->styles[i]);
}

error = handler->set_libcss_node_data(pw, node, node_data);
if (error != CSS_OK) {
css__destroy_node_data(node_data);
state->node_data = NULL((void*)0);
return error;
}

state->node_data = NULL((void*)0);

return CSS_OK;
726}


729/** The releationship of a share candidate node to the selection node. */
730enum share_candidate_type {
CANDIDATE_SIBLING,
CANDIDATE_COUSIN,
733};


736/**
* Get node_data for candidate node if we can reuse its style.
*
* \param[in]  state                 The selection state for current node.
* \param[in]  share_candidate_node  The node to test id and classes of.
* \param[in]  type                  The candidate's relation to selection node.
* \param[out] sharable_node_data    Returns node_data or NULL.
* \return CSS_OK on success, appropriate error otherwise.
*/
745static css_error css_select_style__get_sharable_node_data_for_candidate(
css_select_state *state,
void *share_candidate_node,
enum share_candidate_type type,
struct css_node_data **sharable_node_data)
750{
css_error error;
lwc_string *share_candidate_id;
uint32_t share_candidate_n_classes;
lwc_string **share_candidate_classes;
struct css_node_data *node_data;

UNUSED(type)((void)(type));

*sharable_node_data = NULL((void*)0);

/* We get the candidate node data first, as if it has none, we can't
* share its data anyway.
* Hideous casting to avoid warnings on all platforms we build for. */
error = state->handler->get_libcss_node_data(state->pw,
	share_candidate_node, (void **) (void *) &node_data);
if (error != CSS_OK || node_data == NULL((void*)0)) {
767#ifdef DEBUG_STYLE_SHARING
printf("      \t%s\tno share: no candidate node data\n",
		lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 769
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}));
770#endif
return error;
}

/* If one node has hints and other doesn't then can't share */
if ((node_data->flags & CSS_NODE_FLAGS_HAS_HINTS) !=
	(state->node_data->flags & CSS_NODE_FLAGS_HAS_HINTS)) {
777#ifdef DEBUG_STYLE_SHARING
printf("      \t%s\tno share: have hints mismatch\n",
		lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 779
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}));
780#endif
return CSS_OK;
}

/* If the node and candidate node had different pseudo classes, we
* can't share. */
if ((node_data->flags & CSS_NODE_FLAGS__PSEUDO_CLASSES_MASK) !=
	(state->node_data->flags &
			CSS_NODE_FLAGS__PSEUDO_CLASSES_MASK)) {
789#ifdef DEBUG_STYLE_SHARING
printf("      \t%s\tno share: different pseudo classes\n",
		lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 791
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}));
792#endif
return CSS_OK;

}

/* If the node was affected by attribute or pseudo class rules,
* or had an inline style, it's not a candidate for sharing */
if (node_data->flags & (
	CSS_NODE_FLAGS_TAINT_PSEUDO_CLASS |
	CSS_NODE_FLAGS_TAINT_ATTRIBUTE |
	CSS_NODE_FLAGS_TAINT_SIBLING |
	CSS_NODE_FLAGS_HAS_INLINE_STYLE)) {
804#ifdef DEBUG_STYLE_SHARING
printf("      \t%s\tno share: candidate flags: %s%s%s%s\n",
		lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 806
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}),
		(node_data->flags &
			CSS_NODE_FLAGS_TAINT_PSEUDO_CLASS) ?
				"PSEUDOCLASS" : "",
		(node_data->flags &
			CSS_NODE_FLAGS_TAINT_ATTRIBUTE) ?
				" ATTRIBUTE" : "",
		(node_data->flags &
			CSS_NODE_FLAGS_TAINT_SIBLING) ?
				" SIBLING" : "",
		(node_data->flags &
			CSS_NODE_FLAGS_HAS_INLINE_STYLE) ?
				" INLINE_STYLE" : "");
819#endif
return CSS_OK;
}

/* Check candidate ID doesn't prevent sharing */
error = state->handler->node_id(state->pw,
	share_candidate_node,
	&share_candidate_id);
if (error != CSS_OK) {
return error;

} else if (share_candidate_id != NULL((void*)0)) {
lwc_string_unref(share_candidate_id){ lwc_string *__lwc_s = (share_candidate_id); if (__lwc_s != (
(void*)0)) { __lwc_s->refcnt--; if ((__lwc_s->refcnt ==
 0) || ((__lwc_s->refcnt == 1) && (__lwc_s->insensitive
 == __lwc_s))) lwc_string_destroy(__lwc_s); } };
832#ifdef DEBUG_STYLE_SHARING
printf("      \t%s\tno share: candidate id\n",
		lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 834
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}));
835#endif
return CSS_OK;
}

/* Check candidate classes don't prevent sharing */
error = state->handler->node_classes(state->pw,
	share_candidate_node,
	&share_candidate_classes,
	&share_candidate_n_classes);
if (error != CSS_OK) {
return error;
}

if (state->n_classes != share_candidate_n_classes) {
849#ifdef DEBUG_STYLE_SHARING
printf("      \t%s\tno share: class count mismatch\n",
		lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 851
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}));
852#endif
goto cleanup;
}

/* TODO: no need to care about the order, but it's simpler to
*       have an ordered match, and authors are more likely to be
*       consistent than  not. */
for (uint32_t i = 0; i < share_candidate_n_classes; i++) {
bool_Bool match;
if (lwc_string_caseless_isequal(({ lwc_error __lwc_err = lwc_error_ok; lwc_string *__lwc_str1
 = (state->classes[i]); lwc_string *__lwc_str2 = (share_candidate_classes
[i]); _Bool *__lwc_ret = (&match); if (__lwc_str1->insensitive
 == ((void*)0)) { __lwc_err = lwc__intern_caseless_string(__lwc_str1
); } if (__lwc_err == lwc_error_ok && __lwc_str2->
insensitive == ((void*)0)) { __lwc_err = lwc__intern_caseless_string
(__lwc_str2); } if (__lwc_err == lwc_error_ok) *__lwc_ret = (
__lwc_str1->insensitive == __lwc_str2->insensitive); __lwc_err
; })
		state->classes[i],({ lwc_error __lwc_err = lwc_error_ok; lwc_string *__lwc_str1
 = (state->classes[i]); lwc_string *__lwc_str2 = (share_candidate_classes
[i]); _Bool *__lwc_ret = (&match); if (__lwc_str1->insensitive
 == ((void*)0)) { __lwc_err = lwc__intern_caseless_string(__lwc_str1
); } if (__lwc_err == lwc_error_ok && __lwc_str2->
insensitive == ((void*)0)) { __lwc_err = lwc__intern_caseless_string
(__lwc_str2); } if (__lwc_err == lwc_error_ok) *__lwc_ret = (
__lwc_str1->insensitive == __lwc_str2->insensitive); __lwc_err
; })
		share_candidate_classes[i],({ lwc_error __lwc_err = lwc_error_ok; lwc_string *__lwc_str1
 = (state->classes[i]); lwc_string *__lwc_str2 = (share_candidate_classes
[i]); _Bool *__lwc_ret = (&match); if (__lwc_str1->insensitive
 == ((void*)0)) { __lwc_err = lwc__intern_caseless_string(__lwc_str1
); } if (__lwc_err == lwc_error_ok && __lwc_str2->
insensitive == ((void*)0)) { __lwc_err = lwc__intern_caseless_string
(__lwc_str2); } if (__lwc_err == lwc_error_ok) *__lwc_ret = (
__lwc_str1->insensitive == __lwc_str2->insensitive); __lwc_err
; })
		&match)({ lwc_error __lwc_err = lwc_error_ok; lwc_string *__lwc_str1
 = (state->classes[i]); lwc_string *__lwc_str2 = (share_candidate_classes
[i]); _Bool *__lwc_ret = (&match); if (__lwc_str1->insensitive
 == ((void*)0)) { __lwc_err = lwc__intern_caseless_string(__lwc_str1
); } if (__lwc_err == lwc_error_ok && __lwc_str2->
insensitive == ((void*)0)) { __lwc_err = lwc__intern_caseless_string
(__lwc_str2); } if (__lwc_err == lwc_error_ok) *__lwc_ret = (
__lwc_str1->insensitive == __lwc_str2->insensitive); __lwc_err
; }) == lwc_error_ok &&
		match == false0) {
866#ifdef DEBUG_STYLE_SHARING
	printf("      \t%s\tno share: class mismatch\n",
			lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 868
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}));
869#endif
	goto cleanup;
}
}

if (node_data->flags & CSS_NODE_FLAGS_HAS_HINTS) {
/* TODO: check hints match.  For now, just prevent sharing */
876#ifdef DEBUG_STYLE_SHARING
printf("      \t%s\tno share: hints\n",
		lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 878
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}));
879#endif
goto cleanup;
}

*sharable_node_data = node_data;

885cleanup:
if (share_candidate_classes != NULL((void*)0)) {
for (uint32_t i = 0; i < share_candidate_n_classes; i++) {
	lwc_string_unref(share_candidate_classes[i]){ lwc_string *__lwc_s = (share_candidate_classes[i]); if (__lwc_s
 != ((void*)0)) { __lwc_s->refcnt--; if ((__lwc_s->refcnt
 == 0) || ((__lwc_s->refcnt == 1) && (__lwc_s->
insensitive == __lwc_s))) lwc_string_destroy(__lwc_s); } };
}
}

return CSS_OK;
893}


896/**
* Get previous named cousin node.
*
* \param[in]  state       The selection state for current node.
* \param[in]  node        The node to get the cousin of.
* \param[out] cousin_out  Returns a cousin node or NULL.
* \return CSS_OK on success or appropriate error otherwise.
*/
904static css_error css_select_style__get_named_cousin(
css_select_state *state, void *node,
void **cousin_out)
907{
/* TODO:
*
* Consider cousin nodes; Go to parent's previous sibling's last child.
* The parent and the parent's sibling must be "similar".
*/
UNUSED(state)((void)(state));
UNUSED(node)((void)(node));

*cousin_out = NULL((void*)0);

return CSS_OK;
919}


922/**
* Get node_data for any node that we can reuse the style for.
*
* This is an optimisation to needing to perform selection for a node,
* by sharing the style for a previous node.
*
* \param[in]  node                Node we're selecting for.
* \param[in]  state               The current selection state.
* \param[out] sharable_node_data  Returns node_data or NULL.
* \return CSS_OK on success or appropriate error otherwise.
*/
933static css_error css_select_style__get_sharable_node_data(
void *node, css_select_state *state,
struct css_node_data **sharable_node_data)
936{
css_error error;
enum share_candidate_type type = CANDIDATE_SIBLING;

*sharable_node_data = NULL((void*)0);

/* TODO: move this test to caller? */
if (state->id != NULL((void*)0)) {
/* If the node has an ID can't share another node's style. */
/* TODO: Consider whether this ID exists in the ID hash tables.
 *       (If not, the ID cannot affect the node's style.)
 *
 *       Call css__selector_hash_find_by_id, for each sheet,
 *       and if we get a non-NULL "matched" then return.
 *
 *       Check overhead is worth cost. */
952#ifdef DEBUG_STYLE_SHARING
953printf("      \t%s\tno share: node id (%s)\n", lwc_string_data(state->element.name)({((state->element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state->element.name != NULL", "src/select/select.c", 953
, __extension__ __PRETTY_FUNCTION__)); (const char *)((state->
element.name)+1);}), lwc_string_data(state->id)({((state->id != ((void*)0)) ? (void) (0) : __assert_fail (
"state->id != NULL", "src/select/select.c", 953, __extension__
 __PRETTY_FUNCTION__)); (const char *)((state->id)+1);}));
954#endif
return CSS_OK;
}
if (state->node_data->flags & CSS_NODE_FLAGS_HAS_INLINE_STYLE) {
958#ifdef DEBUG_STYLE_SHARING
959printf("      \t%s\tno share: inline style\n");
960#endif
return CSS_OK;
}

while (true1) {
void *share_candidate_node;

/* Get previous sibling with same element name */
error = state->handler->named_generic_sibling_node(state->pw,
		node, &state->element, &share_candidate_node);
if (error != CSS_OK) {
	return error;
} else {
	if (share_candidate_node == NULL((void*)0)) {
		error = css_select_style__get_named_cousin(
				state, node,
				&share_candidate_node);
		if (error != CSS_OK) {
			return error;
		} else {
			if (share_candidate_node == NULL((void*)0)) {
				break;
			}
		}
		type = CANDIDATE_COUSIN;
	}
}

/* Check whether we can share the candidate node's
 * style.  We already know the element names match,
 * check that candidate node's ID and class won't
 * prevent sharing. */
error = css_select_style__get_sharable_node_data_for_candidate(
		state, share_candidate_node,
		type, sharable_node_data);
if (error != CSS_OK) {
	return error;
}

if (*sharable_node_data != NULL((void*)0)) {
	/* Found style date we can share */
	break;
}

/* Can't share with this; look for another */
node = share_candidate_node;
}

return CSS_OK;
1009}


1012/**
* Finalise a selection state, releasing any resources it owns
*
* \param[in] state  The selection state to finalise.
*/
1017static void css_select__finalise_selection_state(
css_select_state *state)
1019{
if (state->results != NULL((void*)0)) {
css_select_results_destroy(state->results);
}

if (state->node_data != NULL((void*)0)) {
css__destroy_node_data(state->node_data);
}

if (state->classes != NULL((void*)0)) {
for (uint32_t i = 0; i < state->n_classes; i++) {
	lwc_string_unref(state->classes[i]){ lwc_string *__lwc_s = (state->classes[i]); if (__lwc_s !=
 ((void*)0)) { __lwc_s->refcnt--; if ((__lwc_s->refcnt ==
 0) || ((__lwc_s->refcnt == 1) && (__lwc_s->insensitive
 == __lwc_s))) lwc_string_destroy(__lwc_s); } };
}
}

lwc_string_unref(state->id){ lwc_string *__lwc_s = (state->id); if (__lwc_s != ((void
*)0)) { __lwc_s->refcnt--; if ((__lwc_s->refcnt == 0) ||
 ((__lwc_s->refcnt == 1) && (__lwc_s->insensitive
 == __lwc_s))) lwc_string_destroy(__lwc_s); } };
lwc_string_unref(state->element.ns){ lwc_string *__lwc_s = (state->element.ns); if (__lwc_s !=
 ((void*)0)) { __lwc_s->refcnt--; if ((__lwc_s->refcnt ==
 0) || ((__lwc_s->refcnt == 1) && (__lwc_s->insensitive
 == __lwc_s))) lwc_string_destroy(__lwc_s); } };
lwc_string_unref(state->element.name){ lwc_string *__lwc_s = (state->element.name); if (__lwc_s
 != ((void*)0)) { __lwc_s->refcnt--; if ((__lwc_s->refcnt
 == 0) || ((__lwc_s->refcnt == 1) && (__lwc_s->
insensitive == __lwc_s))) lwc_string_destroy(__lwc_s); } };

if (state->revert != NULL((void*)0)) {
for (size_t i = 0; i < CSS_ORIGIN_AUTHOR; i++) {
	for (size_t j = 0; j < CSS_PSEUDO_ELEMENT_COUNT; j++) {
		if (state->revert[i].style[j] == NULL((void*)0)) {
			continue;
		}
		css_computed_style_destroy(
				state->revert[i].style[j]);
	}
}
free(state->revert);
}
1050}


1053/**
* Initialise a selection state.
*
* \param[in]  state         The selection state to initialise
* \param[in]  node          The node we are selecting for.
* \param[in]  parent        The node's parent node, or NULL.
* \param[in]  media         The media specification we're selecting for.
* \param[in]  unit_ctx      Unit conversion context.
* \param[in]  handler       The client selection callback table.
* \param[in]  pw            The client private data, passed out to callbacks.
* \return CSS_OK or appropriate error otherwise.
*/
1065static css_error css_select__initialise_selection_state(
css_select_state *state,
void *node,
void *parent,
const css_media *media,
const css_unit_ctx *unit_ctx,
css_select_handler *handler,
void *pw)
1073{
css_error error;
bool_Bool match;

/* Set up the selection state */
memset(state, 0, sizeof(*state));
state->node = node;
state->media = media;
state->unit_ctx = unit_ctx;
state->handler = handler;
state->pw = pw;
state->next_reject = state->reject_cache +
	(N_ELEMENTS(state->reject_cache)(sizeof((state->reject_cache)) / sizeof((state->reject_cache
)[0])) - 1);

/* Allocate the result set */
state->results = calloc(1, sizeof(css_select_results));
if (state->results == NULL((void*)0)) {
return CSS_NOMEM;
}

error = css__create_node_data(&state->node_data);
if (error != CSS_OK) {
goto failed;
}

error = css__get_parent_bloom(parent, handler, pw,
	&state->node_data->bloom);
if (error != CSS_OK) {
goto failed;
}

/* Get node's name */
error = handler->node_name(pw, node, &state->element);
if (error != CSS_OK){
goto failed;
}

/* Get node's ID, if any */
error = handler->node_id(pw, node, &state->id);
if (error != CSS_OK){
goto failed;
}

/* Get node's classes, if any */
error = handler->node_classes(pw, node,
	&state->classes, &state->n_classes);
if (error != CSS_OK){
goto failed;
}

/* Node pseudo classes */
error = handler->node_is_link(pw, node, &match);
if (error != CSS_OK){
goto failed;
} else if (match) {
state->node_data->flags |= CSS_NODE_FLAGS_PSEUDO_CLASS_LINK;
}

error = handler->node_is_visited(pw, node, &match);
if (error != CSS_OK){
goto failed;
} else if (match) {
state->node_data->flags |= CSS_NODE_FLAGS_PSEUDO_CLASS_VISITED;
}

error = handler->node_is_hover(pw, node, &match);
if (error != CSS_OK){
goto failed;
} else if (match) {
state->node_data->flags |= CSS_NODE_FLAGS_PSEUDO_CLASS_HOVER;
}

error = handler->node_is_active(pw, node, &match);
if (error != CSS_OK){
goto failed;
} else if (match) {
state->node_data->flags |= CSS_NODE_FLAGS_PSEUDO_CLASS_ACTIVE;
}

error = handler->node_is_focus(pw, node, &match);
if (error != CSS_OK){
goto failed;
} else if (match) {
state->node_data->flags |= CSS_NODE_FLAGS_PSEUDO_CLASS_FOCUS;
}

return CSS_OK;

1161failed:
css_select__finalise_selection_state(state);
return error;
1164}

1166static css_error css__select_revert_property_to_origin(
css_select_state *select_state,
prop_state *prop_state,
css_origin origin,
enum css_pseudo_element pseudo,
enum css_properties_e property)
1172{
css_error error;

if (select_state->results->styles[pseudo] == NULL((void*)0)) {
return CSS_OK;
}

if (select_state->revert[origin].style[pseudo] == NULL((void*)0)) {
return prop_dispatch[property].initial(select_state);
}

error = prop_dispatch[property].copy(
	select_state->revert[origin].style[pseudo],
	select_state->results->styles[pseudo]);
if (error != CSS_OK) {
return error;
}

*prop_state = select_state->revert[origin].props[property][pseudo];
return CSS_OK;
1192}

1194static css_error css__select_revert_property(
css_select_state *select_state,
prop_state *prop_state,
enum css_pseudo_element pseudo,
enum css_properties_e property)
1199{
css_error error;

switch (prop_state->origin) {
case CSS_ORIGIN_AUTHOR:
error = css__select_revert_property_to_origin(
		select_state, prop_state, CSS_ORIGIN_USER,
		pseudo, property);
if (error != CSS_OK) {
	return error;
}
if (prop_state->explicit_default != FLAG_VALUE_REVERT) {
	break;
}
/* Fall-through */
case CSS_ORIGIN_USER:
error = css__select_revert_property_to_origin(
		select_state, prop_state, CSS_ORIGIN_UA,
		pseudo, property);
if (error != CSS_OK) {
	return error;
}
if (prop_state->explicit_default != FLAG_VALUE_REVERT) {
	break;
}
/* Fall-through */
case CSS_ORIGIN_UA:
prop_state->explicit_default = FLAG_VALUE_UNSET;
break;
}

return CSS_OK;
1231}

1233/**
* Select a style for the given node
*
* \param ctx             Selection context to use
* \param node            Node to select style for
* \param unit_ctx        Context for length unit conversions.
* \param media           Currently active media specification
* \param inline_style    Corresponding inline style for node, or NULL
* \param handler         Dispatch table of handler functions
* \param pw              Client-specific private data for handler functions
* \param result          Pointer to location to receive result set
* \return CSS_OK on success, appropriate error otherwise.
*
* In computing the style, no reference is made to the parent node's
* style. Therefore, the resultant computed style is not ready for
* immediate use, as some properties may be marked as inherited.
* Use css_computed_style_compose() to obtain a fully computed style.
*
* This two-step approach to style computation is designed to allow
* the client to store the partially computed style and efficiently
* update the fully computed style for a node when layout changes.
*/
1255css_error css_select_style(css_select_ctx *ctx, void *node,
1
[debug] analyzing from css_select_style→
const css_unit_ctx *unit_ctx,
const css_media *media, const css_stylesheet *inline_style,
css_select_handler *handler, void *pw,
css_select_results **result)
1260{
css_origin origin = CSS_ORIGIN_UA;
uint32_t i, j, nhints;
css_error error;
css_select_state state;
css_hint *hints = NULL((void*)0);
void *parent = NULL((void*)0);
struct css_node_data *share;

if (ctx == NULL((void*)0) || node == NULL((void*)0) || result == NULL((void*)0) || handler == NULL((void*)0) ||
2
←
Assuming 'ctx' is not equal to NULL→
3
←
Assuming 'node' is not equal to NULL→
4
←
Assuming 'result' is not equal to NULL→
5
←
Assuming 'handler' is not equal to NULL→
7
←
Taking false branch→
   handler->handler_version != CSS_SELECT_HANDLER_VERSION_1)
6
←
Assuming field 'handler_version' is equal to CSS_SELECT_HANDLER_VERSION_1→
return CSS_BADPARM;

error = handler->parent_node(pw, node, &parent);
if (error != CSS_OK)
8
←
Assuming 'error' is equal to CSS_OK→
9
←
Taking false branch→
return error;

error = css_select__initialise_selection_state(
	&state, node, parent, media, unit_ctx, handler, pw);
if (error9.1
'error' is equal to CSS_OK
 != CSS_OK)
10
←
Taking false branch→
return error;

/* Fetch presentational hints */
error = handler->node_presentational_hint(pw, node, &nhints, &hints);
if (error != CSS_OK)
11
←
Assuming 'error' is equal to CSS_OK→
12
←
Taking false branch→
goto cleanup;
if (nhints > 0) {
13
←
Assuming 'nhints' is <= 0→
14
←
Taking false branch→
state.node_data->flags |= CSS_NODE_FLAGS_HAS_HINTS;
}

if (inline_style != NULL((void*)0)) {
15
←
Assuming 'inline_style' is equal to NULL→
16
←
Taking false branch→
state.node_data->flags |= CSS_NODE_FLAGS_HAS_INLINE_STYLE;
}

/* Check if we can share another node's style */
error = css_select_style__get_sharable_node_data(node, &state, &share);
if (error16.1
'error' is equal to CSS_OK
 != CSS_OK) {
17
←
Taking false branch→
goto cleanup;
} else if (share17.1
'share' is equal to NULL
 != NULL((void*)0)) {
css_computed_style **styles = share->partial.styles;
for (i = 0; i < CSS_PSEUDO_ELEMENT_COUNT; i++) {
	state.results->styles[i] =
			css__computed_style_ref(styles[i]);
}
1304#ifdef DEBUG_STYLE_SHARING
printf("style:\t%s\tSHARED!\n",
		lwc_string_data(state.element.name)({((state.element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state.element.name != NULL", "src/select/select.c", 1306, __extension__
 __PRETTY_FUNCTION__)); (const char *)((state.element.name)+1
);}));
1307#endif
goto complete;
}
1310#ifdef DEBUG_STYLE_SHARING
printf("style:\t%s\tSELECTED\n", lwc_string_data(state.element.name)({((state.element.name != ((void*)0)) ? (void) (0) : __assert_fail
 ("state.element.name != NULL", "src/select/select.c", 1311, __extension__
 __PRETTY_FUNCTION__)); (const char *)((state.element.name)+1
);}));
1312#endif

/* Not sharing; need to select. */
if (ctx->uses_revert ||
18
←
Assuming field 'uses_revert' is false→
	(inline_style18.1
'inline_style' is equal to NULL
 != NULL((void*)0) && inline_style->uses_revert)) {
/* Need to track UA and USER origin styles for revert. */
state.revert = calloc(CSS_ORIGIN_AUTHOR, sizeof(*state.revert));
if (state.revert == NULL((void*)0)) {
	error = CSS_NOMEM;
	goto cleanup;
}
}

/* Base element style is guaranteed to exist
*/
error = css__computed_style_create(
	&state.results->styles[CSS_PSEUDO_ELEMENT_NONE], ctx->calc);
if (error != CSS_OK) {
19
←
Assuming 'error' is equal to CSS_OK→
20
←
Taking false branch→
goto cleanup;
}

/* Apply any hints */
if (nhints20.1
'nhints' is <= 0
 > 0) {
21
←
Taking false branch→
/* Ensure that the appropriate computed style exists */
struct css_computed_style *computed_style =
		state.results->styles[CSS_PSEUDO_ELEMENT_NONE];
state.computed = computed_style;

for (i = 0; i < nhints; i++) {
	error = set_hint(&state, &hints[i]);
	if (error != CSS_OK)
		goto cleanup;
}
}

/* Iterate through the top-level stylesheets, selecting styles
* from those which apply to our current media requirements and
* are not disabled */
if (ctx->n_sheets > 0) {
22
←
Assuming field 'n_sheets' is > 0→
23
←
Taking true branch→
origin = ctx->sheets[0].origin;
}
for (i = 0; i23.1
'i' is < field 'n_sheets'
 < ctx->n_sheets; i++) {
24
←
Loop condition is true.  Entering loop body→
const css_select_sheet s = ctx->sheets[i];

if (state.revert != NULL((void*)0) && s.origin != origin) {
25
←
Assuming field 'revert' is equal to NULL→
	for (j = 0; j < CSS_PSEUDO_ELEMENT_COUNT; j++) {
		if (state.results->styles[j] == NULL((void*)0)) {
			continue;
		}
		error = css__computed_style_clone(
				state.results->styles[j],
				&state.revert[origin].style[j]);
		if (error != CSS_OK) {
			goto cleanup;
		}
		memcpy(state.revert[origin].props,
		       state.props, sizeof(state.props));
	}
	origin = s.origin;
}

if (mq__list_match(s.media, unit_ctx, media, &ctx->str) &&
27
←
Taking true branch→
		s.sheet->disabled == false0) {
26
←
Assuming field 'disabled' is equal to false→
	error = select_from_sheet(ctx, s.sheet,
28
←
Calling 'select_from_sheet'→
			s.origin, &state);
	if (error != CSS_OK)
		goto cleanup;
}
}

/* Consider any inline style for the node */
if (inline_style != NULL((void*)0)) {
css_rule_selector *sel =
		(css_rule_selector *) inline_style->rule_list;

/* Sanity check style */
if (inline_style->rule_count != 1 ||
	inline_style->rule_list->type != CSS_RULE_SELECTOR ||
		inline_style->rule_list->items != 0) {
	error = CSS_INVALID;
	goto cleanup;
}

/* No bytecode if input was empty or wholly invalid */
if (sel->style != NULL((void*)0)) {
	/* Inline style applies to base element only */
	state.current_pseudo = CSS_PSEUDO_ELEMENT_NONE;
	state.computed = state.results->styles[
			CSS_PSEUDO_ELEMENT_NONE];

	error = cascade_style(sel->style, &state);
	if (error != CSS_OK)
		goto cleanup;
}
}

/* Fix up any remaining unset properties. */

/* Base element */
state.current_pseudo = CSS_PSEUDO_ELEMENT_NONE;
state.computed = state.results->styles[CSS_PSEUDO_ELEMENT_NONE];
for (i = 0; i < CSS_N_PROPERTIES; i++) {
prop_state *prop = &state.props[i][CSS_PSEUDO_ELEMENT_NONE];

if (prop->explicit_default == FLAG_VALUE_REVERT) {
	error = css__select_revert_property(&state, prop,
			CSS_PSEUDO_ELEMENT_NONE, i);
	if (error != CSS_OK) {
		goto cleanup;
	}
}

if (prop->explicit_default == FLAG_VALUE_UNSET) {
	if (prop_dispatch[i].inherited == true1) {
		prop->explicit_default = FLAG_VALUE_INHERIT;
	} else {
		prop->explicit_default = FLAG_VALUE_INITIAL;
	}
}

/* If the property is still unset or it's set to inherit
 * and we're the root element, then set it to its initial
 * value. */
if (prop->explicit_default == FLAG_VALUE_INITIAL ||
		prop->set == false0 ||
		(parent == NULL((void*)0) &&
		prop->explicit_default == FLAG_VALUE_INHERIT)) {
	error = set_initial(&state, i,
			CSS_PSEUDO_ELEMENT_NONE, parent);
	if (error != CSS_OK)
		goto cleanup;
}
}

/* Pseudo elements, if any */
for (j = CSS_PSEUDO_ELEMENT_NONE + 1; j < CSS_PSEUDO_ELEMENT_COUNT; j++) {
state.current_pseudo = j;
state.computed = state.results->styles[j];

/* Skip non-existent pseudo elements */
if (state.computed == NULL((void*)0))
	continue;

for (i = 0; i < CSS_N_PROPERTIES; i++) {
	prop_state *prop = &state.props[i][j];

	if (prop->explicit_default == FLAG_VALUE_REVERT) {
		error = css__select_revert_property(&state,
				prop, j, i);
		if (error != CSS_OK) {
			goto cleanup;
		}
	}

	if (prop->explicit_default == FLAG_VALUE_UNSET) {
		if (prop_dispatch[i].inherited == true1) {
			prop->explicit_default = FLAG_VALUE_INHERIT;
		} else {
			prop->explicit_default = FLAG_VALUE_INITIAL;
		}
	}

	/* If the property is still unset then set it
	 * to its initial value. */
	if (prop->explicit_default == FLAG_VALUE_INITIAL ||
			prop->set == false0) {
		error = set_initial(&state, i, j, parent);
		if (error != CSS_OK)
			goto cleanup;
	}
}
}

/* If this is the root element, then we must ensure that all
* length values are absolute, display and float are correctly
* computed, and the default border-{top,right,bottom,left}-color
* is set to the computed value of color. */
if (parent == NULL((void*)0)) {
/* Only compute absolute values for the base element */
error = css__compute_absolute_values(NULL((void*)0),
		state.results->styles[CSS_PSEUDO_ELEMENT_NONE],
		unit_ctx);
if (error != CSS_OK)
	goto cleanup;
}

/* Intern the partial computed styles */
for (j = CSS_PSEUDO_ELEMENT_NONE; j < CSS_PSEUDO_ELEMENT_COUNT; j++) {
/* Skip non-existent pseudo elements */
if (state.results->styles[j] == NULL((void*)0))
	continue;

error = css__arena_intern_style(&state.results->styles[j]);
if (error != CSS_OK) {
	goto cleanup;
}
}

1510complete:
error = css__set_node_data(node, &state, handler, pw);
if (error != CSS_OK) {
goto cleanup;
}

/* Steal the results from the selection state, so they don't get
* freed when the selection state is finalised */
*result = state.results;
state.results = NULL((void*)0);

error = CSS_OK;

1523cleanup:
css_select__finalise_selection_state(&state);

return error;
1527}

1529/**
* Destroy a selection result set
*
* \param results  Result set to destroy
* \return CSS_OK on success, appropriate error otherwise
*/
1535css_error css_select_results_destroy(css_select_results *results)
1536{
uint32_t i;

if (results == NULL((void*)0))
return CSS_BADPARM;

for (i = 0; i < CSS_PSEUDO_ELEMENT_COUNT; i++) {
if (results->styles[i] != NULL((void*)0))
	css_computed_style_destroy(results->styles[i]);
}

free(results);

return CSS_OK;
1550}

1552/**
* Search a selection context for defined font faces
*
* \param ctx          Selection context
* \param media        Currently active media spec
* \param unit_ctx     Current unit conversion context.
* \param font_family  Font family to search for
* \param result       Pointer to location to receive result
* \return CSS_OK on success, appropriate error otherwise.
*/
1562css_error css_select_font_faces(css_select_ctx *ctx,
const css_media *media,
const css_unit_ctx *unit_ctx,
lwc_string *font_family,
css_select_font_faces_results **result)
1567{
uint32_t i;
css_error error;
css_select_font_faces_state state;
uint32_t n_font_faces;

if (ctx == NULL((void*)0) || font_family == NULL((void*)0) || result == NULL((void*)0))
return CSS_BADPARM;

memset(&state, 0, sizeof(css_select_font_faces_state));
state.font_family = font_family;
state.media = media;
state.unit_ctx = unit_ctx;

/* Iterate through the top-level stylesheets, selecting font-faces
* from those which apply to our current media requirements and
* are not disabled */
for (i = 0; i < ctx->n_sheets; i++) {
const css_select_sheet s = ctx->sheets[i];

if (mq__list_match(s.media, unit_ctx, media, &ctx->str) &&
		s.sheet->disabled == false0) {
	error = select_font_faces_from_sheet(s.sheet,
			s.origin, &state, &ctx->str);
	if (error != CSS_OK)
		goto cleanup;
}
}

n_font_faces = state.ua_font_faces.count +
	state.user_font_faces.count +
	state.author_font_faces.count;


if (n_font_faces > 0) {
/* We found some matching faces.  Make a results structure with
 * the font faces in priority order. */
css_select_font_faces_results *results;

results = malloc(sizeof(css_select_font_faces_results));
if (results == NULL((void*)0)) {
	error = CSS_NOMEM;
	goto cleanup;
}

results->font_faces = malloc(
		n_font_faces * sizeof(css_font_face *));
if (results->font_faces == NULL((void*)0)) {
	free(results);
	error = CSS_NOMEM;
	goto cleanup;
}

results->n_font_faces = n_font_faces;

i = 0;
if (state.ua_font_faces.count != 0) {
	memcpy(results->font_faces,
			state.ua_font_faces.font_faces,
			sizeof(css_font_face *) *
				state.ua_font_faces.count);

	i += state.ua_font_faces.count;
}

if (state.user_font_faces.count != 0) {
	memcpy(results->font_faces + i,
			state.user_font_faces.font_faces,
			sizeof(css_font_face *) *
				state.user_font_faces.count);
	i += state.user_font_faces.count;
}

if (state.author_font_faces.count != 0) {
	memcpy(results->font_faces + i,
			state.author_font_faces.font_faces,
			sizeof(css_font_face *) *
				state.author_font_faces.count);
}

*result = results;
}

error = CSS_OK;

1652cleanup:
if (state.ua_font_faces.count != 0)
free(state.ua_font_faces.font_faces);

if (state.user_font_faces.count != 0)
free(state.user_font_faces.font_faces);

if (state.author_font_faces.count != 0)
free(state.author_font_faces.font_faces);

return error;
1663}

1665/**
* Destroy a font-face result set
*
* \param results  Result set to destroy
* \return CSS_OK on success, appropriate error otherwise
*/
1671css_error css_select_font_faces_results_destroy(
css_select_font_faces_results *results)
1673{
if (results == NULL((void*)0))
return CSS_BADPARM;

if (results->font_faces != NULL((void*)0)) {
/* Don't destroy the individual css_font_faces, they're owned
   by their respective sheets */
free(results->font_faces);
}

free(results);

return CSS_OK;
1686}

1688/******************************************************************************
* Selection engine internals below here                                      *
******************************************************************************/


1693css_error set_hint(css_select_state *state, css_hint *hint)
1694{
uint32_t prop = hint->prop;
prop_state *existing = &state->props[prop][CSS_PSEUDO_ELEMENT_NONE];
css_error error;

/* Hint defined -- set it in the result */
error = prop_dispatch[prop].set_from_hint(hint, state->computed);
if (error != CSS_OK)
return error;

/* Keep selection state in sync with reality */
existing->set = 1;
existing->specificity = 0;
existing->origin = CSS_ORIGIN_AUTHOR;
existing->important = 0;
existing->explicit_default = (hint->status == 0) ?
	FLAG_VALUE_INHERIT : FLAG_VALUE__NONE;

return CSS_OK;
1713}

1715css_error set_initial(css_select_state *state,
uint32_t prop, css_pseudo_element pseudo,
void *parent)
1718{
css_error error;

/* Do nothing if this property is inherited (the default state
* of a clean computed style is for everything to be set to inherit)
*
* If the node is tree root and we're dealing with the base element,
* everything should be defaulted.
*/
if (state->props[prop][pseudo].explicit_default == FLAG_VALUE_INITIAL ||
	prop_dispatch[prop].inherited == false0 ||
	(pseudo == CSS_PSEUDO_ELEMENT_NONE && parent == NULL((void*)0))) {
error = prop_dispatch[prop].initial(state);
if (error != CSS_OK)
	return error;
}

return CSS_OK;
1736}

1738#define IMPORT_STACK_SIZE 256

1740css_error select_from_sheet(css_select_ctx *ctx, const css_stylesheet *sheet,
css_origin origin, css_select_state *state)
1742{
const css_stylesheet *s = sheet;
const css_rule *rule = s->rule_list;
uint32_t sp = 0;
const css_rule *import_stack[IMPORT_STACK_SIZE];

do {
/* Find first non-charset rule, if we're at the list head */
if (rule28.1
'rule' is equal to field 'rule_list'
 == s->rule_list) {
	while (rule != NULL((void*)0) && rule->type == CSS_RULE_CHARSET)
29
←
Assuming 'rule' is equal to NULL→
		rule = rule->next;
}

if (rule29.1
'rule' is equal to NULL
 != NULL((void*)0) && rule->type == CSS_RULE_IMPORT) {
	/* Current rule is an import */
	const css_rule_import *import =
			(const css_rule_import *) rule;

	if (import->sheet != NULL((void*)0) &&
			mq__list_match(import->media,
					state->unit_ctx,
					state->media,
					&ctx->str)) {
		/* It's applicable, so process it */
		if (sp >= IMPORT_STACK_SIZE)
			return CSS_NOMEM;

		import_stack[sp++] = rule;

		s = import->sheet;
		rule = s->rule_list;
	} else {
		/* Not applicable; skip over it */
		rule = rule->next;
	}
} else {
	/* Gone past import rules in this sheet */
	css_error error;

	/* Process this sheet */
	state->sheet = s;
	state->current_origin = origin;

	error = match_selectors_in_sheet(ctx, s, state);
30
←
Calling 'match_selectors_in_sheet'→
	if (error != CSS_OK)
		return error;

	/* Find next sheet to process */
	if (sp > 0) {
		sp--;
		rule = import_stack[sp]->next;
		s = import_stack[sp]->parent;
	} else {
		s = NULL((void*)0);
	}
}
} while (s != NULL((void*)0));

return CSS_OK;
1801}

1803static css_error _select_font_face_from_rule(
const css_rule_font_face *rule, css_origin origin,
css_select_font_faces_state *state,
const css_select_strings *str)
1807{
if (mq_rule_good_for_media((const css_rule *) rule,
	state->unit_ctx, state->media, str)) {
bool_Bool correct_family = false0;

if (lwc_string_isequal(((*(&correct_family) = ((rule->font_face->font_family
) == (state->font_family))), lwc_error_ok)
		rule->font_face->font_family,((*(&correct_family) = ((rule->font_face->font_family
) == (state->font_family))), lwc_error_ok)
		state->font_family,((*(&correct_family) = ((rule->font_face->font_family
) == (state->font_family))), lwc_error_ok)
		&correct_family)((*(&correct_family) = ((rule->font_face->font_family
) == (state->font_family))), lwc_error_ok) == lwc_error_ok &&
		correct_family) {
	css_select_font_faces_list *faces = NULL((void*)0);
	const css_font_face **new_faces;
	uint32_t index;
	size_t new_size;

	switch (origin) {
		case CSS_ORIGIN_UA:
			faces = &state->ua_font_faces;
			break;
		case CSS_ORIGIN_USER:
			faces = &state->user_font_faces;
			break;
		case CSS_ORIGIN_AUTHOR:
			faces = &state->author_font_faces;
			break;
	}

	index = faces->count++;
	new_size = faces->count * sizeof(css_font_face *);

	new_faces = realloc(faces->font_faces, new_size);
	if (new_faces == NULL((void*)0)) {
		return CSS_NOMEM;
	}
	faces->font_faces = new_faces;

	faces->font_faces[index] = rule->font_face;
}
}

return CSS_OK;
1848}

1850static css_error select_font_faces_from_sheet(
const css_stylesheet *sheet,
css_origin origin,
css_select_font_faces_state *state,
const css_select_strings *str)
1855{
const css_stylesheet *s = sheet;
const css_rule *rule = s->rule_list;
uint32_t sp = 0;
const css_rule *import_stack[IMPORT_STACK_SIZE];

do {
/* Find first non-charset rule, if we're at the list head */
if (rule == s->rule_list) {
	while (rule != NULL((void*)0) && rule->type == CSS_RULE_CHARSET)
		rule = rule->next;
}

if (rule != NULL((void*)0) && rule->type == CSS_RULE_IMPORT) {
	/* Current rule is an import */
	const css_rule_import *import =
			(const css_rule_import *) rule;

	if (import->sheet != NULL((void*)0) &&
			mq__list_match(import->media,
					state->unit_ctx,
					state->media,
					str)) {
		/* It's applicable, so process it */
		if (sp >= IMPORT_STACK_SIZE)
			return CSS_NOMEM;

		import_stack[sp++] = rule;

		s = import->sheet;
		rule = s->rule_list;
	} else {
		/* Not applicable; skip over it */
		rule = rule->next;
	}
} else if (rule != NULL((void*)0) && rule->type == CSS_RULE_FONT_FACE) {
	css_error error;

	error = _select_font_face_from_rule(
			(const css_rule_font_face *) rule,
			origin, state, str);

	if (error != CSS_OK)
		return error;

	rule = rule->next;
} else if (rule == NULL((void*)0)) {
	/* Find next sheet to process */
	if (sp > 0) {
		sp--;
		rule = import_stack[sp]->next;
		s = import_stack[sp]->parent;
	} else {
		s = NULL((void*)0);
	}
} else {
	rule = rule->next;
}
} while (s != NULL((void*)0));

return CSS_OK;
1916}

1918#undef IMPORT_STACK_SIZE

1920static inline bool_Bool _selectors_pending(const css_selector **node,
const css_selector **id, const css_selector ***classes,
uint32_t n_classes, const css_selector **univ)
1923{
bool_Bool pending = false0;
uint32_t i;

pending |= *node != NULL((void*)0);
pending |= *id != NULL((void*)0);
pending |= *univ != NULL((void*)0);

if (classes != NULL((void*)0) && n_classes > 0) {
for (i = 0; i < n_classes; i++)
	pending |= *(classes[i]) != NULL((void*)0);
}

return pending;
1937}

1939static inline bool_Bool _selector_less_specific(const css_selector *ref,
const css_selector *cand)
1941{
bool_Bool result = true1;

if (cand == NULL((void*)0))
return false0;

if (ref == NULL((void*)0))
return true1;

/* Sort by specificity */
if (cand->specificity < ref->specificity) {
result = true1;
} else if (ref->specificity < cand->specificity) {
result = false0;
} else {
/* Then by rule index -- earliest wins */
if (cand->rule->index < ref->rule->index)
	result = true1;
else
	result = false0;
}

return result;
1964}

1966static const css_selector *_selector_next(const css_selector **node,
const css_selector **id, const css_selector ***classes,
uint32_t n_classes, const css_selector **univ,
css_select_rule_source *src)
1970{
const css_selector *ret = NULL((void*)0);

if (_selector_less_specific(ret, *node)) {
39
←
Taking false branch→
ret = *node;
src->source = CSS_SELECT_RULE_SRC_ELEMENT;
}

if (_selector_less_specific(ret, *id)) {
40
←
Taking true branch→
ret = *id;
src->source = CSS_SELECT_RULE_SRC_ID;
41
←
The value 2 is assigned to 'src.source', which participates in a condition later→
}

if (_selector_less_specific(ret, *univ)) {
ret = *univ;
src->source = CSS_SELECT_RULE_SRC_UNIVERSAL;
}

if (classes41.1
'classes' is equal to NULL
 != NULL((void*)0) && n_classes > 0) {
uint32_t i;

for (i = 0; i < n_classes; i++) {
	if (_selector_less_specific(ret, *(classes[i]))) {
		ret = *(classes[i]);
		src->source = CSS_SELECT_RULE_SRC_CLASS;
		src->class = i;
	}
}
}

return ret;
2001}

2003css_error match_selectors_in_sheet(css_select_ctx *ctx,
const css_stylesheet *sheet, css_select_state *state)
2005{
static const css_selector *empty_selector = NULL((void*)0);
const uint32_t n_classes = state->n_classes;
uint32_t i = 0;
const css_selector **node_selectors = &empty_selector;
css_selector_hash_iterator node_iterator;
const css_selector **id_selectors = &empty_selector;
css_selector_hash_iterator id_iterator;
31
←
'id_iterator' declared without an initial value→
const css_selector ***class_selectors = NULL((void*)0);
css_selector_hash_iterator class_iterator;
const css_selector **univ_selectors = &empty_selector;
css_selector_hash_iterator univ_iterator;
css_select_rule_source src = { CSS_SELECT_RULE_SRC_ELEMENT, 0 };
struct css_hash_selection_requirments req;
css_error error;

/* Set up general selector chain requirments */
req.media = state->media;
req.unit_ctx = state->unit_ctx;
req.node_bloom = state->node_data->bloom;
req.str = &ctx->str;

/* Find hash chain that applies to current node */
req.qname = state->element;
error = css__selector_hash_find(sheet->selectors,
	&req, &node_iterator,
	&node_selectors);
if (error != CSS_OK)
32
←
Assuming 'error' is equal to CSS_OK→
goto cleanup;

if (state->classes != NULL((void*)0) && n_classes > 0) {
33
←
Assuming field 'classes' is equal to NULL→
/* Find hash chains for node classes */
class_selectors = malloc(n_classes * sizeof(css_selector **));
if (class_selectors == NULL((void*)0)) {
	error = CSS_NOMEM;
	goto cleanup;
}

for (i = 0; i < n_classes; i++) {
	req.class = state->classes[i];
	error = css__selector_hash_find_by_class(
			sheet->selectors, &req,
			&class_iterator, &class_selectors[i]);
	if (error != CSS_OK)
		goto cleanup;
}
}

if (state->id33.1
Field 'id' is equal to NULL
 != NULL((void*)0)) {
34
←
Taking false branch→
/* Find hash chain for node ID */
req.id = state->id;
error = css__selector_hash_find_by_id(sheet->selectors,
		&req, &id_iterator, &id_selectors);
if (error != CSS_OK)
	goto cleanup;
}

/* Find hash chain for universal selector */
error = css__selector_hash_find_universal(sheet->selectors, &req,
	&univ_iterator, &univ_selectors);
if (error != CSS_OK)
35
←
Assuming 'error' is equal to CSS_OK→
36
←
Taking false branch→
goto cleanup;

/* Process matching selectors, if any */
while (_selectors_pending(node_selectors, id_selectors,
37
←
Loop condition is true.  Entering loop body→
	class_selectors, n_classes, univ_selectors)) {
const css_selector *selector;

/* Selectors must be matched in ascending order of specificity
 * and rule index. (c.f. css__outranks_existing())
 *
 * Pick the least specific/earliest occurring selector.
 */
selector = _selector_next(node_selectors, id_selectors,
38
←
Calling '_selector_next'→
42
←
Returning from '_selector_next'→
		class_selectors, n_classes, univ_selectors,
		&src);

/* We know there are selectors pending, so should have a
 * selector here */
assert(selector != NULL)((selector != ((void*)0)) ? (void) (0) : __assert_fail ("selector != NULL"
, "src/select/select.c", 2084, __extension__ __PRETTY_FUNCTION__
));
43
←
'?' condition is true→

/* Match and handle the selector chain */
error = match_selector_chain(ctx, selector, state);
if (error43.1
'error' is equal to CSS_OK
 != CSS_OK)
44
←
Taking false branch→
	goto cleanup;

/* Advance to next selector in whichever chain we extracted
 * the processed selector from. */
switch (src.source) {
45
←
Control jumps to 'case CSS_SELECT_RULE_SRC_ID:'  at line 2099→
case CSS_SELECT_RULE_SRC_ELEMENT:
	error = node_iterator(&req, node_selectors,
			&node_selectors);
	break;

case CSS_SELECT_RULE_SRC_ID:
	error = id_iterator(&req, id_selectors,
46
←
Called function pointer is an uninitialized pointer value
			&id_selectors);
	break;

case CSS_SELECT_RULE_SRC_UNIVERSAL:
	error = univ_iterator(&req, univ_selectors,
			&univ_selectors);
	break;

case CSS_SELECT_RULE_SRC_CLASS:
	req.class = state->classes[src.class];
	error = class_iterator(&req, class_selectors[src.class],
			&class_selectors[src.class]);
	break;
}

if (error != CSS_OK)
	goto cleanup;
}

error = CSS_OK;
2121cleanup:
if (class_selectors != NULL((void*)0))
free(class_selectors);

return error;
2126}

2128static void update_reject_cache(css_select_state *state,
css_combinator comb, const css_selector *s)
2130{
const css_selector_detail *detail = &s->data;
const css_selector_detail *next_detail = NULL((void*)0);

if (detail->next)
next_detail = detail + 1;

if (state->next_reject < state->reject_cache ||
	comb != CSS_COMBINATOR_ANCESTOR ||
	next_detail == NULL((void*)0) ||
	next_detail->next != 0 ||
	(next_detail->type != CSS_SELECTOR_CLASS &&
	 next_detail->type != CSS_SELECTOR_ID))
return;

/* Insert */
state->next_reject->type = next_detail->type;
state->next_reject->value = next_detail->qname.name;
state->next_reject--;
2149}

2151css_error match_selector_chain(css_select_ctx *ctx,
const css_selector *selector, css_select_state *state)
2153{
const css_selector *s = selector;
void *node = state->node;
const css_selector_detail *detail = &s->data;
bool_Bool match = false0, may_optimise = true1;
bool_Bool rejected_by_cache;
css_pseudo_element pseudo;
css_error error;

2162#ifdef DEBUG_CHAIN_MATCHING
fprintf(stderrstderr, "matching: ");
dump_chain(selector);
fprintf(stderrstderr, "\n");
2166#endif

/* Match the details of the first selector in the chain.
*
* Note that pseudo elements will only appear as details of
* the first selector in the chain, as the parser will reject
* any selector chains containing pseudo elements anywhere
* else.
*/
error = match_details(ctx, node, detail, state, &match, &pseudo);
if (error != CSS_OK)
return error;

/* Details don't match, so reject selector chain */
if (match == false0)
return CSS_OK;

/* Iterate up the selector chain, matching combinators */
do {
void *next_node = NULL((void*)0);

/* Consider any combinator on this selector */
if (s->data.comb != CSS_COMBINATOR_NONE &&
		s->combinator->data.qname.name !=
			ctx->str.universal) {
	/* Named combinator */
	may_optimise &=
		(s->data.comb == CSS_COMBINATOR_ANCESTOR ||
		 s->data.comb == CSS_COMBINATOR_PARENT);

	error = match_named_combinator(ctx, s->data.comb,
			s->combinator, state, node, &next_node);
	if (error != CSS_OK)
		return error;

	/* No match for combinator, so reject selector chain */
	if (next_node == NULL((void*)0))
		return CSS_OK;
} else if (s->data.comb != CSS_COMBINATOR_NONE) {
	/* Universal combinator */
	may_optimise &=
		(s->data.comb == CSS_COMBINATOR_ANCESTOR ||
		 s->data.comb == CSS_COMBINATOR_PARENT);

	error = match_universal_combinator(ctx, s->data.comb,
			s->combinator, state, node,
			may_optimise, &rejected_by_cache,
			&next_node);
	if (error != CSS_OK)
		return error;

	/* No match for combinator, so reject selector chain */
	if (next_node == NULL((void*)0)) {
		if (may_optimise && s == selector &&
				rejected_by_cache == false0) {
			update_reject_cache(state, s->data.comb,
					s->combinator);
		}

		return CSS_OK;
	}
}

/* Details matched, so progress to combining selector */
s = s->combinator;
node = next_node;
} while (s != NULL((void*)0));

/* If we got here, then the entire selector chain matched, so cascade */
state->current_specificity = selector->specificity;

/* Ensure that the appropriate computed style exists */
if (state->results->styles[pseudo] == NULL((void*)0)) {
error = css__computed_style_create(
		&state->results->styles[pseudo], ctx->calc);
if (error != CSS_OK)
	return error;
}

state->current_pseudo = pseudo;
state->computed = state->results->styles[pseudo];

return cascade_style(((css_rule_selector *) selector->rule)->style,
	state);
2250}

2252css_error match_named_combinator(css_select_ctx *ctx, css_combinator type,
const css_selector *selector, css_select_state *state,
void *node, void **next_node)
2255{
const css_selector_detail *detail = &selector->data;
void *n = node;
css_error error;

do {
bool_Bool match = false0;

/* Find candidate node */
switch (type) {
case CSS_COMBINATOR_ANCESTOR:
	error = state->handler->named_ancestor_node(state->pw,
			n, &selector->data.qname, &n);
	if (error != CSS_OK)
		return error;
	break;
case CSS_COMBINATOR_PARENT:
	error = state->handler->named_parent_node(state->pw,
			n, &selector->data.qname, &n);
	if (error != CSS_OK)
		return error;
	break;
case CSS_COMBINATOR_SIBLING:
	error = state->handler->named_sibling_node(state->pw,
			n, &selector->data.qname, &n);
	if (error != CSS_OK)
		return error;
	if (node == state->node) {
		state->node_data->flags |=
				CSS_NODE_FLAGS_TAINT_SIBLING;
	}
	break;
case CSS_COMBINATOR_GENERIC_SIBLING:
	error = state->handler->named_generic_sibling_node(
			state->pw, n, &selector->data.qname,
			&n);
	if (error != CSS_OK)
		return error;
	if (node == state->node) {
		state->node_data->flags |=
				CSS_NODE_FLAGS_TAINT_SIBLING;
	}
case CSS_COMBINATOR_NONE:
	break;
}

if (n != NULL((void*)0)) {
	/* Match its details */
	error = match_details(ctx, n, detail, state,
			&match, NULL((void*)0));
	if (error != CSS_OK)
		return error;

	/* If we found a match, use it */
	if (match == true1)
		break;

	/* For parent and sibling selectors, only adjacent
	 * nodes are valid. Thus, if we failed to match,
	 * give up. */
	if (type == CSS_COMBINATOR_PARENT ||
			type == CSS_COMBINATOR_SIBLING)
		n = NULL((void*)0);
}
} while (n != NULL((void*)0));

*next_node = n;

return CSS_OK;
2324}

2326static inline void add_node_flags(const void *node,
const css_select_state *state, css_node_flags flags)
2328{
/* If the node in question is the node we're selecting for then its
* style has been tainted by particular rules that affect whether the
* node's style can be shared.  We don't care whether the rule matched
* or not, just that such a rule has been considered. */
if (node == state->node) {
state->node_data->flags |= flags;
}
2336}

2338css_error match_universal_combinator(css_select_ctx *ctx, css_combinator type,
const css_selector *selector, css_select_state *state,
void *node, bool_Bool may_optimise, bool_Bool *rejected_by_cache,
void **next_node)
2342{
const css_selector_detail *detail = &selector->data;
const css_selector_detail *next_detail = NULL((void*)0);
void *n = node;
css_error error;

if (detail->next)
next_detail = detail + 1;

*rejected_by_cache = false0;

/* Consult reject cache first */
if (may_optimise && (type == CSS_COMBINATOR_ANCESTOR ||
	     type == CSS_COMBINATOR_PARENT) &&
	next_detail != NULL((void*)0) &&
	(next_detail->type == CSS_SELECTOR_CLASS ||
	 next_detail->type == CSS_SELECTOR_ID)) {
reject_item *reject = state->next_reject + 1;
reject_item *last = state->reject_cache +
		N_ELEMENTS(state->reject_cache)(sizeof((state->reject_cache)) / sizeof((state->reject_cache
)[0])) - 1;
bool_Bool match = false0;

while (reject <= last) {
	/* Perform pessimistic matching (may hurt quirks) */
	if (reject->type == next_detail->type &&
			lwc_string_isequal(reject->value,((*(&match) = ((reject->value) == (next_detail->qname
.name))), lwc_error_ok)
				next_detail->qname.name,((*(&match) = ((reject->value) == (next_detail->qname
.name))), lwc_error_ok)
				&match)((*(&match) = ((reject->value) == (next_detail->qname
.name))), lwc_error_ok) == lwc_error_ok &&
		 	match) {
		/* Found it: can't match */
		*next_node = NULL((void*)0);
		*rejected_by_cache = true1;
		return CSS_OK;
	}

	reject++;
}
}

do {
bool_Bool match = false0;

/* Find candidate node */
switch (type) {
case CSS_COMBINATOR_ANCESTOR:
case CSS_COMBINATOR_PARENT:
	error = state->handler->parent_node(state->pw, n, &n);
	if (error != CSS_OK)
		return error;
	break;
case CSS_COMBINATOR_SIBLING:
case CSS_COMBINATOR_GENERIC_SIBLING:
	error = state->handler->sibling_node(state->pw, n, &n);
	if (error != CSS_OK)
		return error;
	add_node_flags(node, state,
			CSS_NODE_FLAGS_TAINT_SIBLING);
	break;
case CSS_COMBINATOR_NONE:
	break;
}

if (n != NULL((void*)0)) {
	/* Match its details */
	error = match_details(ctx, n, detail, state,
			&match, NULL((void*)0));
	if (error != CSS_OK)
		return error;

	/* If we found a match, use it */
	if (match == true1)
		break;

	/* For parent and sibling selectors, only adjacent
	 * nodes are valid. Thus, if we failed to match,
	 * give up. */
	if (type == CSS_COMBINATOR_PARENT ||
			type == CSS_COMBINATOR_SIBLING)
		n = NULL((void*)0);
}
} while (n != NULL((void*)0));

*next_node = n;

return CSS_OK;
2427}

2429css_error match_details(css_select_ctx *ctx, void *node,
const css_selector_detail *detail, css_select_state *state,
bool_Bool *match, css_pseudo_element *pseudo_element)
2432{
css_error error;
css_pseudo_element pseudo = CSS_PSEUDO_ELEMENT_NONE;

/* Skip the element selector detail, which is always first.
* (Named elements are handled by match_named_combinator, so the
* element selector detail always matches here.) */
if (detail->next)
detail++;
else
detail = NULL((void*)0);

/* We match by default (if there are no details other than the element
* selector, then we must match) */
*match = true1;

/** \todo Some details are easier to test than others (e.g. dashmatch
* actually requires looking at data rather than simply comparing
* pointers). Should we consider sorting the detail list such that the
* simpler details come first (and thus the expensive match routines
* can be avoided unless absolutely necessary)? */

while (detail != NULL((void*)0)) {
error = match_detail(ctx, node, detail, state, match, &pseudo);
if (error != CSS_OK)
	return error;

/* Detail doesn't match, so reject selector chain */
if (*match == false0)
	return CSS_OK;

if (detail->next)
	detail++;
else
	detail = NULL((void*)0);
}

/* Return the applicable pseudo element, if required */
if (pseudo_element != NULL((void*)0))
*pseudo_element = pseudo;

return CSS_OK;
2474}

2476static inline bool_Bool match_nth(int32_t a, int32_t b, int32_t count)
2477{
if (a == 0) {
return count == b;
} else {
const int32_t delta = count - b;

/* (count - b) / a is positive or (count - b) is 0 */
if (((delta > 0) == (a > 0)) || delta == 0) {
	/* (count - b) / a is integer */
	return (delta % a == 0);
}

return false0;
}
2491}

2493css_error match_detail(css_select_ctx *ctx, void *node,
const css_selector_detail *detail, css_select_state *state,
bool_Bool *match, css_pseudo_element *pseudo_element)
2496{
bool_Bool is_root = false0;
css_error error = CSS_OK;
css_node_flags flags = CSS_NODE_FLAGS_TAINT_PSEUDO_CLASS;

switch (detail->type) {
case CSS_SELECTOR_ELEMENT:
if (detail->negate != 0) {
	/* Only need to test this inside not(), since
	 * it will have been considered as a named node
	 * otherwise. */
	error = state->handler->node_has_name(state->pw, node,
			&detail->qname, match);
}
break;
case CSS_SELECTOR_CLASS:
error = state->handler->node_has_class(state->pw, node,
		detail->qname.name, match);
break;
case CSS_SELECTOR_ID:
error = state->handler->node_has_id(state->pw, node,
		detail->qname.name, match);
break;
case CSS_SELECTOR_PSEUDO_CLASS:
error = state->handler->node_is_root(state->pw, node, &is_root);
if (error != CSS_OK)
	return error;

if (is_root == false0 &&
		detail->qname.name == ctx->str.first_child) {
	int32_t num_before = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, false0, false0, &num_before);
	if (error == CSS_OK)
		*match = (num_before == 0);
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.nth_child) {
	int32_t num_before = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, false0, false0, &num_before);
	if (error == CSS_OK) {
		int32_t a = detail->value.nth.a;
		int32_t b = detail->value.nth.b;

		*match = match_nth(a, b, num_before + 1);
	}
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.nth_last_child) {
	int32_t num_after = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, false0, true1, &num_after);
	if (error == CSS_OK) {
		int32_t a = detail->value.nth.a;
		int32_t b = detail->value.nth.b;

		*match = match_nth(a, b, num_after + 1);
	}
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.nth_of_type) {
	int32_t num_before = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, true1, false0, &num_before);
	if (error == CSS_OK) {
		int32_t a = detail->value.nth.a;
		int32_t b = detail->value.nth.b;

		*match = match_nth(a, b, num_before + 1);
	}
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.nth_last_of_type) {
	int32_t num_after = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, true1, true1, &num_after);
	if (error == CSS_OK) {
		int32_t a = detail->value.nth.a;
		int32_t b = detail->value.nth.b;

		*match = match_nth(a, b, num_after + 1);
	}
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.last_child) {
	int32_t num_after = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, false0, true1, &num_after);
	if (error == CSS_OK)
		*match = (num_after == 0);
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.first_of_type) {
	int32_t num_before = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, true1, false0, &num_before);
	if (error == CSS_OK)
		*match = (num_before == 0);
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.last_of_type) {
	int32_t num_after = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, true1, true1, &num_after);
	if (error == CSS_OK)
		*match = (num_after == 0);
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.only_child) {
	int32_t num_before = 0, num_after = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, false0, false0, &num_before);
	if (error == CSS_OK) {
		error = state->handler->node_count_siblings(
				state->pw, node, false0, true1,
				&num_after);
		if (error == CSS_OK)
			*match = (num_before == 0) &&
					(num_after == 0);
	}
} else if (is_root == false0 &&
		detail->qname.name == ctx->str.only_of_type) {
	int32_t num_before = 0, num_after = 0;

	error = state->handler->node_count_siblings(state->pw,
			node, true1, false0, &num_before);
	if (error == CSS_OK) {
		error = state->handler->node_count_siblings(
				state->pw, node, true1, true1,
				&num_after);
		if (error == CSS_OK)
			*match = (num_before == 0) &&
					(num_after == 0);
	}
} else if (detail->qname.name == ctx->str.root) {
	*match = is_root;
} else if (detail->qname.name == ctx->str.empty) {
	error = state->handler->node_is_empty(state->pw,
			node, match);
} else if (detail->qname.name == ctx->str.link) {
	error = state->handler->node_is_link(state->pw,
			node, match);
	flags = CSS_NODE_FLAGS_NONE;
} else if (detail->qname.name == ctx->str.visited) {
	error = state->handler->node_is_visited(state->pw,
			node, match);
	flags = CSS_NODE_FLAGS_NONE;
} else if (detail->qname.name == ctx->str.hover) {
	error = state->handler->node_is_hover(state->pw,
			node, match);
	flags = CSS_NODE_FLAGS_NONE;
} else if (detail->qname.name == ctx->str.active) {
	error = state->handler->node_is_active(state->pw,
			node, match);
	flags = CSS_NODE_FLAGS_NONE;
} else if (detail->qname.name == ctx->str.focus) {
	error = state->handler->node_is_focus(state->pw,
			node, match);
	flags = CSS_NODE_FLAGS_NONE;
} else if (detail->qname.name == ctx->str.target) {
	error = state->handler->node_is_target(state->pw,
			node, match);
} else if (detail->qname.name == ctx->str.lang) {
	error = state->handler->node_is_lang(state->pw,
			node, detail->value.string, match);
} else if (detail->qname.name == ctx->str.enabled) {
	error = state->handler->node_is_enabled(state->pw,
			node, match);
} else if (detail->qname.name == ctx->str.disabled) {
	error = state->handler->node_is_disabled(state->pw,
			node, match);
} else if (detail->qname.name == ctx->str.checked) {
	error = state->handler->node_is_checked(state->pw,
			node, match);
} else {
	*match = false0;
}
add_node_flags(node, state, flags);
break;
case CSS_SELECTOR_PSEUDO_ELEMENT:
*match = true1;

if (detail->qname.name == ctx->str.first_line) {
	*pseudo_element = CSS_PSEUDO_ELEMENT_FIRST_LINE;
} else if (detail->qname.name == ctx->str.first_letter) {
	*pseudo_element = CSS_PSEUDO_ELEMENT_FIRST_LETTER;
} else if (detail->qname.name == ctx->str.before) {
	*pseudo_element = CSS_PSEUDO_ELEMENT_BEFORE;
} else if (detail->qname.name == ctx->str.after) {
	*pseudo_element = CSS_PSEUDO_ELEMENT_AFTER;
} else
	*match = false0;
break;
case CSS_SELECTOR_ATTRIBUTE:
error = state->handler->node_has_attribute(state->pw, node,
		&detail->qname, match);
add_node_flags(node, state, CSS_NODE_FLAGS_TAINT_ATTRIBUTE);
break;
case CSS_SELECTOR_ATTRIBUTE_EQUAL:
error = state->handler->node_has_attribute_equal(state->pw,
		node, &detail->qname, detail->value.string,
		match);
add_node_flags(node, state, CSS_NODE_FLAGS_TAINT_ATTRIBUTE);
break;
case CSS_SELECTOR_ATTRIBUTE_DASHMATCH:
error = state->handler->node_has_attribute_dashmatch(state->pw,
		node, &detail->qname, detail->value.string,
		match);
add_node_flags(node, state, CSS_NODE_FLAGS_TAINT_ATTRIBUTE);
break;
case CSS_SELECTOR_ATTRIBUTE_INCLUDES:
error = state->handler->node_has_attribute_includes(state->pw,
		node, &detail->qname, detail->value.string,
		match);
add_node_flags(node, state, CSS_NODE_FLAGS_TAINT_ATTRIBUTE);
break;
case CSS_SELECTOR_ATTRIBUTE_PREFIX:
error = state->handler->node_has_attribute_prefix(state->pw,
		node, &detail->qname, detail->value.string,
		match);
add_node_flags(node, state, CSS_NODE_FLAGS_TAINT_ATTRIBUTE);
break;
case CSS_SELECTOR_ATTRIBUTE_SUFFIX:
error = state->handler->node_has_attribute_suffix(state->pw,
		node, &detail->qname, detail->value.string,
		match);
add_node_flags(node, state, CSS_NODE_FLAGS_TAINT_ATTRIBUTE);
break;
case CSS_SELECTOR_ATTRIBUTE_SUBSTRING:
error = state->handler->node_has_attribute_substring(state->pw,
		node, &detail->qname, detail->value.string,
		match);
add_node_flags(node, state, CSS_NODE_FLAGS_TAINT_ATTRIBUTE);
break;
}

/* Invert match, if the detail requests it */
if (error == CSS_OK && detail->negate != 0)
*match = !*match;

return error;
2739}

2741css_error cascade_style(const css_style *style, css_select_state *state)
2742{
css_style s = *style;

while (s.used > 0) {
opcode_t op;
css_error error;
css_code_t opv = *s.bytecode;

advance_bytecode(&s, sizeof(opv));

op = getOpcode(opv);

error = prop_dispatch[op].cascade(opv, &s, state);
if (error != CSS_OK)
	return error;
}

return CSS_OK;
2760}

2762bool_Bool css__outranks_existing(uint16_t op, bool_Bool important, css_select_state *state,
enum flag_value explicit_default)
2764{
prop_state *existing = &state->props[op][state->current_pseudo];
bool_Bool outranks = false0;

/* Sorting on origin & importance gives the following:
*
*           | UA, - | UA, i | USER, - | USER, i | AUTHOR, - | AUTHOR, i
*           |----------------------------------------------------------
* UA    , - |   S       S       Y          Y         Y           Y
* UA    , i |   S       S       Y          Y         Y           Y
* USER  , - |   -       -       S          Y         Y           Y
* USER  , i |   -       -       -          S         -           -
* AUTHOR, - |   -       -       -          Y         S           Y
* AUTHOR, i |   -       -       -          Y         -           S
*
* Where the columns represent the origin/importance of the property
* being considered and the rows represent the origin/importance of
* the existing property.
*
* - means that the existing property must be preserved
* Y means that the new property must be applied
* S means that the specificities of the rules must be considered.
*
* If specificities are considered, the highest specificity wins.
* If specificities are equal, then the rule defined last wins.
*
* We have no need to explicitly consider the ordering of rules if
* the specificities are the same because:
*
* a) We process stylesheets in order
* b) The selector hash chains within a sheet are ordered such that
*    more specific rules come after less specific ones and, when
*    specificities are identical, rules defined later occur after
*    those defined earlier.
*
* Therefore, where we consider specificity, below, the property
* currently being considered will always be applied if its specificity
* is greater than or equal to that of the existing property.
*/

if (existing->set == 0) {
/* Property hasn't been set before, new one wins */
outranks = true1;
} else {
assert(CSS_ORIGIN_UA < CSS_ORIGIN_USER)((CSS_ORIGIN_UA < CSS_ORIGIN_USER) ? (void) (0) : __assert_fail
 ("CSS_ORIGIN_UA < CSS_ORIGIN_USER", "src/select/select.c"
, 2808, __extension__ __PRETTY_FUNCTION__));
assert(CSS_ORIGIN_USER < CSS_ORIGIN_AUTHOR)((CSS_ORIGIN_USER < CSS_ORIGIN_AUTHOR) ? (void) (0) : __assert_fail
 ("CSS_ORIGIN_USER < CSS_ORIGIN_AUTHOR", "src/select/select.c"
, 2809, __extension__ __PRETTY_FUNCTION__));

if (existing->origin < state->current_origin) {
	/* New origin has more weight than existing one.
	 * Thus, new property wins, except when the existing
	 * one is USER, i. */
	if (existing->important == 0 ||
			existing->origin != CSS_ORIGIN_USER) {
		outranks = true1;
	}
} else if (existing->origin == state->current_origin) {
	/* Origins are identical, consider importance, except
	 * for UA stylesheets, when specificity is always
	 * considered (as importance is meaningless) */
	if (existing->origin == CSS_ORIGIN_UA) {
		if (state->current_specificity >=
				existing->specificity) {
			outranks = true1;
		}
	} else if (existing->important == 0 && important) {
		/* New is more important than old. */
		outranks = true1;
	} else if (existing->important && important == false0) {
		/* Old is more important than new */
	} else {
		/* Same importance, consider specificity */
		if (state->current_specificity >=
				existing->specificity) {
			outranks = true1;
		}
	}
} else {
	/* Existing origin has more weight than new one.
	 * Thus, existing property wins, except when the new
	 * one is USER, i. */
	if (state->current_origin == CSS_ORIGIN_USER &&
			important) {
		outranks = true1;
	}
}
}

if (outranks) {
/* The new property is about to replace the old one.
 * Update our state to reflect this. */
existing->set = 1;
existing->specificity = state->current_specificity;
existing->origin = state->current_origin;
existing->important = important;
existing->explicit_default = explicit_default;
}

return outranks;
2862}

2864/******************************************************************************
* Debug helpers                                                              *
******************************************************************************/
2867#ifdef DEBUG_CHAIN_MATCHING
2868void dump_chain(const css_selector *selector)
2869{
const css_selector_detail *detail = &selector->data;

if (selector->data.comb != CSS_COMBINATOR_NONE)
dump_chain(selector->combinator);

if (selector->data.comb == CSS_COMBINATOR_ANCESTOR)
fprintf(stderrstderr, " ");
else if (selector->data.comb == CSS_COMBINATOR_SIBLING)
fprintf(stderrstderr, " + ");
else if (selector->data.comb == CSS_COMBINATOR_PARENT)
fprintf(stderrstderr, " > ");

do {
switch (detail->type) {
case CSS_SELECTOR_ELEMENT:
	if (lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2885, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}) == 1 &&
		lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2886, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
)[0] == '*' &&
			detail->next == 1) {
		break;
	}
	fprintf(stderrstderr, "%.*s",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2891, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2892, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
));
	break;
case CSS_SELECTOR_CLASS:
	fprintf(stderrstderr, ".%.*s",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2896, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2897, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
));
	break;
case CSS_SELECTOR_ID:
	fprintf(stderrstderr, "#%.*s",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2901, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2902, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
));
	break;
case CSS_SELECTOR_PSEUDO_CLASS:
case CSS_SELECTOR_PSEUDO_ELEMENT:
	fprintf(stderrstderr, ":%.*s",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2907, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2908, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
));

	if (detail->value != NULL((void*)0)) {
		fprintf(stderrstderr, "(%.*s)",
			(int) lwc_string_length(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2912, __extension__
 __PRETTY_FUNCTION__)); (detail->value)->len;}),
			lwc_string_data(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2913, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->value)+1);
}));
	}
	break;
case CSS_SELECTOR_ATTRIBUTE:
	fprintf(stderrstderr, "[%.*s]",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2918, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2919, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
));
	break;
case CSS_SELECTOR_ATTRIBUTE_EQUAL:
	fprintf(stderrstderr, "[%.*s=\"%.*s\"]",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2923, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2924, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
),
			(int) lwc_string_length(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2925, __extension__
 __PRETTY_FUNCTION__)); (detail->value)->len;}),
			lwc_string_data(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2926, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->value)+1);
}));
	break;
case CSS_SELECTOR_ATTRIBUTE_DASHMATCH:
	fprintf(stderrstderr, "[%.*s|=\"%.*s\"]",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2930, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2931, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
),
			(int) lwc_string_length(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2932, __extension__
 __PRETTY_FUNCTION__)); (detail->value)->len;}),
			lwc_string_data(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2933, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->value)+1);
}));
	break;
case CSS_SELECTOR_ATTRIBUTE_INCLUDES:
	fprintf(stderrstderr, "[%.*s~=\"%.*s\"]",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2937, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2938, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
),
			(int) lwc_string_length(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2939, __extension__
 __PRETTY_FUNCTION__)); (detail->value)->len;}),
			lwc_string_data(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2940, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->value)+1);
}));
	break;
case CSS_SELECTOR_ATTRIBUTE_PREFIX:
	fprintf(stderrstderr, "[%.*s^=\"%.*s\"]",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2944, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2945, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
),
			(int) lwc_string_length(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2946, __extension__
 __PRETTY_FUNCTION__)); (detail->value)->len;}),
			lwc_string_data(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2947, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->value)+1);
}));
	break;
case CSS_SELECTOR_ATTRIBUTE_SUFFIX:
	fprintf(stderrstderr, "[%.*s$=\"%.*s\"]",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2951, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2952, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
),
			(int) lwc_string_length(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2953, __extension__
 __PRETTY_FUNCTION__)); (detail->value)->len;}),
			lwc_string_data(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2954, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->value)+1);
}));
	break;
case CSS_SELECTOR_ATTRIBUTE_SUBSTRING:
	fprintf(stderrstderr, "[%.*s*=\"%.*s\"]",
			(int) lwc_string_length(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2958, __extension__
 __PRETTY_FUNCTION__)); (detail->name)->len;}),
			lwc_string_data(detail->name)({((detail->name != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->name != NULL", "src/select/select.c", 2959, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->name)+1);}
),
			(int) lwc_string_length(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2960, __extension__
 __PRETTY_FUNCTION__)); (detail->value)->len;}),
			lwc_string_data(detail->value)({((detail->value != ((void*)0)) ? (void) (0) : __assert_fail
 ("detail->value != NULL", "src/select/select.c", 2961, __extension__
 __PRETTY_FUNCTION__)); (const char *)((detail->value)+1);
}));
	break;
}

if (detail->next)
	detail++;
else
	detail = NULL((void*)0);
} while (detail);
2970}
2971#endif
