Hubbub
in_table_body.c
Go to the documentation of this file.
1 /*
2  * This file is part of Hubbub.
3  * Licensed under the MIT License,
4  * http://www.opensource.org/licenses/mit-license.php
5  * Copyright 2008 Andrew Sidwell <takkaria@netsurf-browser.org>
6  */
7 
8 #include <assert.h>
9 #include <string.h>
10 
11 #include "treebuilder/modes.h"
12 #include "treebuilder/internal.h"
14 #include "utils/utils.h"
15 
16 
22 static void table_clear_stack(hubbub_treebuilder *treebuilder)
23 {
24  element_type cur_node = current_node(treebuilder);
25 
26  while (cur_node != TBODY && cur_node != TFOOT &&
27  cur_node != THEAD && cur_node != HTML) {
28  hubbub_ns ns;
30  void *node;
31 
32  element_stack_pop(treebuilder, &ns, &type, &node);
33 
34  treebuilder->tree_handler->unref_node(
35  treebuilder->tree_handler->ctx,
36  node);
37 
38  cur_node = current_node(treebuilder);
39  }
40 
41  return;
42 }
43 
44 
52 {
53  if (element_in_scope(treebuilder, TBODY, true) ||
54  element_in_scope(treebuilder, THEAD, true) ||
55  element_in_scope(treebuilder, TFOOT, true)) {
56  hubbub_ns ns;
57  element_type otype;
58  void *node;
59 
60  table_clear_stack(treebuilder);
61 
62  /* "Act as if an end tag with the same name as the current
63  * node had been seen" -- this behaviour should be identical
64  * to handling for (tbody/tfoot/thead) end tags in this mode */
65  element_stack_pop(treebuilder, &ns, &otype, &node);
66 
67  treebuilder->tree_handler->unref_node(
68  treebuilder->tree_handler->ctx,
69  node);
70 
71  treebuilder->context.mode = IN_TABLE;
72 
73  return HUBBUB_REPROCESS;
74  } else {
76  }
77 
78  return HUBBUB_OK;
79 }
80 
81 
90  const hubbub_token *token)
91 {
92  hubbub_error err = HUBBUB_OK;
93 
94  switch (token->type) {
96  {
98  &token->data.tag.name);
99 
100  if (type == TR) {
101  table_clear_stack(treebuilder);
102 
103  err = insert_element(treebuilder, &token->data.tag,
104  true);
105  if (err == HUBBUB_OK)
106  treebuilder->context.mode = IN_ROW;
107  } else if (type == TH || type == TD) {
108  hubbub_tag tag;
109 
112  /* Manufacture tr tag */
113  tag.ns = HUBBUB_NS_HTML;
114  tag.name.ptr = (const uint8_t *) "tr";
115  tag.name.len = SLEN("tr");
116 
117  tag.n_attributes = 0;
118  tag.attributes = NULL;
119 
120  table_clear_stack(treebuilder);
121 
122  err = insert_element(treebuilder, &tag, true);
123  if (err == HUBBUB_OK) {
124  treebuilder->context.mode = IN_ROW;
125 
126  err = HUBBUB_REPROCESS;
127  }
128  } else if (type == CAPTION || type == COL ||
129  type == COLGROUP || type == TBODY ||
130  type == TFOOT || type == THEAD) {
131  err = table_sub_start_or_table_end(treebuilder);
132  } else {
133  err = handle_in_table(treebuilder, token);
134  }
135  }
136  break;
138  {
140  &token->data.tag.name);
141 
142  if (type == TBODY || type == TFOOT || type == THEAD) {
143  if (!element_in_scope(treebuilder, type, true)) {
145  /* Ignore the token */
146  } else {
147  hubbub_ns ns;
148  element_type otype;
149  void *node;
150 
151  table_clear_stack(treebuilder);
152 
153  element_stack_pop(treebuilder, &ns,
154  &otype, &node);
155 
156  treebuilder->tree_handler->unref_node(
157  treebuilder->tree_handler->ctx,
158  node);
159 
160  treebuilder->context.mode = IN_TABLE;
161  }
162  } else if (type == TABLE) {
163  err = table_sub_start_or_table_end(treebuilder);
164  } else if (type == BODY || type == CAPTION || type == COL ||
165  type == COLGROUP || type == HTML ||
166  type == TD || type == TH || type == TR) {
168  /* Ignore the token */
169  } else {
170  err = handle_in_table(treebuilder, token);
171  }
172  }
173  break;
177  case HUBBUB_TOKEN_EOF:
178  err = handle_in_table(treebuilder, token);
179  break;
180  }
181 
182  return err;
183 }
184 
#define SLEN(s)
Definition: utils.h:34
element_type current_node(hubbub_treebuilder *treebuilder)
Peek at the top element of the element stack.
Definition: treebuilder.c:1258
Definition: internal.h:25
hubbub_token_type type
The token type.
Definition: types.h:120
void * ctx
Context pointer.
Definition: tree.h:292
hubbub_ns ns
Tag namespace.
Definition: types.h:109
Data for a tag.
Definition: types.h:108
Token data.
Definition: types.h:119
hubbub_error handle_in_table_body(hubbub_treebuilder *treebuilder, const hubbub_token *token)
Handle tokens in "in table body" insertion mode.
Definition: in_table_body.c:89
hubbub_string name
Tag name.
Definition: types.h:110
hubbub_tree_handler * tree_handler
Callback table.
Definition: internal.h:122
const uint8_t * ptr
Pointer to data.
Definition: types.h:77
Definition: modes.h:27
element_type
Definition: internal.h:13
Definition: internal.h:17
Definition: internal.h:25
Definition: internal.h:25
Definition: internal.h:22
Definition: internal.h:25
insertion_mode mode
The current insertion mode.
Definition: internal.h:75
Definition: internal.h:22
size_t len
Byte length of string.
Definition: types.h:78
hubbub_error handle_in_table(hubbub_treebuilder *treebuilder, const hubbub_token *token)
Handle token in "in table" insertion mode.
Definition: in_table.c:74
hubbub_treebuilder_context context
Our context.
Definition: internal.h:120
static hubbub_error table_sub_start_or_table_end(hubbub_treebuilder *treebuilder)
Handle the case common to some start tag and the table end tag cases.
Definition: in_table_body.c:51
hubbub_error insert_element(hubbub_treebuilder *treebuilder, const hubbub_tag *tag_name, bool push)
Create element and insert it into the DOM, potentially pushing it on the stack.
Definition: treebuilder.c:751
hubbub_attribute * attributes
Array of attribute data.
Definition: types.h:112
hubbub_error
Definition: errors.h:18
Definition: internal.h:22
Definition: internal.h:17
hubbub_tree_unref_node unref_node
Unreference node.
Definition: tree.h:279
element_type type
Definition: treebuilder.c:25
No error.
Definition: errors.h:19
hubbub_tag tag
Definition: types.h:125
hubbub_ns
Possible namespaces.
Definition: types.h:63
union hubbub_token::@3 data
Type-specific data.
Definition: modes.h:23
uint32_t element_in_scope(hubbub_treebuilder *treebuilder, element_type type, bool in_table)
Determine if an element is in (table) scope.
Definition: treebuilder.c:499
hubbub_error element_stack_pop(hubbub_treebuilder *treebuilder, hubbub_ns *ns, element_type *type, void **node)
Pop an element off the stack of open elements.
Definition: treebuilder.c:1112
element_type element_type_from_name(hubbub_treebuilder *treebuilder, const hubbub_string *tag_name)
Convert an element name into an element type.
Definition: treebuilder.c:986
Definition: internal.h:23
Treebuilder object.
Definition: internal.h:116
uint32_t n_attributes
Count of attributes.
Definition: types.h:111
static void table_clear_stack(hubbub_treebuilder *treebuilder)
Clear the stack back to a table body context.
Definition: in_table_body.c:22