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 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"
  13. #include "treebuilder/treebuilder.h"
  14. #include "utils/utils.h"
  15.  
  16.  
  17. /**
  18.  * Handle token in "in head" insertion mode
  19.  *
  20.  * \param treebuilder  The treebuilder instance
  21.  * \param token        The token to handle
  22.  * \return True to reprocess token, false otherwise
  23.  */
  24. hubbub_error handle_in_select(hubbub_treebuilder *treebuilder,
  25.                 const hubbub_token *token)
  26. {
  27.         hubbub_error err = HUBBUB_OK;
  28.  
  29.         hubbub_ns ns;
  30.         element_type otype;
  31.         void *node;
  32.  
  33.         switch (token->type) {
  34.         case HUBBUB_TOKEN_CHARACTER:
  35.                 err = append_text(treebuilder, &token->data.character);
  36.                 break;
  37.         case HUBBUB_TOKEN_COMMENT:
  38.                 err = process_comment_append(treebuilder, token,
  39.                                 treebuilder->context.element_stack[
  40.                                 treebuilder->context.current_node].node);
  41.                 break;
  42.         case HUBBUB_TOKEN_DOCTYPE:
  43.                 /** \todo parse error */
  44.                 break;
  45.         case HUBBUB_TOKEN_START_TAG:
  46.         {
  47.                 element_type type = element_type_from_name(treebuilder,
  48.                                 &token->data.tag.name);
  49.  
  50.                 if (type == HTML) {
  51.                         /* Process as if "in body" */
  52.                         err = handle_in_body(treebuilder, token);
  53.                 } else if (type == OPTION) {
  54.                         if (current_node(treebuilder) == OPTION) {
  55.                                 element_stack_pop(treebuilder, &ns, &otype,
  56.                                                 &node);
  57.  
  58.                                 treebuilder->tree_handler->unref_node(
  59.                                                 treebuilder->tree_handler->ctx,
  60.                                                 node);
  61.                         }
  62.  
  63.                         err = insert_element(treebuilder, &token->data.tag,
  64.                                         true);
  65.                 } else if (type == OPTGROUP) {
  66.                         if (current_node(treebuilder) == OPTION) {
  67.                                 element_stack_pop(treebuilder, &ns, &otype,
  68.                                                 &node);
  69.  
  70.                                 treebuilder->tree_handler->unref_node(
  71.                                                 treebuilder->tree_handler->ctx,
  72.                                                 node);
  73.                         }
  74.  
  75.                         if (current_node(treebuilder) == OPTGROUP) {
  76.                                 element_stack_pop(treebuilder, &ns, &otype,
  77.                                                 &node);
  78.  
  79.                                 treebuilder->tree_handler->unref_node(
  80.                                                 treebuilder->tree_handler->ctx,
  81.                                                 node);
  82.                         }
  83.  
  84.                         err = insert_element(treebuilder, &token->data.tag,
  85.                                         true);
  86.                 } else if (type == SELECT || type == INPUT ||
  87.                                 type == TEXTAREA) {
  88.  
  89.                         if (element_in_scope(treebuilder, SELECT, true)) {
  90.                                 element_stack_pop_until(treebuilder,
  91.                                                 SELECT);
  92.                                 reset_insertion_mode(treebuilder);
  93.                         } else {
  94.                                 /* fragment case */
  95.                                 /** \todo parse error */
  96.                         }
  97.  
  98.                         if (type != SELECT)
  99.                                 err = HUBBUB_REPROCESS;
  100.                 } else if (type == SCRIPT) {
  101.                         err = handle_in_head(treebuilder, token);
  102.                 } else {
  103.                         /** \todo parse error */
  104.                 }
  105.         }
  106.                 break;
  107.         case HUBBUB_TOKEN_END_TAG:
  108.         {
  109.                 element_type type = element_type_from_name(treebuilder,
  110.                                 &token->data.tag.name);
  111.  
  112.                 if (type == OPTGROUP) {
  113.                         if (current_node(treebuilder) == OPTION &&
  114.                                         prev_node(treebuilder) == OPTGROUP) {
  115.                                 element_stack_pop(treebuilder, &ns, &otype,
  116.                                                 &node);
  117.  
  118.                                 treebuilder->tree_handler->unref_node(
  119.                                                 treebuilder->tree_handler->ctx,
  120.                                                 node);
  121.                         }
  122.  
  123.                         if (current_node(treebuilder) == OPTGROUP) {
  124.                                 element_stack_pop(treebuilder, &ns, &otype,
  125.                                                 &node);
  126.  
  127.                                 treebuilder->tree_handler->unref_node(
  128.                                                 treebuilder->tree_handler->ctx,
  129.                                                 node);
  130.                         } else {
  131.                                 /** \todo parse error */
  132.                         }
  133.                 } else if (type == OPTION) {
  134.                         if (current_node(treebuilder) == OPTION) {
  135.                                 element_stack_pop(treebuilder, &ns, &otype,
  136.                                                 &node);
  137.  
  138.                                 treebuilder->tree_handler->unref_node(
  139.                                                 treebuilder->tree_handler->ctx,
  140.                                                 node);
  141.                         } else {
  142.                                 /** \todo parse error */
  143.                         }
  144.                 } else if (type == SELECT) {
  145.                         if (element_in_scope(treebuilder, SELECT, true)) {
  146.                                 element_stack_pop_until(treebuilder,
  147.                                                 SELECT);
  148.                                 reset_insertion_mode(treebuilder);
  149.                         } else {
  150.                                 /* fragment case */
  151.                                 /** \todo parse error */
  152.                         }
  153.                 }
  154.         }
  155.                 break;
  156.         case HUBBUB_TOKEN_EOF:
  157.                 break;
  158.         }
  159.  
  160.         return err;
  161. }
  162.  
  163.