/** * Trigger parsing of generic (R)CDATA * * \param treebuilder The treebuilder instance * \param token The current token * \param rcdata True for RCDATA, false for CDATA * \return HUBBUB_OK on success, appropriate error otherwise */ hubbub_error parse_generic_rcdata(hubbub_treebuilder *treebuilder, const hubbub_token *token, bool rcdata) { hubbub_error error; element_type type; type = element_type_from_name(treebuilder, &token->data.tag.name); error = insert_element(treebuilder, &token->data.tag, true); if (error != HUBBUB_OK) return error; //params.content_model.model = rcdata ? HUBBUB_CONTENT_MODEL_RCDATA // : HUBBUB_CONTENT_MODEL_CDATA; //error = treebuilder->tokeniser ? hubbub_tokeniser_setopt(treebuilder->tokeniser, // HUBBUB_TOKENISER_CONTENT_MODEL, ¶ms) : HUBBUB_OK; treebuilder->context.collect.mode = treebuilder->context.mode; treebuilder->context.collect.type = type; treebuilder->context.mode = GENERIC_RCDATA; return HUBBUB_OK; }
/** * Handle token in "in table" insertion mode * * \param treebuilder The treebuilder instance * \param token The token to handle * \return True to reprocess token, false otherwise */ hubbub_error handle_in_table(hubbub_treebuilder *treebuilder, const hubbub_token *token) { hubbub_error err = HUBBUB_OK; bool handled = true; switch (token->type) { case HUBBUB_TOKEN_CHARACTER: if (treebuilder->context.element_stack[ current_table(treebuilder) ].tainted) { handled = false; } else { err = process_characters_expect_whitespace( treebuilder, token, true); handled = (err == HUBBUB_OK); } break; case HUBBUB_TOKEN_COMMENT: err = process_comment_append(treebuilder, token, treebuilder->context.element_stack[ treebuilder->context.current_node].node); break; case HUBBUB_TOKEN_DOCTYPE: /** \todo parse error */ break; case HUBBUB_TOKEN_START_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); bool tainted = treebuilder->context.element_stack[ current_table(treebuilder) ].tainted; if (type == CAPTION) { clear_stack_table_context(treebuilder); treebuilder->tree_handler->ref_node( treebuilder->tree_handler->ctx, treebuilder->context.element_stack[ treebuilder->context.current_node].node); err = formatting_list_append(treebuilder, token->data.tag.ns, type, treebuilder->context.element_stack[ treebuilder->context.current_node].node, treebuilder->context.current_node); if (err != HUBBUB_OK) { treebuilder->tree_handler->unref_node( treebuilder->tree_handler->ctx, treebuilder->context.element_stack[ treebuilder->context.current_node].node); return err; } err = insert_element(treebuilder, &token->data.tag, true); if (err != HUBBUB_OK) { hubbub_ns ns; element_type type; void *node; uint32_t index; formatting_list_remove(treebuilder, treebuilder->context.formatting_list_end, &ns, &type, &node, &index); treebuilder->tree_handler->unref_node( treebuilder->tree_handler->ctx, node); return err; } treebuilder->context.mode = IN_CAPTION; } else if (type == COLGROUP || type == COL) { hubbub_error e; hubbub_tag tag = token->data.tag; if (type == COL) { /* Insert colgroup and reprocess */ tag.name.ptr = (const uint8_t *) "colgroup"; tag.name.len = SLEN("colgroup"); tag.n_attributes = 0; tag.attributes = NULL; err = HUBBUB_REPROCESS; } clear_stack_table_context(treebuilder); e = insert_element(treebuilder, &tag, true); if (e != HUBBUB_OK) return e; treebuilder->context.mode = IN_COLUMN_GROUP; } else if (type == TBODY || type == TFOOT || type == THEAD || type == TD || type == TH || type == TR) { hubbub_error e; hubbub_tag tag = token->data.tag; if (type == TD || type == TH || type == TR) { /* Insert tbody and reprocess */ tag.name.ptr = (const uint8_t *) "tbody"; tag.name.len = SLEN("tbody"); tag.n_attributes = 0; tag.attributes = NULL; err = HUBBUB_REPROCESS; } clear_stack_table_context(treebuilder); e = insert_element(treebuilder, &tag, true); if (e != HUBBUB_OK) return e; treebuilder->context.mode = IN_TABLE_BODY; } else if (type == TABLE) { /** \todo parse error */ /* This should match "</table>" handling */ element_stack_pop_until(treebuilder, TABLE); reset_insertion_mode(treebuilder); err = HUBBUB_REPROCESS; } else if (!tainted && (type == STYLE || type == SCRIPT)) { err = handle_in_head(treebuilder, token); } else if (!tainted && type == INPUT) { err = process_input_in_table(treebuilder, token); handled = (err == HUBBUB_OK); } else { handled = false; } } break; case HUBBUB_TOKEN_END_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == TABLE) { /** \todo fragment case */ element_stack_pop_until(treebuilder, TABLE); reset_insertion_mode(treebuilder); } else if (type == BODY || type == CAPTION || type == COL || type == COLGROUP || type == HTML || type == TBODY || type == TD || type == TFOOT || type == TH || type == THEAD || type == TR) { /** \todo parse error */ } else { handled = false; } } break; case HUBBUB_TOKEN_EOF: break; } if (!handled) { treebuilder->context.in_table_foster = true; /** \todo parse error */ err = handle_in_body(treebuilder, token); treebuilder->context.in_table_foster = false; } return err; }
/** * Handle tokens in "generic rcdata" insertion mode * * \param treebuilder The treebuilder instance * \param token The token to process * \return True to reprocess the token, false otherwise */ hubbub_error handle_generic_rcdata(hubbub_treebuilder *treebuilder, const hubbub_token *token) { hubbub_error err = HUBBUB_OK; bool done = false; if (treebuilder->context.strip_leading_lr && token->type != HUBBUB_TOKEN_CHARACTER) { /* Reset the LR stripping flag */ treebuilder->context.strip_leading_lr = false; } switch (token->type) { case HUBBUB_TOKEN_CHARACTER: { hubbub_string chars = token->data.character; if (treebuilder->context.strip_leading_lr) { if (chars.ptr[0] == '\n') { chars.ptr++; chars.len--; } treebuilder->context.strip_leading_lr = false; } if (chars.len == 0) break; err = append_text(treebuilder, &chars); } break; case HUBBUB_TOKEN_END_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type != treebuilder->context.collect.type) { /** \todo parse error */ } if ((treebuilder->context.enable_scripting == true) && (type == SCRIPT)) { err = complete_script(treebuilder); } done = true; } break; case HUBBUB_TOKEN_EOF: /** \todo if the current node's a script, * mark it as already executed */ /** \todo parse error */ done = true; err = HUBBUB_REPROCESS; break; case HUBBUB_TOKEN_COMMENT: case HUBBUB_TOKEN_DOCTYPE: case HUBBUB_TOKEN_START_TAG: /* Should never happen */ assert(0); break; } if (done) { hubbub_ns ns; element_type otype; void *node; /* Pop the current node from the stack */ element_stack_pop(treebuilder, &ns, &otype, &node); /* Return to previous insertion mode */ treebuilder->context.mode = treebuilder->context.collect.mode; } return err; }
/** * Handle token in "in head" insertion mode * * \param treebuilder The treebuilder instance * \param token The token to handle * \return True to reprocess token, false otherwise */ hubbub_error handle_in_head(hubbub_treebuilder *treebuilder, const hubbub_token *token) { hubbub_error err = HUBBUB_OK; bool handled = false; switch (token->type) { case HUBBUB_TOKEN_CHARACTER: err = process_characters_expect_whitespace(treebuilder, token, true); break; case HUBBUB_TOKEN_COMMENT: err = process_comment_append(treebuilder, token, treebuilder->context.element_stack[ treebuilder->context.current_node].node); break; case HUBBUB_TOKEN_DOCTYPE: /** \todo parse error */ break; case HUBBUB_TOKEN_START_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == HTML) { /* Process as if "in body" */ err = handle_in_body(treebuilder, token); } else if (type == BASE || type == COMMAND || type == LINK) { err = insert_element(treebuilder, &token->data.tag, false); /** \todo ack sc flag */ } else if (type == META) { err = process_meta_in_head(treebuilder, token); } else if (type == TITLE) { err = parse_generic_rcdata(treebuilder, token, true); } else if (type == NOFRAMES || type == STYLE) { err = parse_generic_rcdata(treebuilder, token, false); } else if (type == NOSCRIPT) { if (treebuilder->context.enable_scripting) { err = parse_generic_rcdata(treebuilder, token, false); } else { err = insert_element(treebuilder, &token->data.tag, true); if (err != HUBBUB_OK) return err; treebuilder->context.mode = IN_HEAD_NOSCRIPT; } } else if (type == SCRIPT) { /** \todo need to ensure that the client callback * sets the parser-inserted/already-executed script * flags. */ err = parse_generic_rcdata(treebuilder, token, false); } else if (type == HEAD) { /** \todo parse error */ } else { err = HUBBUB_REPROCESS; } } break; case HUBBUB_TOKEN_END_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == HEAD) { handled = true; } else if (type == HTML || type == BODY || type == BR) { err = HUBBUB_REPROCESS; } /** \todo parse error */ } break; case HUBBUB_TOKEN_EOF: err = HUBBUB_REPROCESS; break; } if (handled || err == HUBBUB_REPROCESS) { hubbub_ns ns; element_type otype; void *node; element_stack_pop(treebuilder, &ns, &otype, &node); treebuilder->context.mode = AFTER_HEAD; } return err; }
/** * Handle tokens in "in head noscript" insertion mode * * \param treebuilder The treebuilder instance * \param token The token to process * \return True to reprocess the token, false otherwise */ hubbub_error handle_in_head_noscript(hubbub_treebuilder *treebuilder, const hubbub_token *token) { hubbub_error err = HUBBUB_OK; bool handled = false; switch (token->type) { case HUBBUB_TOKEN_CHARACTER: err = process_characters_expect_whitespace(treebuilder, token, true); break; case HUBBUB_TOKEN_COMMENT: err = handle_in_head(treebuilder, token); break; case HUBBUB_TOKEN_DOCTYPE: /** \todo parse error */ break; case HUBBUB_TOKEN_START_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == HTML) { /* Process as "in body" */ err = handle_in_body(treebuilder, token); } else if (type == NOSCRIPT) { handled = true; } else if (type == LINK || type == META || type == NOFRAMES || type == STYLE) { /* Process as "in head" */ err = handle_in_head(treebuilder, token); } else if (type == HEAD || type == NOSCRIPT) { /** \todo parse error */ } else { /** \todo parse error */ err = HUBBUB_REPROCESS; } } break; case HUBBUB_TOKEN_END_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == NOSCRIPT) { handled = true; } else if (type == BR) { /** \todo parse error */ err = HUBBUB_REPROCESS; } else { /** \todo parse error */ } } break; case HUBBUB_TOKEN_EOF: /** \todo parse error */ err = HUBBUB_REPROCESS; break; } if (handled || err == HUBBUB_REPROCESS) { hubbub_ns ns; element_type otype; void *node; element_stack_pop(treebuilder, &ns, &otype, &node); treebuilder->tree_handler->unref_node( treebuilder->tree_handler->ctx, node); treebuilder->context.mode = IN_HEAD; } return err; }
/** * Handle tokens in "in caption" insertion mode * * \param treebuilder The treebuilder instance * \param token The token to process * \return True to reprocess the token, false otherwise */ hubbub_error handle_in_caption(hubbub_treebuilder *treebuilder, const hubbub_token *token) { hubbub_error err = HUBBUB_OK; bool handled = false; switch (token->type) { case HUBBUB_TOKEN_START_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == CAPTION || type == COL || type == COLGROUP || type == TBODY || type == TD || type == TFOOT || type == TH || type == THEAD || type == TR) { /** \todo parse error */ err = HUBBUB_REPROCESS; } else { /* Process as if "in body" */ err = handle_in_body(treebuilder, token); } } break; case HUBBUB_TOKEN_END_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == CAPTION) { handled = true; } else if (type == TABLE) { /** \todo parse error if type == TABLE */ err = HUBBUB_REPROCESS; } else if (type == BODY || type == COL || type == COLGROUP || type == HTML || type == TBODY || type == TD || type == TFOOT || type == TH || type == THEAD || type == TR) { /** \todo parse error */ } else { /* Process as if "in body" */ err = handle_in_body(treebuilder, token); } } break; case HUBBUB_TOKEN_CHARACTER: case HUBBUB_TOKEN_COMMENT: case HUBBUB_TOKEN_DOCTYPE: case HUBBUB_TOKEN_EOF: /* Process as if "in body" */ err = handle_in_body(treebuilder, token); break; } if (handled || err == HUBBUB_REPROCESS) { hubbub_ns ns; element_type otype = UNKNOWN; void *node; /** \todo fragment case */ close_implied_end_tags(treebuilder, UNKNOWN); while (otype != CAPTION) { /** \todo parse error */ element_stack_pop(treebuilder, &ns, &otype, &node); } clear_active_formatting_list_to_marker(treebuilder); treebuilder->context.mode = IN_TABLE; } return err; }
/** * Create element and insert it into the DOM, * potentially pushing it on the stack * * \param treebuilder The treebuilder instance * \param tag The element to insert * \param push Whether to push the element onto the stack * \return HUBBUB_OK on success, appropriate error otherwise. */ hubbub_error insert_element(hubbub_treebuilder *treebuilder, const hubbub_tag *tag, bool push) { element_type type = current_node(treebuilder); hubbub_error error; void *appended; if (treebuilder->context.in_table_foster && (type == TABLE || type == TBODY || type == TFOOT || type == THEAD || type == TR)) { error = aa_insert_into_foster_parent_new(treebuilder, HUBBUB_TOKEN_START_TAG, &appended); } else { error = treebuilder->tree_handler->append_child_new( treebuilder->tree_handler->ctx, treebuilder->context.element_stack[ treebuilder->context.current_node].node, HUBBUB_TOKEN_START_TAG, &appended); } if (error != HUBBUB_OK) return error; error = treebuilder->tree_handler->set_name( treebuilder->tree_handler->ctx, appended, &tag->name); if (error != HUBBUB_OK) return error; error = treebuilder->tree_handler->add_attributes( treebuilder->tree_handler->ctx, appended, tag->attributes, tag->n_attributes); if (error != HUBBUB_OK) return error; type = element_type_from_name(treebuilder, &tag->name); if (treebuilder->context.form_element != NULL && is_form_associated(type)) { /* Consideration of @form is left to the client */ error = treebuilder->tree_handler->form_associate( treebuilder->tree_handler->ctx, treebuilder->context.form_element, appended); if (error != HUBBUB_OK) { remove_node_from_dom(treebuilder, appended); return error; } } if (push) { error = element_stack_push(treebuilder, tag->ns, type, appended); if (error != HUBBUB_OK) { remove_node_from_dom(treebuilder, appended); return error; } } return HUBBUB_OK; }
/** * Handle tokens in "in row" insertion mode * * \param treebuilder The treebuilder instance * \param token The token to process * \return True to reprocess the token, false otherwise */ hubbub_error handle_in_row(hubbub_treebuilder *treebuilder, const hubbub_token *token) { hubbub_error err = HUBBUB_OK; switch (token->type) { case HUBBUB_TOKEN_START_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == TH || type == TD) { table_clear_stack(treebuilder); err = insert_element(treebuilder, &token->data.tag, true); if (err != HUBBUB_OK) return err; treebuilder->context.mode = IN_CELL; /* ref node for formatting list */ treebuilder->tree_handler->ref_node( treebuilder->tree_handler->ctx, treebuilder->context.element_stack[ treebuilder->context.current_node].node); err = formatting_list_append(treebuilder, token->data.tag.ns, type, treebuilder->context.element_stack[ treebuilder->context.current_node].node, treebuilder->context.current_node); if (err != HUBBUB_OK) { hubbub_ns ns; element_type type; void *node; /* Revert changes */ remove_node_from_dom(treebuilder, treebuilder->context.element_stack[ treebuilder->context.current_node].node); element_stack_pop(treebuilder, &ns, &type, &node); return err; } } else if (type == CAPTION || type == COL || type == COLGROUP || type == TBODY || type == TFOOT || type == THEAD || type == TR) { err = act_as_if_end_tag_tr(treebuilder); } else { err = handle_in_table(treebuilder, token); } } break; case HUBBUB_TOKEN_END_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == TR) { /* We're done with this token, but act_as_if_end_tag_tr * will return HUBBUB_REPROCESS. Therefore, ignore the * return value. */ (void) act_as_if_end_tag_tr(treebuilder); } else if (type == TABLE) { err = act_as_if_end_tag_tr(treebuilder); } else if (type == BODY || type == CAPTION || type == COL || type == COLGROUP || type == HTML || type == TD || type == TH) { /** \todo parse error */ /* Ignore the token */ } else { err = handle_in_table(treebuilder, token); } } break; case HUBBUB_TOKEN_CHARACTER: case HUBBUB_TOKEN_COMMENT: case HUBBUB_TOKEN_DOCTYPE: case HUBBUB_TOKEN_EOF: err = handle_in_table(treebuilder, token); break; } return err; }
/** * Handle tokens in "in column group" insertion mode * * \param treebuilder The treebuilder instance * \param token The token to process * \return True to reprocess the token, false otherwise */ hubbub_error handle_in_column_group(hubbub_treebuilder *treebuilder, const hubbub_token *token) { hubbub_error err = HUBBUB_OK; bool handled = false; switch (token->type) { case HUBBUB_TOKEN_CHARACTER: err = process_characters_expect_whitespace(treebuilder, token, true); break; case HUBBUB_TOKEN_COMMENT: err = process_comment_append(treebuilder, token, treebuilder->context.element_stack[ treebuilder->context.current_node].node); break; case HUBBUB_TOKEN_DOCTYPE: /** \todo parse error */ break; case HUBBUB_TOKEN_START_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == HTML) { /* Process as if "in body" */ err = handle_in_body(treebuilder, token); } else if (type == COL) { err = insert_element(treebuilder, &token->data.tag, false); /** \todo ack sc flag */ } else { err = HUBBUB_REPROCESS; } } break; case HUBBUB_TOKEN_END_TAG: { element_type type = element_type_from_name(treebuilder, &token->data.tag.name); if (type == COLGROUP) { /** \todo fragment case */ handled = true; } else if (type == COL) { /** \todo parse error */ } else { err = HUBBUB_REPROCESS; } } break; case HUBBUB_TOKEN_EOF: /** \todo fragment case */ err = HUBBUB_REPROCESS; break; } if (handled || err == HUBBUB_REPROCESS) { hubbub_ns ns; element_type otype; void *node; /* Pop the current node (which will be a colgroup) */ element_stack_pop(treebuilder, &ns, &otype, &node); treebuilder->context.mode = IN_TABLE; } return err; }