/src/mupdf/source/html/html-parse.c

Source (jump to first uncovered line)
// Copyright (C) 2004-2023 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.

#include "mupdf/fitz.h"
#include "mupdf/ucdn.h"
#include "html-imp.h"

#include <string.h>
#include <stdio.h>
#include <assert.h>

enum { T, R, B, L };

#define DEFAULT_DIR FZ_BIDI_LTR

static const char *html_default_css =
"@page{margin:3em 2em}"
"a{color:#06C;text-decoration:underline}"
"address{display:block;font-style:italic}"
"b{font-weight:bold}"
"bdo{direction:rtl;unicode-bidi:bidi-override}"
"blockquote{display:block;margin:1em 40px}"
"body{display:block;margin:1em}"
"cite{font-style:italic}"
"code{font-family:monospace}"
"dd{display:block;margin:0 0 0 40px}"
"del{text-decoration:line-through}"
"div{display:block}"
"dl{display:block;margin:1em 0}"
"dt{display:block}"
"em{font-style:italic}"
"h1{display:block;font-size:2em;font-weight:bold;margin:0.67em 0;page-break-after:avoid}"
"h2{display:block;font-size:1.5em;font-weight:bold;margin:0.83em 0;page-break-after:avoid}"
"h3{display:block;font-size:1.17em;font-weight:bold;margin:1em 0;page-break-after:avoid}"
"h4{display:block;font-size:1em;font-weight:bold;margin:1.33em 0;page-break-after:avoid}"
"h5{display:block;font-size:0.83em;font-weight:bold;margin:1.67em 0;page-break-after:avoid}"
"h6{display:block;font-size:0.67em;font-weight:bold;margin:2.33em 0;page-break-after:avoid}"
"head{display:none}"
"hr{border-style:solid;border-width:1px;display:block;margin-bottom:0.5em;margin-top:0.5em;text-align:center}"
"html{display:block}"
"i{font-style:italic}"
"ins{text-decoration:underline}"
"kbd{font-family:monospace}"
"li{display:list-item}"
"menu{display:block;list-style-type:disc;margin:1em 0;padding:0 0 0 30pt}"
"ol{display:block;list-style-type:decimal;margin:1em 0;padding:0 0 0 30pt}"
"p{display:block;margin:1em 0}"
"pre{display:block;font-family:monospace;margin:1em 0;white-space:pre}"
"samp{font-family:monospace}"
"script{display:none}"
"small{font-size:0.83em}"
"strong{font-weight:bold}"
"style{display:none}"
"sub{font-size:0.83em;vertical-align:sub}"
"sup{font-size:0.83em;vertical-align:super}"
"table{display:table;border-spacing:2px}"
"tbody{display:table-row-group}"
"td{display:table-cell;padding:1px;background-color:inherit}"
"tfoot{display:table-footer-group}"
"th{display:table-cell;font-weight:bold;padding:1px;text-align:center;background-color:inherit}"
"thead{display:table-header-group}"
"tr{display:table-row}"
"ul{display:block;list-style-type:disc;margin:1em 0;padding:0 0 0 30pt}"
"ul ul{list-style-type:circle}"
"ul ul ul{list-style-type:square}"
"var{font-style:italic}"
"colgroup{display:table-column-group}"
"col{display:table-column}"
"caption{display:block;text-align:center}"
;

static const char *mobi_default_css =
"pagebreak{display:block;page-break-before:always}"
"dl,ol,ul{margin:0}"
"p{margin:0}"
"blockquote{margin:0 40px}"
"center{display:block;text-align:center}"
"big{font-size:1.17em}"
"strike{text-decoration:line-through}"
;

static const char *fb2_default_css =
"@page{margin:3em 2em}"
"FictionBook{display:block;margin:1em}"
"stylesheet,binary{display:none}"
"description>*{display:none}"
"description>title-info{display:block}"
"description>title-info>*{display:none}"
"description>title-info>coverpage{display:block;page-break-before:always;page-break-after:always}"
"body,section,title,subtitle,p,cite,epigraph,text-author,date,poem,stanza,v,empty-line{display:block}"
"image{display:block}"
"p>image{display:inline}"
"table{display:table}"
"tr{display:table-row}"
"th,td{display:table-cell}"
"a{color:#06C;text-decoration:underline}"
"a[type=note]{font-size:small;vertical-align:super}"
"code{white-space:pre;font-family:monospace}"
"emphasis{font-style:italic}"
"strikethrough{text-decoration:line-through}"
"strong{font-weight:bold}"
"sub{font-size:small;vertical-align:sub}"
"sup{font-size:small;vertical-align:super}"
"image{margin:1em 0;text-align:center}"
"cite,poem{margin:1em 2em}"
"subtitle,epigraph,stanza{margin:1em 0}"
"title>p{text-align:center;font-size:x-large}"
"subtitle{text-align:center;font-size:large}"
"p{margin-top:1em;text-align:justify}"
"empty-line{padding-top:1em}"
"p+p{margin-top:0;text-indent:1.5em}"
"empty-line+p{margin-top:0}"
"section>title{page-break-before:always}"
;

static const char *known_html_tags[] = {
  // TODO: add known FB2 tags?
  // Sorted list of all HTML tags.
  "a", "abbr", "acronym", "address", "annotation-xml", "applet", "area",
  "article", "aside", "audio", "b", "base", "basefont", "bdi", "bdo",
  "bgsound", "big", "blink", "blockquote", "body", "br", "button",
  "canvas", "caption", "center", "cite", "code", "col", "colgroup",
  "data", "datalist", "dd", "del", "desc", "details", "dfn", "dir",
  "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure",
  "font", "footer", "foreignobject", "form", "frame", "frameset", "h1",
  "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html",
  "i", "iframe", "image", "img", "input", "ins", "isindex", "kbd",
  "keygen", "label", "legend", "li", "link", "listing", "main",
  "malignmark", "map", "mark", "marquee", "math", "menu", "menuitem",
  "meta", "meter", "mglyph", "mi", "mn", "mo", "ms", "mtext", "multicol",
  "nav", "nextid", "nobr", "noembed", "noframes", "noscript", "object",
  "ol", "optgroup", "option", "output", "p", "param", "plaintext", "pre",
  "progress", "q", "rb", "rp", "rt", "rtc", "ruby", "s", "samp",
  "script", "section", "select", "small", "source", "spacer", "span",
  "strike", "strong", "style", "sub", "summary", "sup", "svg", "table",
  "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time",
  "title", "tr", "track", "tt", "u", "ul", "var", "video", "wbr", "xmp",
};

static const char *known_fb2_tags[] = {
  "FictionBook", "a", "binary", "body", "cite", "code", "coverpage",
  "date", "description", "emphasis", "empty-line", "epigraph", "image",
  "p", "poem", "section", "stanza", "strikethrough", "strong",
  "stylesheet", "sub", "subtitle", "sup", "table", "td", "text-author",
  "th", "title", "title-info", "tr", "v",
};

static const char *find_known_html_tag(const char *tag)
{
  int l = 0;
  int r = nelem(known_html_tags) / 2 - 1;
  while (l <= r)
  {
    int m = (l + r) >> 1;
    int c = strcmp(tag, known_html_tags[m]);
    if (c < 0)
      r = m - 1;
    else if (c > 0)
      l = m + 1;
    else
      return known_html_tags[m];
  }
  return NULL;
}

static const char *find_known_fb2_tag(const char *tag)
{
  int l = 0;
  int r = nelem(known_fb2_tags) / 2 - 1;
  while (l <= r)
  {
    int m = (l + r) >> 1;
    int c = strcmp(tag, known_fb2_tags[m]);
    if (c < 0)
      r = m - 1;
    else if (c > 0)
      l = m + 1;
    else
      return known_fb2_tags[m];
  }
  return NULL;
}

struct genstate
{
  fz_pool *pool;
  fz_html_font_set *set;
  fz_archive *zip;
  fz_tree *images;
  fz_xml_doc *xml;
  int is_fb2;
  const char *base_uri;
  fz_css *css;
  int at_bol;
  fz_html_box *emit_white;
  int last_brk_cls;

  int list_counter;
  int section_depth;
  fz_bidi_direction markup_dir;
  fz_text_language markup_lang;
  char *href;

  fz_css_style_splay *styles;
};

static int iswhite(int c)
{
  return c == ' ' || c == '\t' || c == '\r' || c == '\n';
}

static int is_all_white(const char *s)
{
  while (*s)
  {
    if (!iswhite(*s))
      return 0;
    ++s;
  }
  return 1;
}

/* TODO: pool allocator for flow nodes */
/* TODO: store text by pointing to a giant buffer */

static void fz_drop_html_flow(fz_context *ctx, fz_html_flow *flow)
{
  while (flow)
  {
    fz_html_flow *next = flow->next;
    if (flow->type == FLOW_IMAGE)
      fz_drop_image(ctx, flow->content.image);
    flow = next;
  }
}

static fz_html_flow *add_flow(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box, int type, int extras)
{
  size_t size = (type == FLOW_IMAGE ? sizeof(fz_html_flow) : offsetof(fz_html_flow, content) + extras);
  fz_html_flow *flow;

  /* Shouldn't happen, but bug 705324. */
  if (top == NULL || top->type != BOX_FLOW)
    return NULL;

  flow = fz_pool_alloc(ctx, pool, size);
  flow->type = type;
  flow->expand = 0;
  flow->bidi_level = 0;
  flow->markup_lang = 0;
  flow->breaks_line = 0;
  flow->box = inline_box;
  (*top->s.build.flow_tail) = flow;
  top->s.build.flow_tail = &flow->next;
  return flow;
}

static void add_flow_space(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box)
{
  fz_html_flow *flow = add_flow(ctx, pool, top, inline_box, FLOW_SPACE, 0);
  if (flow)
    flow->expand = 1;
}

static void add_flow_break(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box)
{
  (void)add_flow(ctx, pool, top, inline_box, FLOW_BREAK, 0);
}

static void add_flow_sbreak(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box)
{
  (void)add_flow(ctx, pool, top, inline_box, FLOW_SBREAK, 0);
}

static void add_flow_shyphen(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box)
{
  (void)add_flow(ctx, pool, top, inline_box, FLOW_SHYPHEN, 0);
}

static void add_flow_word(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box, const char *a, const char *b, int lang)
{
  fz_html_flow *flow = add_flow(ctx, pool, top, inline_box, FLOW_WORD, b - a + 1);
  if (flow == NULL)
    return;
  memcpy(flow->content.text, a, b - a);
  flow->content.text[b - a] = 0;
  flow->markup_lang = lang;
}

static void add_flow_image(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box, fz_image *img)
{
  fz_html_flow *flow = add_flow(ctx, pool, top, inline_box, FLOW_IMAGE, 0);
  if (flow)
    flow->content.image = fz_keep_image(ctx, img);
}

static void add_flow_anchor(fz_context *ctx, fz_pool *pool, fz_html_box *top, fz_html_box *inline_box)
{
  (void)add_flow(ctx, pool, top, inline_box, FLOW_ANCHOR, 0);
}

fz_html_flow *fz_html_split_flow(fz_context *ctx, fz_pool *pool, fz_html_flow *flow, size_t offset)
{
  fz_html_flow *new_flow;
  char *text;
  size_t len;

  assert(flow->type == FLOW_WORD);

  if (offset == 0)
    return flow;
  text = flow->content.text;
  while (*text && offset)
  {
    int rune;
    text += fz_chartorune(&rune, text);
    offset--;
  }
  len = strlen(text);
  new_flow = fz_pool_alloc(ctx, pool, offsetof(fz_html_flow, content) + len+1);
  memcpy(new_flow, flow, offsetof(fz_html_flow, content));
  new_flow->next = flow->next;
  flow->next = new_flow;
  strcpy(new_flow->content.text, text);
  *text = 0;
  return new_flow;
}

static void flush_space(fz_context *ctx, fz_html_box *flow, int lang, struct genstate *g)
{
  static const char *space = " ";
  fz_pool *pool = g->pool;
  if (g->emit_white)
  {
    int bsp = g->emit_white->style->white_space & WS_ALLOW_BREAK_SPACE;
    if (!g->at_bol)
    {
      if (bsp)
        add_flow_space(ctx, pool, flow, g->emit_white);
      else
        add_flow_word(ctx, pool, flow, g->emit_white, space, space+1, lang);
    }
    g->emit_white = 0;
  }
}

/* pair-wise lookup table for UAX#14 linebreaks */
static const char *pairbrk[29] =
{
/*  -OCCQGNESIPPNAHIIHBBBZCWHHJJJR- */
/*  -PLPULSXYSROULLDNYAB2WMJ23LVTI- */
  "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", /* OP open punctuation */
  "_^^%%^^^^%%_____%%__^^^______", /* CL close punctuation */
  "_^^%%^^^^%%%%%__%%__^^^______", /* CP close parenthesis */
  "^^^%%%^^^%%%%%%%%%%%^^^%%%%%%", /* QU quotation */
  "%^^%%%^^^%%%%%%%%%%%^^^%%%%%%", /* GL non-breaking glue */
  "_^^%%%^^^_______%%__^^^______", /* NS nonstarters */
  "_^^%%%^^^______%%%__^^^______", /* EX exclamation/interrogation */
  "_^^%%%^^^__%_%__%%__^^^______", /* SY symbols allowing break after */
  "_^^%%%^^^__%%%__%%__^^^______", /* IS infix numeric separator */
  "%^^%%%^^^__%%%%_%%__^^^%%%%%_", /* PR prefix numeric */
  "%^^%%%^^^__%%%__%%__^^^______", /* PO postfix numeric */
  "%^^%%%^^^%%%%%_%%%__^^^______", /* NU numeric */
  "%^^%%%^^^__%%%_%%%__^^^______", /* AL ordinary alphabetic and symbol characters */
  "%^^%%%^^^__%%%_%%%__^^^______", /* HL hebrew letter */
  "_^^%%%^^^_%____%%%__^^^______", /* ID ideographic */
  "_^^%%%^^^______%%%__^^^______", /* IN inseparable characters */
  "_^^%_%^^^__%____%%__^^^______", /* HY hyphens */
  "_^^%_%^^^_______%%__^^^______", /* BA break after */
  "%^^%%%^^^%%%%%%%%%%%^^^%%%%%%", /* BB break before */
  "_^^%%%^^^_______%%_^^^^______", /* B2 break opportunity before and after */
  "____________________^________", /* ZW zero width space */
  "%^^%%%^^^__%%%_%%%__^^^______", /* CM combining mark */
  "%^^%%%^^^%%%%%%%%%%%^^^%%%%%%", /* WJ word joiner */
  "_^^%%%^^^_%____%%%__^^^___%%_", /* H2 hangul leading/vowel syllable */
  "_^^%%%^^^_%____%%%__^^^____%_", /* H3 hangul leading/vowel/trailing syllable */
  "_^^%%%^^^_%____%%%__^^^%%%%__", /* JL hangul leading jamo */
  "_^^%%%^^^_%____%%%__^^^___%%_", /* JV hangul vowel jamo */
  "_^^%%%^^^_%____%%%__^^^____%_", /* JT hangul trailing jamo */
  "_^^%%%^^^_______%%__^^^_____%", /* RI regional indicator */
};

static fz_html_box *
find_flow_encloser(fz_context *ctx, fz_html_box *flow)
{
  /* This code was written to assume that there will always be a
   * flow box enclosing callers of this. Bug 705324 shows that
   * this isn't always the case. In the absence of a reproducer
   * file, all I can do is try to patch around the issue so that
   * we won't crash. */
  while (flow->type != BOX_FLOW)
  {
    if (flow->up == NULL)
    {
      fz_warn(ctx, "Flow encloser not found. Please report this file!");
      break;
    }
    flow = flow->up;
  }
  return flow;
}

static void generate_text(fz_context *ctx, fz_html_box *box, const char *text, int lang, struct genstate *g)
{
  fz_html_box *flow;
  fz_pool *pool = g->pool;
  int collapse = box->style->white_space & WS_COLLAPSE;
  int bsp = box->style->white_space & WS_ALLOW_BREAK_SPACE;
  int bnl = box->style->white_space & WS_FORCE_BREAK_NEWLINE;

  static const char *space = " ";

  flow = find_flow_encloser(ctx, box);
  if (flow == NULL)
    return;

  while (*text)
  {
    if (bnl && (*text == '\n' || *text == '\r'))
    {
      if (text[0] == '\r' && text[1] == '\n')
        text += 2;
      else
        text += 1;
      add_flow_break(ctx, pool, flow, box);
      g->at_bol = 1;
    }
    else if (iswhite(*text))
    {
      if (collapse)
      {
        if (bnl)
          while (*text == ' ' || *text == '\t')
            ++text;
        else
          while (iswhite(*text))
            ++text;
        g->emit_white = box;
      }
      else
      {
        // TODO: tabs
        if (bsp)
          add_flow_space(ctx, pool, flow, box);
        else
          add_flow_word(ctx, pool, flow, box, space, space+1, lang);
        ++text;
      }
      g->last_brk_cls = UCDN_LINEBREAK_CLASS_WJ; /* don't add sbreaks after a space */
    }
    else
    {
      const char *prev, *mark = text;
      int c;

      flush_space(ctx, flow, lang, g);

      if (g->at_bol)
        g->last_brk_cls = UCDN_LINEBREAK_CLASS_WJ;

      while (*text && !iswhite(*text))
      {
        prev = text;
        text += fz_chartorune(&c, text);
        if (c == 0xAD) /* soft hyphen */
        {
          if (mark != prev)
            add_flow_word(ctx, pool, flow, box, mark, prev, lang);
          add_flow_shyphen(ctx, pool, flow, box);
          mark = text;
          g->last_brk_cls = UCDN_LINEBREAK_CLASS_WJ; /* don't add sbreaks after a soft hyphen */
        }
        else if (bsp) /* allow soft breaks */
        {
          int this_brk_cls = ucdn_get_resolved_linebreak_class(c);
          if (this_brk_cls < UCDN_LINEBREAK_CLASS_RI)
          {
            int brk = pairbrk[g->last_brk_cls][this_brk_cls];

            /* we handle spaces elsewhere, so ignore these classes */
            if (brk == '@') brk = '^';
            if (brk == '#') brk = '^';
            if (brk == '%') brk = '^';

            if (brk == '_')
            {
              if (mark != prev)
                add_flow_word(ctx, pool, flow, box, mark, prev, lang);
              add_flow_sbreak(ctx, pool, flow, box);
              mark = prev;
            }

            g->last_brk_cls = this_brk_cls;
          }
        }
      }
      if (mark != text)
        add_flow_word(ctx, pool, flow, box, mark, text, lang);

      g->at_bol = 0;
    }
  }
}

static fz_image *load_html_image(fz_context *ctx, fz_archive *zip, const char *base_uri, const char *src)
{
  char path[2048];
  fz_image *img = NULL;
  fz_buffer *buf = NULL;

  fz_var(img);
  fz_var(buf);

  fz_try(ctx)
  {
    if (!strncmp(src, "data:image/jpeg;base64,", 23))
      buf = fz_new_buffer_from_base64(ctx, src+23, 0);
    else if (!strncmp(src, "data:image/png;base64,", 22))
      buf = fz_new_buffer_from_base64(ctx, src+22, 0);
    else if (!strncmp(src, "data:image/gif;base64,", 22))
      buf = fz_new_buffer_from_base64(ctx, src+22, 0);
    else
    {
      fz_strlcpy(path, base_uri, sizeof path);
      fz_strlcat(path, "/", sizeof path);
      fz_strlcat(path, src, sizeof path);
      fz_urldecode(path);
      fz_cleanname(path);
      buf = fz_read_archive_entry(ctx, zip, path);
    }
#if FZ_ENABLE_SVG
    if (strstr(src, ".svg"))
      img = fz_new_image_from_svg(ctx, buf, base_uri, zip);
    else
#endif
      img = fz_new_image_from_buffer(ctx, buf);
  }
  fz_always(ctx)
    fz_drop_buffer(ctx, buf);
  fz_catch(ctx)
  {
    fz_ignore_error(ctx);
    fz_warn(ctx, "html: cannot load image src='%s'", src);
  }

  return img;
}

static fz_image *load_svg_image(fz_context *ctx, fz_archive *zip, const char *base_uri,
  fz_xml_doc *xmldoc, fz_xml *node)
{
  fz_image *img = NULL;
#if FZ_ENABLE_SVG
  fz_try(ctx)
    img = fz_new_image_from_svg_xml(ctx, xmldoc, node, base_uri, zip);
  fz_catch(ctx)
  {
    fz_ignore_error(ctx);
    fz_warn(ctx, "html: cannot load embedded svg document");
  }
#endif
  return img;
}

static void generate_image(fz_context *ctx, fz_html_box *box, fz_image *img, struct genstate *g)
{
  fz_html_box *flow;
  fz_pool *pool = g->pool;

  flow = find_flow_encloser(ctx, box);

  flush_space(ctx, flow, 0, g);

  if (!img)
  {
    const char *alt = "[image]";
    add_flow_word(ctx, pool, flow, box, alt, alt + 7, 0);
  }
  else
  {
    fz_try(ctx)
    {
      add_flow_sbreak(ctx, pool, flow, box);
      add_flow_image(ctx, pool, flow, box, img);
      add_flow_sbreak(ctx, pool, flow, box);
    }
    fz_always(ctx)
    {
      fz_drop_image(ctx, img);
    }
    fz_catch(ctx)
      fz_rethrow(ctx);
  }

  g->at_bol = 0;
}

static void fz_drop_html_box(fz_context *ctx, fz_html_box *box)
{
  while (box)
  {
    fz_html_box *next = box->next;
    if (box->type == BOX_FLOW)
      fz_drop_html_flow(ctx, box->u.flow.head);
    fz_drop_html_box(ctx, box->down);
    box = next;
  }
}

static void fz_drop_html_imp(fz_context *ctx, fz_storable *stor)
{
  fz_html *html = (fz_html *)stor;
  fz_drop_html_box(ctx, html->tree.root);
  fz_drop_pool(ctx, html->tree.pool);
}

static void fz_drop_story_imp(fz_context *ctx, fz_storable *stor)
{
  fz_story *story = (fz_story *)stor;
  fz_free(ctx, story->user_css);
  fz_drop_html_font_set(ctx, story->font_set);
  fz_drop_xml(ctx, story->dom);
  fz_drop_html_box(ctx, story->tree.root);
  fz_drop_buffer(ctx, story->warnings);
  fz_drop_archive(ctx, story->zip);
  /* The pool must be the last thing dropped. */
  fz_drop_pool(ctx, story->tree.pool);
}

/* Drop a structure derived from an html_tree. The exact things
 * freed here will depend upon the drop function with which it
 * was created. */
static void
fz_drop_html_tree(fz_context *ctx, fz_html_tree *tree)
{
  fz_defer_reap_start(ctx);
  fz_drop_storable(ctx, &tree->storable);
  fz_defer_reap_end(ctx);
}

void fz_drop_html(fz_context *ctx, fz_html *html)
{
  fz_drop_html_tree(ctx, &html->tree);
}

void fz_drop_story(fz_context *ctx, fz_story *story)
{
  if (!story)
    return;

  fz_drop_html_tree(ctx, &story->tree);
}

fz_html *fz_keep_html(fz_context *ctx, fz_html *html)
{
  return fz_keep_storable(ctx, &html->tree.storable);
}

static fz_html_box *new_box(fz_context *ctx, struct genstate *g, fz_xml *node, int type, fz_css_style *style)
{
  fz_html_box *box;
  const char *tag = fz_xml_tag(node);
  const char *id = fz_xml_att(node, "id");
  const char *href;

  if (type == BOX_INLINE)
    box = fz_pool_alloc(ctx, g->pool, offsetof(fz_html_box, u));
  else if (type == BOX_FLOW)
    box = fz_pool_alloc(ctx, g->pool, offsetof(fz_html_box, u) + sizeof(box->u.flow));
  else
    box = fz_pool_alloc(ctx, g->pool, offsetof(fz_html_box, u) + sizeof(box->u.block));

  box->type = type;
  box->is_first_flow = 0;
  box->markup_dir = g->markup_dir;
  box->heading = 0;
  box->list_item = 0;

  box->style = fz_css_enlist(ctx, style, &g->styles, g->pool);

  if (tag)
  {
    box->tag = find_known_html_tag(tag);
    if (!box->tag && g->is_fb2)
      box->tag = find_known_fb2_tag(tag);
    if (!box->tag)
      box->tag = fz_pool_strdup(ctx, g->pool, tag);
  }
  else
  {
    box->tag = "#anon";
  }

  if (id)
    box->id = fz_pool_strdup(ctx, g->pool, id);

  if (tag && tag[0]=='a' && tag[1]==0)
  {
    // Support deprecated anchor syntax with id in "name" instead of "id" attribute.
    if (!id)
    {
      const char *name = fz_xml_att(node, "name");
      if (name)
        box->id = fz_pool_strdup(ctx, g->pool, name);
    }

    if (g->is_fb2)
    {
      href = fz_xml_att(node, "l:href");
      if (!href)
        href = fz_xml_att(node, "xlink:href");
    }
    else
    {
      href = fz_xml_att(node, "href");
    }
    if (href)
      g->href = fz_pool_strdup(ctx, g->pool, href);
  }

  if (g->href)
    box->href = g->href;

  if (type == BOX_FLOW)
  {
    box->u.flow.head = NULL;
    box->s.build.flow_tail = &box->u.flow.head;
  }

  return box;
}

static void append_box(fz_context *ctx, fz_html_box *parent, fz_html_box *child)
{
  child->up = parent;
  if (!parent->down)
    parent->down = child;
  if (parent->s.build.last_child)
    parent->s.build.last_child->next = child;
  parent->s.build.last_child = child;
}

static fz_html_box *find_block_context(fz_context *ctx, fz_html_box *box)
{
  while (box->type != BOX_BLOCK && box->type != BOX_TABLE_CELL)
    box = box->up;
  return box;
}

static fz_html_box *find_table_row_context(fz_context *ctx, fz_html_box *box)
{
  fz_html_box *look = box;
  while (look && look->type != BOX_TABLE)
    look = look->up;
  if (look)
    return look;
  fz_warn(ctx, "table-row not inside table element");
  return NULL;
}

static fz_html_box *find_table_cell_context(fz_context *ctx, fz_html_box *box)
{
  fz_html_box *look = box;
  while (look && look->type != BOX_TABLE_ROW)
    look = look->up;
  if (look)
    return look;
  fz_warn(ctx, "table-cell not inside table-row element");
  return NULL;
}

static fz_html_box *find_inline_context(fz_context *ctx, struct genstate *g, fz_html_box *box)
{
  fz_css_style style;
  fz_html_box *flow_box;

  if (box->type == BOX_FLOW || box->type == BOX_INLINE)
    return box;

  // We have an inline element that is not in an existing flow/inline context.

  // Find the closest block level box to insert content into.
  while (box->type != BOX_BLOCK && box->type != BOX_TABLE_CELL)
    box = box->up;

  // Concatenate onto the last open flow box if we have one.
  if (box->s.build.last_child && box->s.build.last_child->type == BOX_FLOW)
    return box->s.build.last_child;

  // No flow box found, create and insert one!

  // TODO: null style instead of default for flow box?
  fz_default_css_style(ctx, &style);
  flow_box = new_box(ctx, g, NULL, BOX_FLOW, &style);
  flow_box->is_first_flow = !box->down;
  g->at_bol = 1;

  append_box(ctx, box, flow_box);

  return flow_box;
}

static void gen2_children(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *root_node, fz_css_match *root_match);

static void gen2_text(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node)
{
  fz_html_box *anon_box;
  fz_css_style style;
  const char *text;
  int collapse;

  text = fz_xml_text(node);
  collapse = root_box->style->white_space & WS_COLLAPSE;
  if (collapse && is_all_white(text))
  {
    g->emit_white = root_box;
  }
  else
  {
    if (root_box->type != BOX_INLINE)
    {
      /* Create anonymous inline box, with the same style as the top block box. */
      style = *root_box->style;

      // Make sure not to recursively multiply font sizes
      style.font_size.value = 1;
      style.font_size.unit = N_SCALE;

      root_box = find_inline_context(ctx, g, root_box);
      anon_box = new_box(ctx, g, NULL, BOX_INLINE, &style);
      append_box(ctx, root_box, anon_box);
      root_box = anon_box;
    }

    generate_text(ctx, root_box, text, g->markup_lang, g);
  }
}

static fz_html_box *gen2_inline(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, fz_css_style *style)
{
  fz_html_box *this_box;
  fz_html_box *flow_box;
  root_box = find_inline_context(ctx, g, root_box);
  this_box = new_box(ctx, g, node, BOX_INLINE, style);
  append_box(ctx, root_box, this_box);
  if (this_box->id)
  {
    flow_box = find_flow_encloser(ctx, this_box);
    add_flow_anchor(ctx, g->pool, flow_box, this_box);
  }
  return this_box;
}

static void gen2_break(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node)
{
  fz_html_box *this_box;
  fz_html_box *flow_box;

  if (root_box->type != BOX_INLINE)
  {
    /* Create inline box to hold the <br> tag, with the same style as containing block. */
    /* Make sure not to recursively multiply font sizes. */
    fz_css_style style = *root_box->style;
    style.font_size.value = 1;
    style.font_size.unit = N_SCALE;
    this_box = new_box(ctx, g, node, BOX_INLINE, &style);
    append_box(ctx, find_inline_context(ctx, g, root_box), this_box);
  }
  else
  {
    this_box = root_box;
  }

  flow_box = find_flow_encloser(ctx, this_box);
  add_flow_break(ctx, g->pool, flow_box, this_box);
  g->at_bol = 1;
}

static fz_html_box *gen2_block(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, fz_css_style *style)
{
  fz_html_box *this_box;
  root_box = find_block_context(ctx, root_box);
  this_box = new_box(ctx, g, node, BOX_BLOCK, style);
  append_box(ctx, root_box, this_box);
  return this_box;
}

static fz_html_box *gen2_table(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, fz_css_style *style)
{
  fz_html_box *this_box;
  root_box = find_block_context(ctx, root_box);
  this_box = new_box(ctx, g, node, BOX_TABLE, style);
  append_box(ctx, root_box, this_box);
  return this_box;
}

static fz_html_box *gen2_table_row(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, fz_css_style *style)
{
  fz_html_box *this_box, *table_box;

  table_box = find_table_row_context(ctx, root_box);
  if (!table_box)
    return gen2_block(ctx, g, root_box, node, style);

  this_box = new_box(ctx, g, node, BOX_TABLE_ROW, style);
  append_box(ctx, table_box, this_box);
  return this_box;
}

static fz_html_box *gen2_table_cell(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, fz_css_style *style)
{
  fz_html_box *this_box, *row_box;

  row_box = find_table_cell_context(ctx, root_box);
  if (!row_box)
    return gen2_block(ctx, g, root_box, node, style);

  this_box = new_box(ctx, g, node, BOX_TABLE_CELL, style);
  append_box(ctx, row_box, this_box);
  return this_box;
}

static void gen2_image_common(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, fz_image *img, int display, fz_css_style *style)
{
  fz_html_box *img_block_box;
  fz_html_box *img_inline_box;

  if (display == DIS_INLINE || display == DIS_INLINE_BLOCK)
  {
    root_box = find_inline_context(ctx, g, root_box);
    img_inline_box = new_box(ctx, g, node, BOX_INLINE, style);
    append_box(ctx, root_box, img_inline_box);
    generate_image(ctx, img_inline_box, img, g);
  }
  else
  {
    root_box = find_block_context(ctx, root_box);
    img_block_box = new_box(ctx, g, node, BOX_BLOCK, style);
    append_box(ctx, root_box, img_block_box);

    root_box = find_inline_context(ctx, g, img_block_box);
    img_inline_box = new_box(ctx, g, NULL, BOX_INLINE, style);
    append_box(ctx, root_box, img_inline_box);
    generate_image(ctx, img_inline_box, img, g);
  }
}

static void gen2_image_html(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, int display, fz_css_style *style)
{
  const char *src = fz_xml_att(node, "src");
  if (src)
  {
    fz_css_style local_style = *style;
    fz_image *img;
    int w, h;
    const char *w_att = fz_xml_att(node, "width");
    const char *h_att = fz_xml_att(node, "height");

    if (w_att && (w = fz_atoi(w_att)) > 0)
    {
      local_style.width.value = w;
      local_style.width.unit = strchr(w_att, '%') ? N_PERCENT : N_LENGTH;
    }
    if (h_att && (h = fz_atoi(h_att)) > 0)
    {
      local_style.height.value = h;
      local_style.height.unit = strchr(h_att, '%') ? N_PERCENT : N_LENGTH;
    }

    img = load_html_image(ctx, g->zip, g->base_uri, src);
    gen2_image_common(ctx, g, root_box, node, img, display, &local_style);
  }
}

static void gen2_image_fb2(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, int display, fz_css_style *style)
{
  const char *src = fz_xml_att(node, "l:href");
  if (!src)
    src = fz_xml_att(node, "xlink:href");
  if (src && src[0] == '#')
  {
    fz_image *img = fz_tree_lookup(ctx, g->images, src+1);
    gen2_image_common(ctx, g, root_box, node, fz_keep_image(ctx, img), display, style);
  }
}

static void gen2_image_svg(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node, int display, fz_css_style *style)
{
  fz_image *img = load_svg_image(ctx, g->zip, g->base_uri, g->xml, node);
  gen2_image_common(ctx, g, root_box, node, img, display, style);
}

static int get_heading_from_tag(fz_context *ctx, struct genstate *g, const char *tag)
{
  if (tag[0] == 'h' && tag[1] != 0 && tag[2] == 0)
  {
    switch (tag[1])
    {
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    }
  }
  if (g->is_fb2)
  {
    if (!strcmp(tag, "title") || !strcmp(tag, "subtitle"))
      return fz_mini(g->section_depth, 6);
  }
  return 0;
}

static void gen2_tag(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *node,
  fz_css_match *match, int display, fz_css_style *style)
{
  fz_html_box *this_box;
  const char *tag;
  const char *lang_att;
  const char *dir_att;

  int save_markup_dir = g->markup_dir;
  int save_markup_lang = g->markup_lang;
  char *save_href = g->href;

  if (display == DIS_NONE)
    return;

  tag = fz_xml_tag(node);

  dir_att = fz_xml_att(node, "dir");
  if (dir_att)
  {
    if (!strcmp(dir_att, "auto"))
      g->markup_dir = FZ_BIDI_NEUTRAL;
    else if (!strcmp(dir_att, "rtl"))
      g->markup_dir = FZ_BIDI_RTL;
    else if (!strcmp(dir_att, "ltr"))
      g->markup_dir = FZ_BIDI_LTR;
    else
      g->markup_dir = DEFAULT_DIR;
  }

  lang_att = fz_xml_att(node, "lang");
  if (lang_att)
    g->markup_lang = fz_text_language_from_string(lang_att);

  switch (display)
  {
  case DIS_INLINE_BLOCK:
    // TODO handle inline block as a flow node
    this_box = gen2_block(ctx, g, root_box, node, style);
    break;

  case DIS_BLOCK:
    this_box = gen2_block(ctx, g, root_box, node, style);
    this_box->heading = get_heading_from_tag(ctx, g, tag);
    break;

  case DIS_LIST_ITEM:
    this_box = gen2_block(ctx, g, root_box, node, style);
    this_box->list_item = ++g->list_counter;
    break;

  // TODO: https://www.w3.org/TR/CSS2/tables.html#anonymous-boxes
  //
  // The table generation code should insert and create anonymous boxes
  // for any missing child/parent elements.
  //
  // MISSING CHILDREN:
  // 1: Wrap consecutive BLOCK found in a TABLE in an anon TABLE_ROW.
  // 2: Wrap consecutive BLOCK found in a TABLE_ROW in an anon TABLE_CELL.
  //
  // MISSING PARENTS:
  // 1: Wrap consecutive TABLE_CELL found outside TABLE_ROW in an anon TABLE_ROW
  // 2: Wrap consecutive TABLE_ROW found outside TABLE in an anon TABLE
  //
  // For now we ignore this and treat any such elements that are out of
  // context as plain block elements.

  case DIS_TABLE:
    this_box = gen2_table(ctx, g, root_box, node, style);
    break;
  case DIS_TABLE_GROUP:
    // no box for table-row-group elements
    this_box = root_box;
    break;
  case DIS_TABLE_ROW:
    this_box = gen2_table_row(ctx, g, root_box, node, style);
    break;
  case DIS_TABLE_CELL:
    this_box = gen2_table_cell(ctx, g, root_box, node, style);
    break;

  case DIS_INLINE:
  default:
    this_box = gen2_inline(ctx, g, root_box, node, style);
    break;
  }

  if (tag && !strcmp(tag, "ol"))
  {
    int save_list_counter = g->list_counter;
    g->list_counter = 0;
    gen2_children(ctx, g, this_box, node, match);
    g->list_counter = save_list_counter;
  }
  else if (tag && !strcmp(tag, "section"))
  {
    int save_section_depth = g->section_depth;
    g->section_depth++;
    gen2_children(ctx, g, this_box, node, match);
    g->section_depth = save_section_depth;
  }
  else
  {
    gen2_children(ctx, g, this_box, node, match);
  }

  g->markup_dir = save_markup_dir;
  g->markup_lang = save_markup_lang;
  g->href = save_href;
}

static void gen2_children(fz_context *ctx, struct genstate *g, fz_html_box *root_box, fz_xml *root_node, fz_css_match *root_match)
{
  fz_xml *node;
  const char *tag;
  fz_css_match match;
  fz_css_style style;
  int display;

  for (node = fz_xml_down(root_node); node; node = fz_xml_next(node))
  {
    tag = fz_xml_tag(node);
    if (tag)
    {
      fz_match_css(ctx, &match, root_match, g->css, node);
      fz_apply_css_style(ctx, g->set, &style, &match);
      display = fz_get_css_match_display(&match);
      if (tag[0]=='b' && tag[1]=='r' && tag[2]==0)
      {
        gen2_break(ctx, g, root_box, node);
      }
      else if (tag[0]=='i' && tag[1]=='m' && tag[2]=='g' && tag[3]==0)
      {
        gen2_image_html(ctx, g, root_box, node, display, &style);
      }
      else if (g->is_fb2 && tag[0]=='i' && tag[1]=='m' && tag[2]=='a' && tag[3]=='g' && tag[4]=='e' && tag[5]==0)
      {
        gen2_image_fb2(ctx, g, root_box, node, display, &style);
      }
      else if (tag[0]=='s' && tag[1]=='v' && tag[2]=='g' && tag[3]==0)
      {
        gen2_image_svg(ctx, g, root_box, node, display, &style);
      }
      else
      {
        gen2_tag(ctx, g, root_box, node, &match, display, &style);
      }
    }
    else
    {
      gen2_text(ctx, g, root_box, node);
    }
  }
}

static char *concat_text(fz_context *ctx, fz_xml *root)
{
  fz_xml *node;
  size_t i = 0, n = 1;
  char *s;
  for (node = fz_xml_down(root); node; node = fz_xml_next(node))
  {
    const char *text = fz_xml_text(node);
    n += text ? strlen(text) : 0;
  }
  s = Memento_label(fz_malloc(ctx, n), "concat_html");
  for (node = fz_xml_down(root); node; node = fz_xml_next(node))
  {
    const char *text = fz_xml_text(node);
    if (text)
    {
      n = strlen(text);
      memcpy(s+i, text, n);
      i += n;
    }
  }
  s[i] = 0;
  return s;
}

static void
html_load_css_link(fz_context *ctx, fz_html_font_set *set, fz_archive *zip, const char *base_uri, fz_css *css, fz_xml *root, const char *href)
{
  char path[2048];
  char css_base_uri[2048];
  fz_buffer *buf;

  fz_var(buf);

  fz_strlcpy(path, base_uri, sizeof path);
  fz_strlcat(path, "/", sizeof path);
  fz_strlcat(path, href, sizeof path);
  fz_urldecode(path);
  fz_cleanname(path);

  fz_dirname(css_base_uri, path, sizeof css_base_uri);

  buf = NULL;
  fz_try(ctx)
  {
    buf = fz_read_archive_entry(ctx, zip, path);
    fz_parse_css(ctx, css, fz_string_from_buffer(ctx, buf), path);
    fz_add_css_font_faces(ctx, set, zip, css_base_uri, css);
  }
  fz_always(ctx)
    fz_drop_buffer(ctx, buf);
  fz_catch(ctx)
  {
    fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
    fz_report_error(ctx);
    fz_warn(ctx, "ignoring stylesheet %s", path);
  }
}

static void
html_load_css(fz_context *ctx, fz_html_font_set *set, fz_archive *zip, const char *base_uri, fz_css *css, fz_xml *root)
{
  fz_xml *html, *head, *node;

  html = fz_xml_find(root, "html");
  head = fz_xml_find_down(html, "head");
  for (node = fz_xml_down(head); node; node = fz_xml_next(node))
  {
    if (fz_xml_is_tag(node, "link"))
    {
      char *rel = fz_xml_att(node, "rel");
      if (rel && !fz_strcasecmp(rel, "stylesheet"))
      {
        char *type = fz_xml_att(node, "type");
        if ((type && !strcmp(type, "text/css")) || !type)
        {
          char *href = fz_xml_att(node, "href");
          if (href)
          {
            html_load_css_link(ctx, set, zip, base_uri, css, root, href);
          }
        }
      }
    }
    else if (fz_xml_is_tag(node, "style"))
    {
      char *s = concat_text(ctx, node);
      fz_try(ctx)
      {
        fz_parse_css(ctx, css, s, "<style>");
        fz_add_css_font_faces(ctx, set, zip, base_uri, css);
      }
      fz_always(ctx)
        fz_free(ctx, s);
      fz_catch(ctx)
      {
        fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
        fz_report_error(ctx);
        fz_warn(ctx, "ignoring inline stylesheet");
      }
    }
  }
}

static void
fb2_load_css(fz_context *ctx, fz_html_font_set *set, fz_archive *zip, const char *base_uri, fz_css *css, fz_xml *root)
{
  fz_xml *fictionbook, *stylesheet;

  fictionbook = fz_xml_find(root, "FictionBook");
  stylesheet = fz_xml_find_down(fictionbook, "stylesheet");
  if (stylesheet)
  {
    char *s = concat_text(ctx, stylesheet);
    fz_try(ctx)
    {
      fz_parse_css(ctx, css, s, "<stylesheet>");
      fz_add_css_font_faces(ctx, set, zip, base_uri, css);
    }
    fz_catch(ctx)
    {
      fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
      fz_report_error(ctx);
      fz_warn(ctx, "ignoring inline stylesheet");
    }
    fz_free(ctx, s);
  }
}

static fz_tree *
load_fb2_images(fz_context *ctx, fz_xml *root)
{
  fz_xml *fictionbook, *binary;
  fz_tree *images = NULL;

  fictionbook = fz_xml_find(root, "FictionBook");
  for (binary = fz_xml_find_down(fictionbook, "binary"); binary; binary = fz_xml_find_next(binary, "binary"))
  {
    const char *id = fz_xml_att(binary, "id");
    char *b64 = NULL;
    fz_buffer *buf = NULL;
    fz_image *img = NULL;

    fz_var(b64);
    fz_var(buf);

    if (id == NULL)
    {
      fz_warn(ctx, "Skipping image with no id");
      continue;
    }

    fz_try(ctx)
    {
      b64 = concat_text(ctx, binary);
      buf = fz_new_buffer_from_base64(ctx, b64, strlen(b64));
      img = fz_new_image_from_buffer(ctx, buf);
    }
    fz_always(ctx)
    {
      fz_drop_buffer(ctx, buf);
      fz_free(ctx, b64);
    }
    fz_catch(ctx)
      fz_rethrow(ctx);

    images = fz_tree_insert(ctx, images, id, img);
  }

  return images;
}

typedef struct
{
  uint32_t *data;
  size_t cap;
  size_t len;
} uni_buf;

typedef struct
{
  fz_context *ctx;
  fz_pool *pool;
  fz_html_flow *flow;
  uni_buf *buffer;
} bidi_data;

static void fragment_cb(const uint32_t *fragment,
      size_t fragment_len,
      int bidi_level,
      int script,
      void *arg)
{
  bidi_data *data = (bidi_data *)arg;

  /* We are guaranteed that fragmentOffset will be at the beginning
   * of flow. */
  while (fragment_len > 0)
  {
    size_t len;

    if (data->flow->type == FLOW_SPACE)
    {
      len = 1;
    }
    else if (data->flow->type == FLOW_BREAK || data->flow->type == FLOW_SBREAK ||
        data->flow->type == FLOW_SHYPHEN || data->flow->type == FLOW_ANCHOR)
    {
      len = 0;
    }
    else
    {
      /* Must be text */
      len = fz_utflen(data->flow->content.text);
      if (len > fragment_len)
      {
        /* We need to split this flow box */
        (void)fz_html_split_flow(data->ctx, data->pool, data->flow, fragment_len);
        len = fz_utflen(data->flow->content.text);
      }
    }

    /* This flow box is entirely contained within this fragment. */
    data->flow->bidi_level = bidi_level;
    data->flow->script = script;
    data->flow = data->flow->next;
    fragment_len -= len;
  }
}

static fz_bidi_direction
detect_flow_directionality(fz_context *ctx, fz_pool *pool, uni_buf *buffer, fz_bidi_direction bidi_dir, fz_html_flow *flow)
{
  fz_html_flow *end = flow;
  bidi_data data;

  while (end)
  {
    int level = end->bidi_level;

    /* Gather the text from the flow up into a single buffer (at
     * least, as much of it as has the same direction markup). */
    buffer->len = 0;
    while (end && (level & 1) == (end->bidi_level & 1))
    {
      size_t len = 0;
      const char *text = "";
      int broken = 0;

      switch (end->type)
      {
      case FLOW_WORD:
        len = fz_utflen(end->content.text);
        text = end->content.text;
        break;
      case FLOW_SPACE:
        len = 1;
        text = " ";
        break;
      case FLOW_SHYPHEN:
      case FLOW_SBREAK:
        break;
      case FLOW_BREAK:
      case FLOW_IMAGE:
        broken = 1;
        break;
      }

      end = end->next;

      if (broken)
        break;

      /* Make sure the buffer is large enough */
      if (buffer->len + len > buffer->cap)
      {
        size_t newcap = buffer->cap;
        if (newcap < 128)
          newcap = 128; /* Sensible small default */

        while (newcap < buffer->len + len)
          newcap = (newcap * 3) / 2;

        buffer->data = fz_realloc_array(ctx, buffer->data, newcap, uint32_t);
        buffer->cap = newcap;
      }

      /* Expand the utf8 text into Unicode and store it in the buffer */
      while (*text)
      {
        int rune;
        text += fz_chartorune(&rune, text);
        buffer->data[buffer->len++] = rune;
      }
    }

    /* Detect directionality for the buffer */
    data.ctx = ctx;
    data.pool = pool;
    data.flow = flow;
    data.buffer = buffer;
    fz_bidi_fragment_text(ctx, buffer->data, buffer->len, &bidi_dir, fragment_cb, &data, 0 /* Flags */);
    flow = end;
  }
  return bidi_dir;
}

static void
detect_box_directionality(fz_context *ctx, fz_pool *pool, uni_buf *buffer, fz_html_box *box)
{
  while (box)
  {
    if (box->type == BOX_FLOW)
      box->markup_dir = detect_flow_directionality(ctx, pool, buffer, box->markup_dir, box->u.flow.head);
    detect_box_directionality(ctx, pool, buffer, box->down);
    box = box->next;
  }
}

static void
detect_directionality(fz_context *ctx, fz_pool *pool, fz_html_box *box)
{
  uni_buf buffer = { NULL };

  fz_try(ctx)
    detect_box_directionality(ctx, pool, &buffer, box);
  fz_always(ctx)
    fz_free(ctx, buffer.data);
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static fz_xml_doc *
parse_to_xml(fz_context *ctx, fz_buffer *buf, int try_xml, int try_html5)
{
  fz_xml_doc *xml;

  if (try_xml && try_html5)
  {
    fz_try(ctx)
      xml = fz_parse_xml(ctx, buf, 1);
    fz_catch(ctx)
    {
      if (fz_caught(ctx) == FZ_ERROR_SYNTAX)
      {
        fz_report_error(ctx);
        fz_warn(ctx, "syntax error in XHTML; retrying using HTML5 parser");
        xml = fz_parse_xml_from_html5(ctx, buf);
      }
      else
        fz_rethrow(ctx);
    }
  }
  else if (try_xml)
    xml = fz_parse_xml(ctx, buf, 1);
  else
  {
    assert(try_html5);
    xml = fz_parse_xml_from_html5(ctx, buf);
  }

  return xml;
}

static void move_background_color_style_up(fz_context *ctx, struct genstate *g, fz_html_box *root, fz_html_box *from)
{
  fz_css_color transparent = { 0, 0, 0, 0 };
  fz_css_style s1, s2;
  memcpy(&s1, root->style, sizeof s1);
  memcpy(&s2, from->style, sizeof s2);
  s1.background_color = s2.background_color;
  s2.background_color = transparent;
  root->style = fz_css_enlist(ctx, &s1, &g->styles, g->pool);
  from->style = fz_css_enlist(ctx, &s2, &g->styles, g->pool);
}

static void move_background_color_up(fz_context *ctx, struct genstate *g, fz_html_box *root)
{
  fz_html_box *html, *body;

  if (root->style->background_color.a != 0)
  {
    return;
  }

  html = root->down;
  if (html && !strcmp(html->tag, "html"))
  {
    if (html->style->background_color.a != 0)
    {
      move_background_color_style_up(ctx, g, root, html);
      return;
    }

    body = html->down;
    if (body && !strcmp(body->tag, "body"))
    {
      if (body->style->background_color.a != 0)
      {
        move_background_color_style_up(ctx, g, root, body);
        return;
      }
    }
  }
}

static void
xml_to_boxes(fz_context *ctx, fz_html_font_set *set, fz_archive *zip, const char *base_uri, const char *user_css,
  fz_xml_doc *xml, fz_html_tree *tree, char **rtitle, int try_fictionbook, int is_mobi)
{
  fz_xml *root, *node;
  char *title;

  fz_css_match root_match, match;
  struct genstate g = {0};

  g.pool = NULL;
  g.set = set;
  g.zip = zip;
  g.images = NULL;
  g.xml = xml;
  g.is_fb2 = 0;
  g.base_uri = base_uri;
  g.css = NULL;
  g.at_bol = 0;
  g.emit_white = 0;
  g.last_brk_cls = UCDN_LINEBREAK_CLASS_OP;
  g.list_counter = 0;
  g.section_depth = 0;
  g.markup_dir = FZ_BIDI_LTR;
  g.markup_lang = FZ_LANG_UNSET;
  g.href = NULL;
  g.styles = NULL;

  if (rtitle)
    *rtitle = NULL;

  root = fz_xml_root(g.xml);
  g.css = fz_new_css(ctx);

#ifndef NDEBUG
  if (fz_atoi(getenv("FZ_DEBUG_XML")))
    fz_debug_xml(root, 0);
#endif

  fz_try(ctx)
  {
    if (try_fictionbook && fz_xml_find(root, "FictionBook"))
    {
      g.is_fb2 = 1;
      fz_parse_css(ctx, g.css, fb2_default_css, "<default:fb2>");
      if (fz_use_document_css(ctx))
        fb2_load_css(ctx, g.set, g.zip, g.base_uri, g.css, root);
      g.images = load_fb2_images(ctx, root);
    }
    else if (is_mobi)
    {
      g.is_fb2 = 0;
      fz_parse_css(ctx, g.css, html_default_css, "<default:html>");
      fz_parse_css(ctx, g.css, mobi_default_css, "<default:mobi>");
      if (fz_use_document_css(ctx))
        html_load_css(ctx, g.set, g.zip, g.base_uri, g.css, root);
    }
    else
    {
      g.is_fb2 = 0;
      fz_parse_css(ctx, g.css, html_default_css, "<default:html>");
      if (fz_use_document_css(ctx))
        html_load_css(ctx, g.set, g.zip, g.base_uri, g.css, root);
    }

    if (user_css)
    {
      fz_parse_css(ctx, g.css, user_css, "<user>");
      fz_add_css_font_faces(ctx, g.set, g.zip, ".", g.css);
    }
  }
  fz_catch(ctx)
  {
    fz_drop_tree(ctx, g.images, (void(*)(fz_context*,void*))fz_drop_image);
    fz_drop_css(ctx, g.css);
    fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
    fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
    fz_report_error(ctx);
    fz_warn(ctx, "ignoring styles");
    g.css = fz_new_css(ctx);
    g.images = NULL;
  }

#ifndef NDEBUG
  if (fz_atoi(getenv("FZ_DEBUG_CSS")))
    fz_debug_css(ctx, g.css);
#endif

  fz_try(ctx)
  {
    fz_css_style style;
    int display;

    fz_match_css_at_page(ctx, &root_match, g.css);
    fz_apply_css_style(ctx, g.set, &style, &root_match);

    g.pool = tree->pool;
    g.markup_dir = DEFAULT_DIR;
    g.markup_lang = FZ_LANG_UNSET;

    // Create root node
    tree->root = new_box(ctx, &g, NULL, BOX_BLOCK, &style);
    // TODO: transfer page margins out of this hacky box

    tree->root->tag = ":root";
    tree->root->s.layout.em = 0;
    tree->root->s.layout.x = 0;
    tree->root->s.layout.y = 0;
    tree->root->s.layout.w = 0;
    tree->root->s.layout.b = 0;

    // Create document node (html).
    fz_match_css(ctx, &match, &root_match, g.css, root);
    fz_apply_css_style(ctx, g.set, &style, &match);
    display = fz_get_css_match_display(&match);
    gen2_tag(ctx, &g, tree->root, root, &match, display, &style);

    detect_directionality(ctx, g.pool, tree->root);

    if (g.is_fb2)
    {
      node = fz_xml_find(root, "FictionBook");
      node = fz_xml_find_down(node, "description");
      node = fz_xml_find_down(node, "title-info");
      node = fz_xml_find_down(node, "book-title");
      if (rtitle)
      {
        title = fz_xml_text(fz_xml_down(node));
        if (title)
          *rtitle = fz_pool_strdup(ctx, g.pool, title);
      }
    }
    else
    {
      node = fz_xml_find(root, "html");
      node = fz_xml_find_down(node, "head");
      node = fz_xml_find_down(node, "title");
      if (rtitle)
      {
        title = fz_xml_text(fz_xml_down(node));
        if (title)
          *rtitle = fz_pool_strdup(ctx, g.pool, title);
      }

      // Move html or body background-color to :root.
      move_background_color_up(ctx, &g, tree->root);
    }
  }
  fz_always(ctx)
  {
    fz_drop_tree(ctx, g.images, (void(*)(fz_context*,void*))fz_drop_image);
    fz_drop_css(ctx, g.css);
  }
  fz_catch(ctx)
  {
    if (rtitle)
    {
      fz_free(ctx, *rtitle);
      *rtitle = NULL;
    }
    /* Dropping the tree works regardless of whether the tree is part of an fz_html or not. */
    fz_drop_html_tree(ctx, tree);
    fz_rethrow(ctx);
  }
}

static const char *mobi_font_size[7] = {
  "0.67em",
  "0.83em",
  "1em",
  "1.17em",
  "1.33em",
  "1.5em",
  "1.67em",
};

static void
patch_mobi_html(fz_context *ctx, fz_pool *pool, fz_xml *node)
{
  fz_xml *down;
  char buf[500];
  while (node)
  {
    char *tag = fz_xml_tag(node);
    if (tag)
    {
      // Read MOBI attributes, convert to inline CSS style
      if (!strcmp(tag, "font"))
      {
        const char *size = fz_xml_att(node, "size");
        if (size)
        {
          if (!strcmp(size, "1")) size = mobi_font_size[0];
          else if (!strcmp(size, "2")) size = mobi_font_size[1];
          else if (!strcmp(size, "3")) size = mobi_font_size[2];
          else if (!strcmp(size, "4")) size = mobi_font_size[3];
          else if (!strcmp(size, "5")) size = mobi_font_size[4];
          else if (!strcmp(size, "6")) size = mobi_font_size[5];
          else if (!strcmp(size, "7")) size = mobi_font_size[6];
          else if (!strcmp(size, "+1")) size = mobi_font_size[3];
          else if (!strcmp(size, "+2")) size = mobi_font_size[4];
          else if (!strcmp(size, "+3")) size = mobi_font_size[5];
          else if (!strcmp(size, "+4")) size = mobi_font_size[6];
          else if (!strcmp(size, "+5")) size = mobi_font_size[6];
          else if (!strcmp(size, "+6")) size = mobi_font_size[6];
          else if (!strcmp(size, "-1")) size = mobi_font_size[1];
          else if (!strcmp(size, "-2")) size = mobi_font_size[0];
          else if (!strcmp(size, "-3")) size = mobi_font_size[0];
          else if (!strcmp(size, "-4")) size = mobi_font_size[0];
          else if (!strcmp(size, "-5")) size = mobi_font_size[0];
          else if (!strcmp(size, "-6")) size = mobi_font_size[0];
          fz_snprintf(buf, sizeof buf, "font-size:%s", size);
          fz_xml_add_att(ctx, pool, node, "style", buf);
        }
      }
      else
      {
        char *height = fz_xml_att(node, "height");
        char *width = fz_xml_att(node, "width");
        char *align = fz_xml_att(node, "align");
        if (height || width || align)
        {
          buf[0] = 0;
          if (height)
          {
            fz_strlcat(buf, "margin-top:", sizeof buf);
            fz_strlcat(buf, height, sizeof buf);
            fz_strlcat(buf, ";", sizeof buf);
          }
          if (width)
          {
            fz_strlcat(buf, "text-indent:", sizeof buf);
            fz_strlcat(buf, width, sizeof buf);
            fz_strlcat(buf, ";", sizeof buf);
          }
          if (align)
          {
            fz_strlcat(buf, "text-align:", sizeof buf);
            fz_strlcat(buf, align, sizeof buf);
            fz_strlcat(buf, ";", sizeof buf);
          }
          fz_xml_add_att(ctx, pool, node, "style", buf);
        }
        if (!strcmp(tag, "img"))
        {
          char *recindex = fz_xml_att(node, "recindex");
          if (recindex)
            fz_xml_add_att(ctx, pool, node, "src", recindex);
        }
      }
    }

    down = fz_xml_down(node);
    if (down)
      patch_mobi_html(ctx, pool, down);

    node = fz_xml_next(node);
  }
}

static void
fz_parse_html_tree(fz_context *ctx,
  fz_html_font_set *set, fz_archive *zip, const char *base_uri, fz_buffer *buf, const char *user_css,
  int try_xml, int try_html5, fz_html_tree *tree, char **rtitle, int try_fictionbook, int patch_mobi)
{
  fz_xml_doc *xml;

  if (rtitle)
    *rtitle = NULL;

  xml = parse_to_xml(ctx, buf, try_xml, try_html5);

  if (patch_mobi)
    patch_mobi_html(ctx, xml->u.doc.pool, xml);

  fz_try(ctx)
    xml_to_boxes(ctx, set, zip, base_uri, user_css, xml, tree, rtitle, try_fictionbook, patch_mobi);
  fz_always(ctx)
    fz_drop_xml(ctx, xml);
  fz_catch(ctx)
    fz_rethrow(ctx);
}

#define fz_new_derived_html_tree(CTX, TYPE, DROP) \
 ((TYPE *)Memento_label(fz_new_html_tree_of_size(CTX, sizeof(TYPE), DROP), #TYPE))

static fz_html_tree *
fz_new_html_tree_of_size(fz_context *ctx, size_t size, fz_store_drop_fn *drop)
{
  fz_pool *pool = fz_new_pool(ctx);
  fz_html_tree *tree;

  fz_try(ctx)
  {
    tree = fz_pool_alloc(ctx, pool, size);
    FZ_INIT_STORABLE(tree, 1, drop);
    tree->pool = pool;
  }
  fz_catch(ctx)
  {
    fz_drop_pool(ctx, pool);
    fz_rethrow(ctx);
  }

  return tree;
}

fz_html *
fz_parse_html(fz_context *ctx,
  fz_html_font_set *set, fz_archive *zip, const char *base_uri, fz_buffer *buf, const char *user_css,
  int try_xml, int try_html5, int patch_mobi)
{
  fz_html *html = fz_new_derived_html_tree(ctx, fz_html, fz_drop_html_imp);

  html->layout_w = 0;
  html->layout_h = 0;
  html->layout_em = 0;

  fz_try(ctx)
    fz_parse_html_tree(ctx, set, zip, base_uri, buf, user_css, try_xml, try_html5, &html->tree, &html->title, 1, patch_mobi);
  fz_catch(ctx)
  {
    fz_drop_html(ctx, html);
    fz_rethrow(ctx);
  }

  return html;
}

typedef struct
{
  int saved;
  fz_warning_cb *old;
  void *arg;
  fz_buffer *buffer;
  fz_context *ctx;
} warning_save;

static void
warn_to_buffer(void *user, const char *message)
{
  warning_save *save = (warning_save *)user;
  fz_context *ctx = save->ctx;

  fz_try(ctx)
  {
    fz_append_string(ctx, save->buffer, message);
    fz_append_byte(ctx, save->buffer, '\n');
  }
  fz_catch(ctx)
  {
    /* Silently swallow the error. */
    fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
    fz_report_error(ctx);
  }
}

static void
redirect_warnings_to_buffer(fz_context *ctx, fz_buffer *buf, warning_save *save)
{
  save->saved = 1;
  save->old = fz_warning_callback(ctx, &save->arg);
  save->buffer = buf;
  save->ctx = ctx;

  fz_flush_warnings(ctx);
  fz_set_warning_callback(ctx, warn_to_buffer, save);
}

static void
restore_warnings(fz_context *ctx, warning_save *save)
{
  if (!save->saved)
    return;

  fz_flush_warnings(ctx);
  fz_set_warning_callback(ctx, save->old, save->arg);
}

fz_story *
fz_new_story(fz_context *ctx, fz_buffer *buf, const char *user_css, float em, fz_archive *zip)
{
  fz_story *story = fz_new_derived_html_tree(ctx, fz_story, fz_drop_story_imp);
  warning_save saved = { 0 };
  fz_buffer *local_buffer = NULL;

  if (buf == NULL)
  {
    local_buffer = fz_new_buffer(ctx, 0);
    buf = local_buffer;
  }

  fz_var(local_buffer);
  fz_var(saved);

  fz_try(ctx)
  {
    story->zip = fz_keep_archive(ctx, zip);
    story->font_set = fz_new_html_font_set(ctx);
    story->em = em;
    story->user_css = user_css ? fz_strdup(ctx, user_css) : NULL;
    story->warnings = fz_new_buffer(ctx, 128);
    redirect_warnings_to_buffer(ctx, story->warnings, &saved);
    story->dom = parse_to_xml(ctx, buf, 0, 1);
  }
  fz_always(ctx)
  {
    restore_warnings(ctx, &saved);
    fz_drop_buffer(ctx, local_buffer);
  }
  fz_catch(ctx)
  {
    fz_drop_html_tree(ctx, &story->tree);
    fz_rethrow(ctx);
  }

  return story;
}

fz_html *
fz_parse_xhtml(fz_context *ctx, fz_html_font_set *set, fz_archive *zip, const char *base_uri, fz_buffer *buf, const char *user_css)
{
  /* try as XML first, fall back to HTML5 */
  return fz_parse_html(ctx, set, zip, base_uri, buf, user_css, 1, 1, 0);
}

static void indent(int level)
{
  while (level-- > 0)
    putchar('\t');
}

static void
fz_debug_html_flow(fz_context *ctx, fz_html_flow *flow, int level)
{
  fz_html_box *sbox = NULL;
  while (flow)
  {
    if (flow->box != sbox) {
      sbox = flow->box;
      indent(level);
#ifndef NDEBUG
      printf("@style <%s> em=%g font='%s'", sbox->tag, sbox->s.layout.em, fz_font_name(ctx, sbox->style->font));
#else
      printf("@style em=%g font='%s'", sbox->s.layout.em, fz_font_name(ctx, sbox->style->font));
#endif
      if (fz_font_is_serif(ctx, sbox->style->font))
        printf(" serif");
      else
        printf(" sans");
      if (fz_font_is_monospaced(ctx, sbox->style->font))
        printf(" monospaced");
      if (fz_font_is_bold(ctx, sbox->style->font))
        printf(" bold");
      if (fz_font_is_italic(ctx, sbox->style->font))
        printf(" italic");
      if (sbox->style->small_caps)
        printf(" small-caps");
      printf("\n");
    }

    indent(level);
    switch (flow->type) {
    case FLOW_WORD: printf("word "); break;
    case FLOW_SPACE: printf("space"); break;
    case FLOW_SBREAK: printf("sbrk "); break;
    case FLOW_SHYPHEN: printf("shy  "); break;
    case FLOW_BREAK: printf("break"); break;
    case FLOW_IMAGE: printf("image"); break;
    case FLOW_ANCHOR: printf("anchor"); break;
    }
    // printf(" y=%g x=%g w=%g", flow->y, flow->x, flow->w);
    if (flow->type == FLOW_IMAGE)
      printf(" h=%g", flow->h);
    if (flow->type == FLOW_WORD)
      printf(" text='%s'", flow->content.text);
    printf("\n");
    if (flow->breaks_line) {
      indent(level);
      printf("*\n");
    }

    flow = flow->next;
  }
}

fz_structure fz_html_tag_to_structure(const char *tag)
{
  if (!strcmp(tag, "body")) return FZ_STRUCTURE_DOCUMENT;
  if (!strcmp(tag, "div")) return FZ_STRUCTURE_DIV;
  if (!strcmp(tag, "span")) return FZ_STRUCTURE_SPAN;
  if (!strcmp(tag, "blockquote")) return FZ_STRUCTURE_BLOCKQUOTE;
  if (!strcmp(tag, "p")) return FZ_STRUCTURE_P;
  if (!strcmp(tag, "h1")) return FZ_STRUCTURE_H1;
  if (!strcmp(tag, "h2")) return FZ_STRUCTURE_H2;
  if (!strcmp(tag, "h3")) return FZ_STRUCTURE_H3;
  if (!strcmp(tag, "h4")) return FZ_STRUCTURE_H4;
  if (!strcmp(tag, "h5")) return FZ_STRUCTURE_H5;
  if (!strcmp(tag, "h6")) return FZ_STRUCTURE_H6;
  if (!strcmp(tag, "ol")) return FZ_STRUCTURE_LIST;
  if (!strcmp(tag, "ul")) return FZ_STRUCTURE_LIST;
  if (!strcmp(tag, "dl")) return FZ_STRUCTURE_LIST;
  if (!strcmp(tag, "li")) return FZ_STRUCTURE_LISTITEM;
  if (!strcmp(tag, "table")) return FZ_STRUCTURE_TABLE;
  if (!strcmp(tag, "tr")) return FZ_STRUCTURE_TR;
  if (!strcmp(tag, "th")) return FZ_STRUCTURE_TH;
  if (!strcmp(tag, "td")) return FZ_STRUCTURE_TD;
  if (!strcmp(tag, "thead")) return FZ_STRUCTURE_THEAD;
  if (!strcmp(tag, "tbody")) return FZ_STRUCTURE_TBODY;
  if (!strcmp(tag, "tfoot")) return FZ_STRUCTURE_TFOOT;
  return FZ_STRUCTURE_INVALID;
}

static void
fz_debug_html_box(fz_context *ctx, fz_html_box *box, int level)
{
  while (box)
  {
    indent(level);
    printf("box ");
    switch (box->type) {
    case BOX_BLOCK: printf("block"); break;
    case BOX_FLOW: printf("flow"); break;
    case BOX_INLINE: printf("inline"); break;
    case BOX_TABLE: printf("table"); break;
    case BOX_TABLE_ROW: printf("table-row"); break;
    case BOX_TABLE_CELL: printf("table-cell"); break;
    }

    printf(" <%s>", box->tag);
    // printf(" em=%g", box->em);
    // printf(" x=%g y=%g w=%g b=%g", box->x, box->y, box->w, box->b);

    if (box->is_first_flow)
      printf(" is-first-flow");
    if (box->list_item)
      printf(" list=%d", box->list_item);
    if (box->id)
      printf(" id=(%s)", box->id);
    if (box->href)
      printf(" href=(%s)", box->href);
    printf("\n");

    if (box->type == BOX_BLOCK || box->type == BOX_TABLE) {
      indent(level+1);
      printf(">margin=(%g %g %g %g)\n", box->u.block.margin[0], box->u.block.margin[1], box->u.block.margin[2], box->u.block.margin[3]);
      //indent(level+1);
      //printf(">padding=(%g %g %g %g)\n", box->u.block.padding[0], box->u.block.padding[1], box->u.block.padding[2], box->u.block.padding[3]);
      //indent(level+1);
      //printf(">border=(%g %g %g %g)\n", box->u.block.border[0], box->u.block.border[1], box->u.block.border[2], box->u.block.border[3]);
    }

    if (box->down)
      fz_debug_html_box(ctx, box->down, level + 1);
    if (box->type == BOX_FLOW) {
      indent(level+1);
      printf("flow\n");
      fz_debug_html_flow(ctx, box->u.flow.head, level + 2);
    }

    box = box->next;
  }
}

void
fz_debug_html(fz_context *ctx, fz_html_box *box)
{
  fz_debug_html_box(ctx, box, 0);
}

static size_t
fz_html_size(fz_context *ctx, fz_html *html)
{
  return html ? fz_pool_size(ctx, html->tree.pool) : 0;
}

/* Magic to make html storable. */
typedef struct {
  int refs;
  void *doc;
  int chapter_num;
} fz_html_key;

static int
fz_make_hash_html_key(fz_context *ctx, fz_store_hash *hash, void *key_)
{
  fz_html_key *key = (fz_html_key *)key_;
  hash->u.pi.ptr = key->doc;
  hash->u.pi.i = key->chapter_num;
  return 1;
}

static void *
fz_keep_html_key(fz_context *ctx, void *key_)
{
  fz_html_key *key = (fz_html_key *)key_;
  return fz_keep_imp(ctx, key, &key->refs);
}

static void
fz_drop_html_key(fz_context *ctx, void *key_)
{
  fz_html_key *key = (fz_html_key *)key_;
  if (fz_drop_imp(ctx, key, &key->refs))
  {
    fz_free(ctx, key);
  }
}

static int
fz_cmp_html_key(fz_context *ctx, void *k0_, void *k1_)
{
  fz_html_key *k0 = (fz_html_key *)k0_;
  fz_html_key *k1 = (fz_html_key *)k1_;
  return k0->doc == k1->doc && k0->chapter_num == k1->chapter_num;
}

static void
fz_format_html_key(fz_context *ctx, char *s, size_t n, void *key_)
{
  fz_html_key *key = (fz_html_key *)key_;
  fz_snprintf(s, n, "(html doc=%p, ch=%d)", key->doc, key->chapter_num);
}

static const fz_store_type fz_html_store_type =
{
  "fz_html",
  fz_make_hash_html_key,
  fz_keep_html_key,
  fz_drop_html_key,
  fz_cmp_html_key,
  fz_format_html_key,
  NULL
};

fz_html *fz_store_html(fz_context *ctx, fz_html *html, void *doc, int chapter)
{
  fz_html_key *key = NULL;
  fz_html *other_html;

  /* Stick the parsed html in the store */
  fz_var(key);

  fz_try(ctx)
  {
    key = fz_malloc_struct(ctx, fz_html_key);
    key->refs = 1;
    key->doc = doc;
    key->chapter_num = chapter;
    other_html = fz_store_item(ctx, key, html, fz_html_size(ctx, html), &fz_html_store_type);
    if (other_html)
    {
      fz_drop_html(ctx, html);
      html = other_html;
    }
  }
  fz_always(ctx)
    fz_drop_html_key(ctx, key);
  fz_catch(ctx)
  {
    /* Do nothing */
  }

  return html;
}

fz_html *fz_find_html(fz_context *ctx, void *doc, int chapter)
{
  fz_html_key key;

  key.refs = 1;
  key.doc = doc;
  key.chapter_num = chapter;
  return fz_find_item(ctx, &fz_drop_html_imp, &key, &fz_html_store_type);
}

static int
html_filter_store(fz_context *ctx, void *doc, void *key_)
{
  fz_html_key *key = (fz_html_key *)key_;

  return (doc == key->doc);
}

void fz_purge_stored_html(fz_context *ctx, void *doc)
{
  fz_filter_store(ctx, html_filter_store, doc, &fz_html_store_type);
}

static void
convert_to_boxes(fz_context *ctx, fz_story *story)
{
  warning_save saved = { 0 };

  if (story->dom == NULL)
    return;

  fz_var(saved);

  fz_try(ctx)
  {
    redirect_warnings_to_buffer(ctx, story->warnings, &saved);
    xml_to_boxes(ctx, story->font_set, story->zip, ".", story->user_css, story->dom, &story->tree, NULL, 0, 0);
  }
  fz_always(ctx)
  {
    fz_drop_xml(ctx, story->dom);
    story->dom = NULL;
    restore_warnings(ctx, &saved);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);
}

int fz_place_story(fz_context *ctx, fz_story *story, fz_rect where, fz_rect *filled)
{
  return fz_place_story_flags(ctx, story, where, filled, 0);
}

int fz_place_story_flags(fz_context *ctx, fz_story *story, fz_rect where, fz_rect *filled, int flags)
{
  float w, h;

  if (filled)
    *filled = fz_empty_rect;

  if (story == NULL || story->complete)
    return 0;

  /* Convert from XML to box model on the first attempt to place.
   * The DOM is unusable from here on in. */
  convert_to_boxes(ctx, story);

  w = where.x1 - where.x0;
  h = where.y1 - where.y0;
  /* Confusingly, we call the layout using restart_draw, not restart_place,
   * because we don't want to destroy the current values in restart_place
   * in case we have to retry later. This means the values are left in
   * the correct struct though! */
  story->restart_draw.start = story->restart_place.start;
  story->restart_draw.start_flow = story->restart_place.start_flow;
  story->restart_draw.end = NULL;
  story->restart_draw.end_flow = NULL;
  story->restart_draw.reason = FZ_HTML_RESTART_REASON_NONE;
  story->restart_draw.flags = flags;
  story->bbox = where;
  fz_restartable_layout_html(ctx, &story->tree, where.x0, where.y0, w, h, story->em, &story->restart_draw);
  story->restart_draw.start = story->restart_place.start;
  story->restart_draw.start_flow = story->restart_place.start_flow;

  if (filled)
  {
    fz_html_box *b = story->tree.root;
    filled->x0 = b->s.layout.x - b->u.block.margin[L] - b->u.block.border[L] - b->u.block.padding[L];
    filled->x1 = b->s.layout.w + b->u.block.margin[R] + b->u.block.border[R] + b->u.block.padding[R] + b->s.layout.x;
    filled->y0 = b->s.layout.y - b->u.block.margin[T] - b->u.block.border[T] - b->u.block.padding[T];
    filled->y1 = b->s.layout.b + b->u.block.margin[B] + b->u.block.border[B] + b->u.block.padding[B];
  }

#ifndef NDEBUG
  if (fz_atoi(getenv("FZ_DEBUG_HTML")))
    fz_debug_html(ctx, story->tree.root);
#endif

  if (story->restart_draw.end == NULL)
    return FZ_HTML_RESTART_REASON_NONE;
  if (story->restart_draw.reason == FZ_HTML_RESTART_REASON_LINE_WIDTH)
    return FZ_HTML_RESTART_REASON_LINE_WIDTH;
  return FZ_HTML_RESTART_REASON_LINE_HEIGHT;
}

const char *
fz_story_warnings(fz_context *ctx, fz_story *story)
{
  unsigned char *data;

  if (!story)
    return NULL;

  convert_to_boxes(ctx, story);

  fz_terminate_buffer(ctx, story->warnings);

  if (fz_buffer_storage(ctx, story->warnings, &data) == 0)
    return NULL;

  return (const char *)data;
}

Coverage Report

Created: 2024-05-20 06:23