Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  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 John-Mark Bell <jmb@netsurf-browser.org>
  6.  */
  7.  
  8. #include <assert.h>
  9. #include <string.h>
  10.  
  11. #include "treebuilder/modes.h"
  12. #include "treebuilder/internal.h"
  13. #include "treebuilder/treebuilder.h"
  14. #include "utils/utils.h"
  15.  
  16.  
  17. /**
  18.  * Handle tokens in "after head" insertion mode
  19.  *
  20.  * \param treebuilder  The treebuilder instance
  21.  * \param token        The token to process
  22.  * \return True to reprocess the token, false otherwise
  23.  */
  24. hubbub_error handle_after_head(hubbub_treebuilder *treebuilder,
  25.                 const hubbub_token *token)
  26. {
  27.         hubbub_error err = HUBBUB_OK;
  28.         bool handled = false;
  29.  
  30.         switch (token->type) {
  31.         case HUBBUB_TOKEN_CHARACTER:
  32.                 err = process_characters_expect_whitespace(treebuilder,
  33.                                 token, true);
  34.                 break;
  35.         case HUBBUB_TOKEN_COMMENT:
  36.                 err = process_comment_append(treebuilder, token,
  37.                                 treebuilder->context.element_stack[
  38.                                 treebuilder->context.current_node].node);
  39.                 break;
  40.         case HUBBUB_TOKEN_DOCTYPE:
  41.                 /** \todo parse error */
  42.                 break;
  43.         case HUBBUB_TOKEN_START_TAG:
  44.         {
  45.                 element_type type = element_type_from_name(treebuilder,
  46.                                 &token->data.tag.name);
  47.  
  48.                 if (type == HTML) {
  49.                         /* Process as if "in body" */
  50.                         err = handle_in_body(treebuilder, token);
  51.                 } else if (type == BODY) {
  52.                         handled = true;
  53.                 } else if (type == FRAMESET) {
  54.                         err = insert_element(treebuilder, &token->data.tag,
  55.                                 true);
  56.                         if (err == HUBBUB_OK)
  57.                                 treebuilder->context.mode = IN_FRAMESET;
  58.                 } else if (type == BASE || type == LINK || type == META ||
  59.                                 type == NOFRAMES || type == SCRIPT ||
  60.                                 type == STYLE || type == TITLE) {
  61.                         hubbub_ns ns;
  62.                         element_type otype;
  63.                         void *node;
  64.                         uint32_t index;
  65.  
  66.                         /** \todo parse error */
  67.  
  68.                         err = element_stack_push(treebuilder,
  69.                                         HUBBUB_NS_HTML,
  70.                                         HEAD,
  71.                                         treebuilder->context.head_element);
  72.                         if (err != HUBBUB_OK)
  73.                                 return err;
  74.  
  75.                         index = treebuilder->context.current_node;
  76.  
  77.                         /* Process as "in head" */
  78.                         err = handle_in_head(treebuilder, token);
  79.  
  80.                         element_stack_remove(treebuilder, index,
  81.                                         &ns, &otype, &node);
  82.  
  83.                         /* No need to unref node as we never increased
  84.                          * its reference count when pushing it on the stack */
  85.                 } else if (type == HEAD) {
  86.                         /** \todo parse error */
  87.                 } else {
  88.                         err = HUBBUB_REPROCESS;
  89.                 }
  90.         }
  91.                 break;
  92.         case HUBBUB_TOKEN_END_TAG:
  93.         {
  94.                 element_type type = element_type_from_name(treebuilder,
  95.                                 &token->data.tag.name);
  96.  
  97.                 if (type == HTML || type == BODY || type == BR) {
  98.                         err = HUBBUB_REPROCESS;
  99.                 } else {
  100.                         /** \todo parse error */
  101.                 }
  102.         }
  103.                 break;
  104.         case HUBBUB_TOKEN_EOF:
  105.                 err = HUBBUB_REPROCESS;
  106.                 break;
  107.         }
  108.  
  109.         if (handled || err == HUBBUB_REPROCESS) {
  110.                 hubbub_error e;
  111.                 hubbub_tag tag;
  112.  
  113.                 if (err == HUBBUB_REPROCESS) {
  114.                         /* Manufacture body */
  115.                         tag.ns = HUBBUB_NS_HTML;
  116.                         tag.name.ptr = (const uint8_t *) "body";
  117.                         tag.name.len = SLEN("body");
  118.  
  119.                         tag.n_attributes = 0;
  120.                         tag.attributes = NULL;
  121.                 } else {
  122.                         tag = token->data.tag;
  123.                 }
  124.  
  125.                 e = insert_element(treebuilder, &tag, true);
  126.                 if (e != HUBBUB_OK)
  127.                         return e;
  128.  
  129.                 treebuilder->context.mode = IN_BODY;
  130.         }
  131.  
  132.         return err;
  133. }
  134.  
  135.