src/document/sgml/parser.c

   1 /* SGML node handling */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include "elinks.h"
  11
  12 #include "cache/cache.h"
  13 #include "document/document.h"
  14 #include "document/dom/node.h"
  15 #include "document/dom/stack.h"
  16 #include "document/html/renderer.h" /* TODO: Move get_convert_table() */
  17 #include "document/sgml/html/html.h"
  18 #include "document/sgml/parser.h"
  19 #include "document/sgml/scanner.h"
  20 #include "document/sgml/sgml.h"
  21 #include "intl/charsets.h"
  22 #include "protocol/uri.h"
  23 #include "util/error.h"
  24 #include "util/lists.h"
  25 #include "util/memory.h"
  26 #include "util/string.h"
  27
  28
  29 /* Functions for adding new nodes to the DOM tree */
  30
  31 static inline struct dom_node *
  32 add_sgml_document(struct dom_stack *stack, struct uri *uri)
  33 {
  34         unsigned char *string = struri(uri);
  35         int length = strlen(string);
  36         struct dom_node *node = init_dom_node(DOM_NODE_DOCUMENT, string, length);
  37
  38         return node ? push_dom_node(stack, node) : node;
  39 }
  40
  41 static inline struct dom_node *
  42 add_sgml_element(struct dom_stack *stack, struct scanner_token *token)
  43 {
  44         struct sgml_parser *parser = stack->parser;
  45         struct dom_node *parent = get_dom_stack_top(stack)->node;
  46         struct dom_stack_state *state;
  47         struct sgml_parser_state *pstate;
  48         struct dom_node *node;
  49         struct sgml_node_info *node_info;
  50
  51         node = add_dom_element(parent, token->string, token->length);
  52         if (!node) return NULL;
  53
  54         node_info = get_sgml_node_info(parser->info->elements, node);
  55         node->data.element.type = node_info->type;
  56
  57         if (!push_dom_node(stack, node))
  58                 return NULL;
  59
  60         state = get_dom_stack_top(stack);
  61         assert(node == state->node);
  62
  63         pstate = get_dom_stack_state_data(stack, state);
  64         pstate->info = node_info;
  65
  66         return node;
  67 }
  68
  69
  70 static inline void
  71 add_sgml_attribute(struct dom_stack *stack,
  72                   struct scanner_token *token, struct scanner_token *valtoken)
  73 {
  74         struct sgml_parser *parser = stack->parser;
  75         struct dom_node *parent = get_dom_stack_top(stack)->node;
  76         unsigned char *value = valtoken ? valtoken->string : NULL;
  77         uint16_t valuelen = valtoken ? valtoken->length : 0;
  78         struct sgml_node_info *info;
  79         struct dom_node *node;
  80
  81         node = add_dom_attribute(parent, token->string, token->length,
  82                                  value, valuelen);
  83
  84         info = get_sgml_node_info(parser->info->attributes, node);
  85
  86         node->data.attribute.type      = info->type;
  87         node->data.attribute.id        = !!(info->flags & SGML_ATTRIBUTE_IDENTIFIER);
  88         node->data.attribute.reference = !!(info->flags & SGML_ATTRIBUTE_REFERENCE);
  89
  90         if (valtoken && valtoken->type == SGML_TOKEN_STRING)
  91                 node->data.attribute.quoted = 1;
  92
  93         if (!node || !push_dom_node(stack, node))
  94                 return;
  95
  96         pop_dom_node(stack);
  97 }
  98
  99 static inline struct dom_node *
 100 add_sgml_proc_instruction(struct dom_stack *stack, struct scanner_token *token)
 101 {
 102         struct dom_node *parent = get_dom_stack_top(stack)->node;
 103         struct dom_node *node;
 104         /* Split the token in two if we can find a first space separator. */
 105         unsigned char *separator = memchr(token->string, ' ', token->length);
 106
 107         /* Anything before the separator becomes the target name ... */
 108         unsigned char *name = token->string;
 109         int namelen = separator ? separator - token->string : token->length;
 110
 111         /* ... and everything after the instruction value. */
 112         unsigned char *value = separator ? separator + 1 : NULL;
 113         int valuelen = value ? token->length - namelen - 1 : 0;
 114
 115         node = add_dom_proc_instruction(parent, name, namelen, value, valuelen);
 116         if (!node) return NULL;
 117
 118         switch (token->type) {
 119         case SGML_TOKEN_PROCESS_XML:
 120                 node->data.proc_instruction.type = DOM_PROC_INSTRUCTION_XML;
 121                 break;
 122
 123         case SGML_TOKEN_PROCESS:
 124         default:
 125                 node->data.proc_instruction.type = DOM_PROC_INSTRUCTION;
 126         }
 127
 128         if (!push_dom_node(stack, node))
 129                 return NULL;
 130
 131         if (token->type != SGML_TOKEN_PROCESS_XML)
 132                 pop_dom_node(stack);
 133
 134         return node;
 135 }
 136
 137 static inline void
 138 add_sgml_node(struct dom_stack *stack, enum dom_node_type type, struct scanner_token *token)
 139 {
 140         struct dom_node *parent = get_dom_stack_top(stack)->node;
 141         struct dom_node *node = add_dom_node(parent, type, token->string, token->length);
 142
 143         if (!node) return;
 144
 145         if (token->type == SGML_TOKEN_SPACE)
 146                 node->data.text.only_space = 1;
 147
 148         if (push_dom_node(stack, node))
 149                 pop_dom_node(stack);
 150 }
 151
 152 #define add_sgml_entityref(stack, t)    add_sgml_node(stack, DOM_NODE_ENTITY_REFERENCE, t)
 153 #define add_sgml_text(stack, t)         add_sgml_node(stack, DOM_NODE_TEXT, t)
 154 #define add_sgml_comment(stack, t)      add_sgml_node(stack, DOM_NODE_COMMENT, t)
 155
 156 static inline void
 157 parse_sgml_attributes(struct dom_stack *stack, struct scanner *scanner)
 158 {
 159         struct scanner_token name;
 160
 161         assert(scanner_has_tokens(scanner)
 162                && (get_scanner_token(scanner)->type == SGML_TOKEN_ELEMENT_BEGIN
 163                    || get_scanner_token(scanner)->type == SGML_TOKEN_PROCESS_XML));
 164
 165         skip_scanner_token(scanner);
 166
 167         while (scanner_has_tokens(scanner)) {
 168                 struct scanner_token *token = get_scanner_token(scanner);
 169
 170                 assert(token);
 171
 172                 switch (token->type) {
 173                 case SGML_TOKEN_TAG_END:
 174                         skip_scanner_token(scanner);
 175                         /* and return */
 176                 case SGML_TOKEN_ELEMENT:
 177                 case SGML_TOKEN_ELEMENT_BEGIN:
 178                 case SGML_TOKEN_ELEMENT_END:
 179                 case SGML_TOKEN_ELEMENT_EMPTY_END:
 180                         return;
 181
 182                 case SGML_TOKEN_IDENT:
 183                         copy_struct(&name, token);
 184
 185                         /* Skip the attribute name token */
 186                         token = get_next_scanner_token(scanner);
 187                         if (token && token->type == '=') {
 188                                 /* If the token is not a valid value token
 189                                  * ignore it. */
 190                                 token = get_next_scanner_token(scanner);
 191                                 if (token
 192                                     && token->type != SGML_TOKEN_IDENT
 193                                     && token->type != SGML_TOKEN_ATTRIBUTE
 194                                     && token->type != SGML_TOKEN_STRING)
 195                                         token = NULL;
 196                         } else {
 197                                 token = NULL;
 198                         }
 199
 200                         add_sgml_attribute(stack, &name, token);
 201
 202                         /* Skip the value token */
 203                         if (token)
 204                                 skip_scanner_token(scanner);
 205                         break;
 206
 207                 default:
 208                         skip_scanner_token(scanner);
 209
 210                 }
 211         }
 212 }
 213
 214 void
 215 parse_sgml_document(struct dom_stack *stack, struct scanner *scanner)
 216 {
 217         while (scanner_has_tokens(scanner)) {
 218                 struct scanner_token *token = get_scanner_token(scanner);
 219
 220                 switch (token->type) {
 221                 case SGML_TOKEN_ELEMENT:
 222                 case SGML_TOKEN_ELEMENT_BEGIN:
 223                         if (!add_sgml_element(stack, token)) {
 224                                 if (token->type == SGML_TOKEN_ELEMENT) {
 225                                         skip_scanner_token(scanner);
 226                                         break;
 227                                 }
 228
 229                                 skip_sgml_tokens(scanner, SGML_TOKEN_TAG_END);
 230                                 break;
 231                         }
 232
 233                         if (token->type == SGML_TOKEN_ELEMENT_BEGIN) {
 234                                 parse_sgml_attributes(stack, scanner);
 235                         } else {
 236                                 skip_scanner_token(scanner);
 237                         }
 238
 239                         break;
 240
 241                 case SGML_TOKEN_ELEMENT_EMPTY_END:
 242                         pop_dom_node(stack);
 243                         skip_scanner_token(scanner);
 244                         break;
 245
 246                 case SGML_TOKEN_ELEMENT_END:
 247                         if (!token->length) {
 248                                 pop_dom_node(stack);
 249                         } else {
 250                                 pop_dom_nodes(stack, DOM_NODE_ELEMENT,
 251                                               token->string, token->length);
 252                         }
 253                         skip_scanner_token(scanner);
 254                         break;
 255
 256                 case SGML_TOKEN_NOTATION_COMMENT:
 257                         add_sgml_comment(stack, token);
 258                         skip_scanner_token(scanner);
 259                         break;
 260
 261                 case SGML_TOKEN_NOTATION_ATTLIST:
 262                 case SGML_TOKEN_NOTATION_DOCTYPE:
 263                 case SGML_TOKEN_NOTATION_ELEMENT:
 264                 case SGML_TOKEN_NOTATION_ENTITY:
 265                 case SGML_TOKEN_NOTATION:
 266                         skip_scanner_token(scanner);
 267                         break;
 268
 269                 case SGML_TOKEN_PROCESS_XML:
 270                         if (!add_sgml_proc_instruction(stack, token)) {
 271                                 skip_sgml_tokens(scanner, SGML_TOKEN_TAG_END);
 272                                 break;
 273                         }
 274
 275                         parse_sgml_attributes(stack, scanner);
 276                         pop_dom_node(stack);
 277                         break;
 278
 279                 case SGML_TOKEN_PROCESS:
 280                         add_sgml_proc_instruction(stack, token);
 281                         skip_scanner_token(scanner);
 282                         break;
 283
 284                 case SGML_TOKEN_ENTITY:
 285                         add_sgml_entityref(stack, token);
 286                         skip_scanner_token(scanner);
 287                         break;
 288
 289                 case SGML_TOKEN_SPACE:
 290                 case SGML_TOKEN_TEXT:
 291                 default:
 292                         add_sgml_text(stack, token);
 293                         skip_scanner_token(scanner);
 294                 }
 295         }
 296 }
 297
 298
 299 struct sgml_parser *
 300 init_sgml_parser(struct cache_entry *cached, struct document *document)
 301 {
 302         size_t obj_size = sizeof(struct sgml_parser_state);
 303         struct sgml_parser *parser;
 304
 305         parser = mem_calloc(1, sizeof(*parser));
 306         if (!parser) return NULL;
 307
 308         parser->document    = document;
 309         parser->cache_entry = cached;
 310         parser->info        = &sgml_html_info;
 311
 312         init_dom_stack(&parser->stack, parser, NULL, parser->info->callbacks, obj_size);
 313
 314         if (document->options.plain)
 315                 parser->flags |= SGML_PARSER_ADD_ELEMENT_ENDS;
 316
 317         return parser;
 318 }
 319
 320 void
 321 done_sgml_parser(struct sgml_parser *parser)
 322 {
 323         done_dom_stack(&parser->stack);
 324         mem_free(parser);
 325 }
 326
 327 /* FIXME: Make it possible to push variable number of strings (even nested
 328  * while parsing another string) so that we can feed back output of stuff
 329  * like ECMAScripts document.write(). */
 330 struct dom_node *
 331 parse_sgml(struct sgml_parser *parser, struct string *buffer)
 332 {
 333         unsigned char *source = buffer->source;
 334         unsigned char *end = source + buffer->length;
 335
 336         init_scanner(&parser->scanner, &sgml_scanner_info, source, end);
 337
 338         parser->root = add_sgml_document(&parser->stack, parser->document->uri);
 339         if (parser->root) {
 340                 parse_sgml_document(&parser->stack, &parser->scanner);
 341         }
 342
 343         return parser->root;
 344 }