aniani/elinks
1
0
Fork 0
mirror of https://github.com/rkd77/elinks.git synced 2024-12-04 14:46:47 -05:00
Code

[xml] Removed code related to CONFIG_XML

Browse Source
This commit is contained in:
Witold Filipczyk 2023-05-05 20:40:17 +02:00
parent 6da8ab303f
commit a445c6507a
15 changed files with 19 additions and 1204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/document/libdom/renderer.c
View File

@ -14,8 +14,8 @@
#include "document/document.h"
#include "document/renderer.h"
#include "document/libdom/mapa.h"
#include "document/libdom/renderer.h"
#include "document/plain/renderer.h"
#include "document/xml/renderer.h"
#include "ecmascript/libdom/parse.h"

4
src/document/xml/renderer.h → src/document/libdom/renderer.h
View File

@ -1,5 +1,5 @@
#ifndef EL__DOCUMENT_XML_RENDERER_H
#define EL__DOCUMENT_XML_RENDERER_H
#ifndef EL__DOCUMENT_LIBDOM_RENDERER_H
#define EL__DOCUMENT_LIBDOM_RENDERER_H
#ifdef __cplusplus
extern "C" {

2
src/document/libdom/renderer2.c
View File

@ -16,7 +16,7 @@
#include "document/html/renderer.h"
#include "document/libdom/corestrings.h"
#include "document/libdom/mapa.h"
#include "document/xml/renderer2.h"
#include "document/libdom/renderer2.h"
#include "ecmascript/libdom/parse.h"

4
src/document/xml/renderer2.h → src/document/libdom/renderer2.h
View File

@ -1,5 +1,5 @@
#ifndef EL__DOCUMENT_XML_RENDERER2_H
#define EL__DOCUMENT_XML_RENDERER2_H
#ifndef EL__DOCUMENT_LIBDOM_RENDERER2_H
#define EL__DOCUMENT_LIBDOM_RENDERER2_H
#ifdef __cplusplus
extern "C" {

10
src/document/renderer.cpp
View File

@ -21,9 +21,9 @@
#include "document/html/iframes.h"
#include "document/html/renderer.h"
#include "document/plain/renderer.h"
#ifdef CONFIG_XML
#include "document/xml/renderer.h"
#include "document/xml/renderer2.h"
#ifdef CONFIG_LIBDOM
#include "document/libdom/renderer.h"
#include "document/libdom/renderer2.h"
#endif
#include "document/renderer.h"
#include "document/view.h"
@ -259,7 +259,7 @@ render_encoded_document(struct cache_entry *cached, struct document *document)
}
}
}
#ifdef CONFIG_XML
#ifdef CONFIG_LIBDOM
if (document->options.plain && cached->content_type
&& (!c_strcasecmp("text/html", cached->content_type)
|| !c_strcasecmp("application/xhtml+xml", cached->content_type))) {
@ -293,7 +293,7 @@ render_encoded_document(struct cache_entry *cached, struct document *document)
&& (!c_strlcasecmp("text/gemini", 11, cached->content_type, -1)))
render_gemini_document(cached, document, &buffer);
else
#if defined(CONFIG_XML) && defined(CONFIG_ECMASCRIPT)
#if defined(CONFIG_LIBDOM) && defined(CONFIG_ECMASCRIPT)
if (get_opt_bool("ecmascript.enable", NULL)) {
if (encoding != ENCODING_NONE) {
done_string(&buffer);

6
src/document/xml/Makefile
View File

@ -1,6 +0,0 @@
top_builddir=../../..
include $(top_builddir)/Makefile.config
OBJS = renderer.obj renderer2.obj
include $(top_srcdir)/Makefile.lib

2
src/document/xml/meson.build
View File

@ -1,2 +0,0 @@
#subdir('html')
srcs += files('renderer.cpp', 'renderer2.cpp')

67
src/document/xml/renderer.cpp
View File

@ -1,67 +0,0 @@
/* Plain text document renderer */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "elinks.h"
#include "bookmarks/bookmarks.h"
#include "cache/cache.h"
#include "config/options.h"
#include "document/docdata.h"
#include "document/document.h"
#include "document/format.h"
#include "document/options.h"
#include "document/plain/renderer.h"
#include "document/xml/renderer.h"
#include "document/renderer.h"
#ifdef CONFIG_ECMASCRIPT
#include "ecmascript/ecmascript.h"
#endif
#include "globhist/globhist.h"
#include "intl/charsets.h"
#include "protocol/protocol.h"
#include "protocol/uri.h"
#include "terminal/color.h"
#include "terminal/draw.h"
#include "util/color.h"
#include "util/error.h"
#include "util/memory.h"
#include "util/string.h"
#include <libxml++/libxml++.h>
#include <string>
#ifndef CONFIG_LIBDOM
void
render_source_document_cxx(struct cache_entry *cached, struct document *document,
struct string *buffer)
{
char *head = empty_string_or_(cached->head);
(void)get_convert_table(head, document->options.cp,
document->options.assume_cp,
&document->cp,
&document->cp_status,
document->options.hard_assume);
if (!document->dom) {
document->dom = document_parse(document);
}
if (document->dom) {
xmlpp::Document *docu = (xmlpp::Document *)document->dom;
xmlpp::ustring text = docu->write_to_string_formatted(get_cp_mime_name(document->cp));
struct string tt;
if (init_string(&tt)) {
add_bytes_to_string(&tt, text.c_str(), text.size());
render_plain_document(cached, document, &tt);
done_string(&tt);
}
}
}
#endif

156
src/document/xml/renderer2.cpp
View File

@ -1,156 +0,0 @@
/* Plain text document renderer */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "elinks.h"
#include "bookmarks/bookmarks.h"
#include "cache/cache.h"
#include "config/options.h"
#include "document/docdata.h"
#include "document/document.h"
#include "document/format.h"
#include "document/options.h"
#include "document/html/internal.h"
#include "document/html/parser.h"
#include "document/html/parser/parse.h"
#include "document/plain/renderer.h"
#include "document/renderer.h"
#include "document/xml/renderer2.h"
#ifdef CONFIG_ECMASCRIPT
#include "ecmascript/ecmascript.h"
#endif
#include "globhist/globhist.h"
#include "intl/charsets.h"
#include "protocol/protocol.h"
#include "protocol/uri.h"
#include "terminal/color.h"
#include "terminal/draw.h"
#include "util/color.h"
#include "util/error.h"
#include "util/memory.h"
#include "util/string.h"
#include <libxml++/libxml++.h>
#include <map>
#ifndef CONFIG_LIBDOM
static void
dump_element(std::map<int, xmlpp::Element *> *mapa, struct string *buf, xmlpp::Element *element)
{
add_char_to_string(buf, '<');
(*mapa)[buf->length] = element;
add_to_string(buf, element->get_name().c_str());
auto attrs = element->get_attributes();
auto it = attrs.begin();
auto end = attrs.end();
for (;it != end; ++it) {
add_char_to_string(buf, ' ');
add_to_string(buf, (*it)->get_name().c_str());
add_char_to_string(buf, '=');
add_char_to_string(buf, '"');
add_to_string(buf, (*it)->get_value().c_str());
add_char_to_string(buf, '"');
}
add_char_to_string(buf, '>');
}
static void
walk_tree(std::map<int, xmlpp::Element *> *mapa, struct string *buf, void *nod, bool start)
{
xmlpp::Node *node = static_cast<xmlpp::Node *>(nod);
if (!node) {
return;
}
if (!start) {
const auto textNode = dynamic_cast<const xmlpp::TextNode*>(node);
if (textNode) {
add_bytes_to_string(buf, textNode->get_content().c_str(), textNode->get_content().length());
} else {
const auto cDataNode = dynamic_cast<const xmlpp::CdataNode*>(node);
if (cDataNode) {
add_bytes_to_string(buf, cDataNode->get_content().c_str(), cDataNode->get_content().length());
} else {
auto element = dynamic_cast<xmlpp::Element*>(node);
if (element) {
dump_element(mapa, buf, element);
}
}
}
}
auto childs = node->get_children();
auto it = childs.begin();
auto end = childs.end();
for (; it != end; ++it) {
walk_tree(mapa, buf, *it, false);
}
if (!start) {
const auto element = dynamic_cast<const xmlpp::Element*>(node);
if (element) {
add_to_string(buf, "</");
add_to_string(buf, element->get_name().c_str());
add_char_to_string(buf, '>');
}
}
}
void
render_xhtml_document(struct cache_entry *cached, struct document *document, struct string *buffer)
{
if (!document->dom) {
(void)get_convert_table(cached->head ?: (char *)"", document->options.cp,
document->options.assume_cp,
&document->cp,
&document->cp_status,
document->options.hard_assume);
document->dom = document_parse(document);
}
if (!document->dom) {
return;
}
assert(cached && document);
if_assert_failed return;
xmlpp::Document *doc = (xmlpp::Document *)document->dom;
xmlpp::Element* root = (xmlpp::Element *)doc->get_root_node();
if (!buffer->length) {
struct string tt;
if (!init_string(&tt)) {
return;
}
std::map<int, xmlpp::Element *> *mapa = (std::map<int, xmlpp::Element *> *)document->element_map;
if (!mapa) {
mapa = new std::map<int, xmlpp::Element *>;
document->element_map = (void *)mapa;
} else {
mapa->clear();
}
walk_tree(mapa, &tt, root, true);
*buffer = tt;
document->text = tt.source;
}
render_html_document(cached, document, buffer);
}
#endif

942
src/document/xml/tables.c
View File

@ -1,942 +0,0 @@
/* General element handlers */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifndef _GNU_SOURCE
#define _GNU_SOURCE /* strcasestr() */
#endif
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "elinks.h"
#include "config/options.h"
#include "bfu/listmenu.h"
#include "bookmarks/bookmarks.h"
#include "document/css/apply.h"
#include "document/html/frames.h"
#include "document/html/parser/link.h"
#include "document/html/parser/stack.h"
#include "document/html/parser/table.h"
#include "document/html/parser.h"
#include "document/html/renderer.h"
#include "document/html/tables.h"
#include "document/options.h"
#include "document/xml/renderer2.h"
#include "document/xml/tables.h"
#include "document/xml/tags.h"
#include "ecmascript/spidermonkey/element.h"
#include "globhist/globhist.h"
#include "intl/charsets.h"
#include "protocol/uri.h"
#include "terminal/draw.h"
#include "util/align.h"
#include "util/box.h"
#include "util/color.h"
#include "util/conv.h"
#include "util/error.h"
#include "util/memdebug.h"
#include "util/memory.h"
#include "util/string.h"
/* Unsafe macros */
#include "document/html/internal.h"
#include <stdio.h>
#include <libxml++/libxml++.h>
static void
get_bordercolor2(struct source_renderer *renderer, void *no, color_T *rgb)
{
struct html_context *html_context = renderer->html_context;
if (!use_document_fg_colors(html_context->options))
return;
xmlpp::Element *node = no;
xmlpp::ustring color = node->get_attribute_value("bordercolor");
if (color == "") {
color = node->get_attribute_value("bordercolorlight");
}
if (color == "") {
color = node->get_attribute_value("bordercolordark");
}
if (color == "") {
return;
}
char *at = memacpy(color.c_str(), color.size());
if (!at) return;
decode_color(at, strlen(at), rgb);
mem_free(at);
}
static void
tags_set_table_frame(struct source_renderer *renderer, void *no, struct table *table)
{
struct html_context *html_context = renderer->html_context;
char *al;
if (!table->border) {
table->frame = TABLE_FRAME_VOID;
return;
}
table->frame = TABLE_FRAME_BOX;
xmlpp::Element *node = no;
xmlpp::ustring frame_value = node->get_attribute_value("frame");
al = memacpy(frame_value.c_str(), frame_value.size());
if (!al) return;
if (!c_strcasecmp(al, "void")) table->frame = TABLE_FRAME_VOID;
else if (!c_strcasecmp(al, "above")) table->frame = TABLE_FRAME_ABOVE;
else if (!c_strcasecmp(al, "below")) table->frame = TABLE_FRAME_BELOW;
else if (!c_strcasecmp(al, "hsides")) table->frame = TABLE_FRAME_HSIDES;
else if (!c_strcasecmp(al, "vsides")) table->frame = TABLE_FRAME_VSIDES;
else if (!c_strcasecmp(al, "lhs")) table->frame = TABLE_FRAME_LHS;
else if (!c_strcasecmp(al, "rhs")) table->frame = TABLE_FRAME_RHS;
/* Following tests are useless since TABLE_FRAME_BOX is the default.
* else if (!c_strcasecmp(al, "box")) table->frame = TABLE_FRAME_BOX;
* else if (!c_strcasecmp(al, "border")) table->frame = TABLE_FRAME_BOX;
*/
mem_free(al);
}
static void
tags_set_table_rules(struct source_renderer *renderer, void *no, struct table *table)
{
char *al;
table->rules = table->border ? TABLE_RULE_ALL : TABLE_RULE_NONE;
xmlpp::Element *node = no;
xmlpp::ustring frame_value = node->get_attribute_value("rules");
al = memacpy(frame_value.c_str(), frame_value.size());
if (!al) return;
if (!c_strcasecmp(al, "none")) table->rules = TABLE_RULE_NONE;
else if (!c_strcasecmp(al, "groups")) table->rules = TABLE_RULE_GROUPS;
else if (!c_strcasecmp(al, "rows")) table->rules = TABLE_RULE_ROWS;
else if (!c_strcasecmp(al, "cols")) table->rules = TABLE_RULE_COLS;
else if (!c_strcasecmp(al, "all")) table->rules = TABLE_RULE_ALL;
mem_free(al);
}
static void
tags_get_align(struct source_renderer *renderer, void *no, int *a)
{
xmlpp::Element *node = no;
xmlpp::ustring align_value = node->get_attribute_value("align");
char *al = memacpy(align_value.c_str(), align_value.size());
if (!al) return;
if (!c_strcasecmp(al, "left")) *a = ALIGN_LEFT;
else if (!c_strcasecmp(al, "right")) *a = ALIGN_RIGHT;
else if (!c_strcasecmp(al, "center")) *a = ALIGN_CENTER;
else if (!c_strcasecmp(al, "justify")) *a = ALIGN_JUSTIFY;
else if (!c_strcasecmp(al, "char")) *a = ALIGN_RIGHT; /* NOT IMPLEMENTED */
mem_free(al);
}
static void
tags_get_valign(struct source_renderer *renderer, void *no, int *a)
{
xmlpp::Element *node = no;
xmlpp::ustring valign_value = node->get_attribute_value("valign");
char *al = memacpy(valign_value.c_str(), valign_value.size());
if (!al) return;
if (!c_strcasecmp(al, "top")) *a = VALIGN_TOP;
else if (!c_strcasecmp(al, "middle")) *a = VALIGN_MIDDLE;
else if (!c_strcasecmp(al, "bottom")) *a = VALIGN_BOTTOM;
else if (!c_strcasecmp(al, "baseline")) *a = VALIGN_BASELINE; /* NOT IMPLEMENTED */
mem_free(al);
}
static void
tags_get_column_width(struct source_renderer *renderer, void *no, int *width, int sh)
{
struct html_context *html_context = renderer->html_context;
xmlpp::Element *node = no;
xmlpp::ustring width_value = node->get_attribute_value("width");
char *al = memacpy(width_value.c_str(), width_value.size());
int len;
if (!al) return;
len = strlen(al);
if (len && al[len - 1] == '*') {
char *en;
int n;
al[len - 1] = '\0';
errno = 0;
n = strtoul(al, (char **) &en, 10);
if (!errno && n >= 0 && (!*en || *en == '.'))
*width = WIDTH_RELATIVE - n;
} else {
int w = get_width2(al, sh, html_context);
if (w >= 0) *width = w;
}
mem_free(al);
}
int
tags_get_bgcolor(struct source_renderer *renderer, void *no, color_T *rgb)
{
struct html_context *html_context = renderer->html_context;
if (!use_document_bg_colors(html_context->options))
return -1;
xmlpp::Element *node = no;
xmlpp::ustring bgcolor_value = node->get_attribute_value("bgcolor");
char *at = memacpy(bgcolor_value.c_str(), bgcolor_value.size());
if (!at) return -1;
int res = decode_color(at, strlen(at), rgb);
mem_free(at);
return res;
}
static void
tags_parse_table_attributes(struct source_renderer *renderer, struct table *table, void *no, int real)
{
struct html_context *html_context = renderer->html_context;
xmlpp::Element *node = no;
xmlpp::ustring id_value = node->get_attribute_value("id");
if (id_value != "") {
table->fragment_id = memacpy(id_value.c_str(), id_value.size());
}
get_bordercolor2(renderer, no, &table->color.border);
xmlpp::ustring width_value = node->get_attribute_value("width");
char *width = memacpy(width_value.c_str(), width_value.size());
table->width = get_width2(width, real, html_context);
if (table->width == -1) {
table->width = get_html_max_width();
table->full_width = 1;
}
/* From http://www.w3.org/TR/html4/struct/tables.html#adef-border-TABLE
* The following settings should be observed by user agents for
* backwards compatibility.
* Setting border="0" implies frame="void" and, unless otherwise
* specified, rules="none".
* Other values of border imply frame="border" and, unless otherwise
* specified, rules="all".
* The value "border" in the start tag of the TABLE element should be
* interpreted as the value of the frame attribute. It implies
* rules="all" and some default (non-zero) value for the border
* attribute. */
xmlpp::ustring border_value = node->get_attribute_value("border");
if (border_value != "") {
char *at = memacpy(border_value.c_str(), border_value.size());
table->border = get_num2(at);
}
if (table->border == -1) {
xmlpp::Attribute *attr = dynamic_cast<xmlpp::Attribute *>(node->get_attribute("border"));
if (!attr) {
attr = dynamic_cast<xmlpp::Attribute *>(node->get_attribute("rules"));
}
if (!attr) {
attr = dynamic_cast<xmlpp::Attribute *>(node->get_attribute("frames"));
}
table->border = (attr != nullptr);
}
if (table->border) {
int_upper_bound(&table->border, 2);
xmlpp::ustring cellspacing_value = node->get_attribute_value("cellspacing");
if (cellspacing_value != "") {
char *at = memacpy(cellspacing_value.c_str(), cellspacing_value.size());
table->cellspacing = get_num2(at);
}
int_bounds(&table->cellspacing, 1, 2);
}
tags_set_table_frame(renderer, no, table);
/* TODO: cellpadding may be expressed as a percentage, this is not
* handled yet. */
xmlpp::ustring cellpadding_value = node->get_attribute_value("cellpadding");
char *at = memacpy(cellpadding_value.c_str(), cellpadding_value.size());
table->cellpadding = get_num2(at);
if (table->cellpadding == -1) {
table->vcellpadding = 0;
table->cellpadding = !!table->border;
} else {
table->vcellpadding = (table->cellpadding >= HTML_CHAR_HEIGHT / 2 + 1);
table->cellpadding = (table->cellpadding >= HTML_CHAR_WIDTH / 2 + 1);
}
tags_set_table_rules(renderer, no, table);
table->align = par_elformat.align;
tags_get_align(renderer, no, &table->align);
table->color.background = par_elformat.color.background;
tags_get_bgcolor(renderer, no, &table->color.background);
}
#define realloc_bad_html(bad_html, size) \
mem_align_alloc(bad_html, size, (size) + 1, 0xFF)
static void
tags_add_table_bad_html_start(struct table *table, void *start)
{
if (table->caption.start_node && !table->caption.end_node)
return;
/* Either no bad html or last one not needing @end pointer */
if (table->bad_html_size
&& !table->bad_html[table->bad_html_size - 1].end_node)
return;
if (realloc_bad_html(&table->bad_html, table->bad_html_size))
table->bad_html[table->bad_html_size++].start_node = start;
}
static void
tags_add_table_bad_html_end(struct table *table, void *end)
{
if (table->caption.start_node && !table->caption.end_node) {
table->caption.end_node = end;
return;
}
if (table->bad_html_size
&& !table->bad_html[table->bad_html_size - 1].end_node)
table->bad_html[table->bad_html_size - 1].end_node = end;
}
static struct table *
tags_parse_table(struct source_renderer *renderer, void *no, int sh)
{
struct html_context *html_context = renderer->html_context;
xmlpp::Element *node = no;
struct table *table;
struct table_cell *cell;
char *t_attr, *en, *name;
char *l_fragment_id = NULL;
color_T last_bgcolor;
int namelen;
int in_cell = 0;
int l_al = ALIGN_LEFT;
int l_val = VALIGN_MIDDLE;
int colspan, rowspan;
int group = 0;
int i, j, k;
int c_al = ALIGN_TR, c_val = VALIGN_TR, c_width = WIDTH_AUTO, c_span = 0;
int cols, rows;
int col = 0, row = -1;
int maxj;
int closing_tag, is_header;
unsigned char c;
char *colspa = NULL;
char *rowspa = NULL;
xmlpp::ustring colspan_value;
xmlpp::ustring rowspan_value;
xmlpp::ustring id_value;
xmlpp::ustring name_value;
// *end = html;
table = new_table();
if (!table) return NULL;
tags_parse_table_attributes(renderer, table, no, sh);
last_bgcolor = table->color.background;
se:
// en = html;
see:
// html = en;
if (!in_cell) {
tags_add_table_bad_html_start(table, node);
}
/// while (html < eof && *html != '<') html++;
if (false) { //&& html >= eof) {
if (in_cell) CELL(table, col, row)->end_node = node;
tags_add_table_bad_html_end(table, node);
goto scan_done;
}
// if (html + 2 <= eof && (html[1] == '!' || html[1] == '?')) {
// html = skip_comment(html, eof);
// goto se;
// }
/// if (parse_element(html, eof, &name, &namelen, &t_attr, &en)) {
/// html++;
/// goto se;
/// }
name_value = node->get_name();
if (name_value == "") goto see;
name = name_value.c_str();
namelen = name_value.size();
// if (!namelen) goto see;
// if (name[0] == '/') {
// namelen--;
// if (!namelen) goto see;
// name++;
// closing_tag = 1;
//
// } else {
// closing_tag = 0;
// }
closing_tag = 0;
// if (!c_strlcasecmp(name, namelen, "TABLE", 5)) {
// if (!closing_tag) {
// en = skip_table(en, eof);
// goto see;
if (!c_strlcasecmp(name_value.c_str(), name_value.size(), "TABLE", 5)) {
if (!closing_tag) {
//en = tags_skip_table(renderer, no);
node = node->get_next_sibling();
goto see;
} else {
// if (c_span) new_columns(table, c_span, c_width, c_al, c_val, 1);
// if (in_cell) CELL(table, col, row)->end = html;
// add_table_bad_html_end(table, html);
if (c_span) new_columns(table, c_span, c_width, c_al, c_val, 1);
if (in_cell) CELL(table, col, row)->end_node = node;
tags_add_table_bad_html_end(table, node);
goto scan_done;
}
}
// if (!c_strlcasecmp(name, namelen, "CAPTION", 7)) {
// if (!closing_tag) {
// add_table_bad_html_end(table, html);
// if (!table->caption.start)
// table->caption.start = html;
// } else {
// if (table->caption.start && !table->caption.end)
// table->caption.end = html;
// }
// goto see;
// }
if (!c_strlcasecmp(name_value.c_str(), name_value.size(), "CAPTION", 7)) {
if (!closing_tag) {
tags_add_table_bad_html_end(table, node);
if (!table->caption.start_node)
table->caption.start_node = node;
} else {
if (table->caption.start_node && !table->caption.end_node)
table->caption.end_node = node;
}
goto see;
}
// if (!c_strlcasecmp(name, namelen, "COLGROUP", 8)) {
// if (c_span) new_columns(table, c_span, c_width, c_al, c_val, 1);
//
// add_table_bad_html_end(table, html);
//
// c_al = ALIGN_TR;
// c_val = VALIGN_TR;
// c_width = WIDTH_AUTO;
//
// if (!closing_tag) {
// get_align(html_context, t_attr, &c_al);
// get_valign(html_context, t_attr, &c_val);
// get_column_width(t_attr, &c_width, sh, html_context);
// c_span = get_num(t_attr, "span", html_context->doc_cp);
// if (c_span == -1)
// c_span = 1;
// else if (c_span > HTML_MAX_COLSPAN)
// c_span = HTML_MAX_COLSPAN;
//
// } else {
// c_span = 0;
// }
// goto see;
// }
if (!c_strlcasecmp(name_value.c_str(), name_value.size(), "COLGROUP", 8)) {
if (c_span) new_columns(table, c_span, c_width, c_al, c_val, 1);
tags_add_table_bad_html_end(table, node);
c_al = ALIGN_TR;
c_val = VALIGN_TR;
c_width = WIDTH_AUTO;
if (!closing_tag) {
tags_get_align(renderer, no, &c_al);
tags_get_valign(renderer, no, &c_val);
tags_get_column_width(renderer, no, &c_width, sh);
xmlpp::ustring span_value = node->get_attribute_value("span");
char *spa = memacpy(span_value.c_str(), span_value.size());
c_span = get_num2(spa);
if (c_span == -1)
c_span = 1;
else if (c_span > HTML_MAX_COLSPAN)
c_span = HTML_MAX_COLSPAN;
} else {
c_span = 0;
}
goto see;
}
// if (!closing_tag && !c_strlcasecmp(name, namelen, "COL", 3)) {
// int sp, width, al, val;
//
// add_table_bad_html_end(table, html);
//
// sp = get_num(t_attr, "span", html_context->doc_cp);
// if (sp == -1) sp = 1;
// else if (sp > HTML_MAX_COLSPAN) sp = HTML_MAX_COLSPAN;
//
// width = c_width;
// al = c_al;
// val = c_val;
// get_align(html_context, t_attr, &al);
// get_valign(html_context, t_attr, &val);
// get_column_width(t_attr, &width, sh, html_context);
// new_columns(table, sp, width, al, val, !!c_span);
// c_span = 0;
// goto see;
// }
if (!closing_tag && !c_strlcasecmp(name_value.c_str(), name_value.size(), "COL", 3)) {
int sp, width, al, val;
tags_add_table_bad_html_end(table, node);
xmlpp::ustring span_value = node->get_attribute_value("span");
char *spa = memacpy(span_value.c_str(), span_value.size());
sp = get_num2(spa);
if (sp == -1) sp = 1;
else if (sp > HTML_MAX_COLSPAN) sp = HTML_MAX_COLSPAN;
width = c_width;
al = c_al;
val = c_val;
tags_get_align(renderer, no, &al);
tags_get_valign(renderer, no, &val);
tags_get_column_width(renderer, no, &width, sh);
new_columns(table, sp, width, al, val, !!c_span);
c_span = 0;
goto see;
}
/* All following tags have T as first letter. */
if (c_toupper(name[0]) != 'T') goto see;
name++; namelen--;
if (namelen == 0) goto see;
c = c_toupper(name[0]);
/* /TR /TD /TH */
if (closing_tag && namelen == 1) {
if (c == 'R' || c == 'D' || c == 'H') {
if (c_span)
new_columns(table, c_span, c_width, c_al, c_val, 1);
if (in_cell) {
CELL(table, col, row)->end_node = node;
in_cell = 0;
}
tags_add_table_bad_html_end(table, node);
goto see;
}
}
/* Beyond that point, opening tags only. */
if (closing_tag) goto see;
/* THEAD TBODY TFOOT */
if (namelen == 4
&& ((!c_strlcasecmp(name, namelen, "HEAD", 4)) ||
(!c_strlcasecmp(name, namelen, "BODY", 4)) ||
(!c_strlcasecmp(name, namelen, "FOOT", 4)))) {
if (c_span) new_columns(table, c_span, c_width, c_al, c_val, 1);
tags_add_table_bad_html_end(table, node);
group = 2;
goto see;
}
/* Beyond this point, only two letters tags. */
if (namelen != 1) goto see;
/* TR */
if (c == 'R') {
if (c_span) new_columns(table, c_span, c_width, c_al, c_val, 1);
if (in_cell) {
CELL(table, col, row)->end_node = node;
in_cell = 0;
}
tags_add_table_bad_html_end(table, node);
if (group) group--;
l_al = ALIGN_LEFT;
l_val = VALIGN_MIDDLE;
last_bgcolor = table->color.background;
tags_get_align(renderer, no, &l_al);
tags_get_valign(renderer, no, &l_val);
tags_get_bgcolor(renderer, no, &last_bgcolor);
xmlpp::ustring id_value = node->get_attribute_value("id");
mem_free_set(&l_fragment_id, memacpy(id_value.c_str(), id_value.size()));
row++;
col = 0;
goto see;
}
/* TD TH */
is_header = (c == 'H');
if (!is_header && c != 'D')
goto see;
if (c_span) new_columns(table, c_span, c_width, c_al, c_val, 1);
tags_add_table_bad_html_end(table, node);
if (in_cell) {
CELL(table, col, row)->end_node = node;
in_cell = 0;
}
if (row == -1) {
row = 0;
col = 0;
}
for (;;col++) {
cell = new_cell(table, col, row);
if (!cell) goto see;
if (!cell->is_used) break;
if (cell->colspan == -1) goto see;
}
in_cell = 1;
cell->col = col;
cell->row = row;
cell->is_used = 1;
cell->start = en;
cell->align = l_al;
cell->valign = l_val;
id_value = node->get_attribute_value("id");
mem_free_set(&cell->fragment_id, memacpy(id_value.c_str(), id_value.size()));
// cell->fragment_id = get_attr_val(t_attr, "id", html_context->doc_cp);
if (!cell->fragment_id && l_fragment_id) {
cell->fragment_id = l_fragment_id;
l_fragment_id = NULL;
}
cell->is_header = is_header;
if (cell->is_header) cell->align = ALIGN_CENTER;
if (group == 1) cell->is_group = 1;
if (col < table->columns_count) {
if (table->columns[col].align != ALIGN_TR)
cell->align = table->columns[col].align;
if (table->columns[col].valign != VALIGN_TR)
cell->valign = table->columns[col].valign;
}
cell->bgcolor = last_bgcolor;
tags_get_align(renderer, no, &cell->align);
tags_get_valign(renderer, no, &cell->valign);
tags_get_bgcolor(renderer, no, &cell->bgcolor);
colspan_value = node->get_attribute_value("colspan");
colspa = memacpy(colspan_value.c_str(), colspan_value.size());
colspan = get_num2(colspa);
if (colspan == -1) colspan = 1;
else if (!colspan) colspan = -1;
else if (colspan > HTML_MAX_COLSPAN) colspan = HTML_MAX_COLSPAN;
rowspan_value = node->get_attribute_value("rowspan");
rowspa = memacpy(rowspan_value.c_str(), rowspan_value.size());
rowspan = get_num2(rowspa);
if (rowspan == -1) rowspan = 1;
else if (!rowspan) rowspan = -1;
else if (rowspan > HTML_MAX_ROWSPAN) rowspan = HTML_MAX_ROWSPAN;
cell->colspan = colspan;
cell->rowspan = rowspan;
if (colspan == 1) {
int width = WIDTH_AUTO;
tags_get_column_width(renderer, no, &width, sh);
if (width != WIDTH_AUTO)
set_td_width(table, col, width, 0);
}
cols = table->cols;
for (i = 1; colspan != -1 ? i < colspan : i < cols; i++) {
struct table_cell *span_cell = new_cell(table, col + i, row);
if (!span_cell)
goto abort;
if (span_cell->is_used) {
colspan = i;
for (k = 0; k < i; k++)
CELL(table, col + k, row)->colspan = colspan;
break;
}
span_cell->is_used = span_cell->is_spanned = 1;
span_cell->rowspan = rowspan;
span_cell->colspan = colspan;
span_cell->col = col;
span_cell->row = row;
}
rows = table->rows;
maxj = rowspan != -1 ? rowspan : rows;
/* Out of memory prevention, limit allocated memory to HTML_MAX_CELLS_MEMORY.
* Not perfect but better than nothing. */
if (maxj * i > HTML_MAX_CELLS_MEMORY / sizeof(*cell))
goto abort;
for (j = 1; j < maxj; j++) {
for (k = 0; k < i; k++) {
struct table_cell *span_cell = new_cell(table, col + k, row + j);
if (!span_cell)
goto abort;
if (span_cell->is_used) {
int l, m;
if (span_cell->col == col
&& span_cell->row == row)
continue;
for (l = 0; l < k; l++)
memset(CELL(table, col + l, row + j), 0,
sizeof(*span_cell));
rowspan = j;
for (l = 0; l < i; l++)
for (m = 0; m < j; m++)
CELL(table, col + l, row + m)->rowspan = j;
goto see;
}
span_cell->is_used = span_cell->is_spanned = 1;
span_cell->rowspan = rowspan;
span_cell->colspan = colspan;
span_cell->col = col;
span_cell->row = row;
}
}
goto see;
scan_done:
// *end = html;
mem_free_if(l_fragment_id);
for (col = 0; col < table->cols; col++) for (row = 0; row < table->rows; row++) {
struct table_cell *cell = CELL(table, col, row);
if (!cell->is_spanned) {
if (cell->colspan == -1) cell->colspan = table->cols - col;
if (cell->rowspan == -1) cell->rowspan = table->rows - row;
}
}
if (table->rows) {
table->rows_heights = (int *)mem_calloc(table->rows, sizeof(*table->rows_heights));
if (!table->rows_heights)
goto abort;
} else {
table->rows_heights = NULL;
}
for (col = 0; col < table->columns_count; col++)
if (table->columns[col].width != WIDTH_AUTO)
set_td_width(table, col, table->columns[col].width, 1);
set_td_width(table, table->cols, WIDTH_AUTO, 0);
return table;
abort:
// *end = eof;
free_table(table);
return NULL;
}
static void
tags_draw_table_bad_html(struct source_renderer *renderer, struct table *table)
{
struct html_context *html_context = renderer->html_context;
int i;
for (i = 0; i < table->bad_html_size; i++) {
struct html_start_end *html = &table->bad_html[i];
void *start_node = html->start_node;
void *end_node = html->end_node;
dump_dom_structure(renderer, start_node, 0);
}
}
void
tags_format_table(struct source_renderer *renderer, void *no)
{
struct html_context *html_context = renderer->html_context;
struct part *part = html_context->part;
struct table *table;
struct node *node, *new_node;
struct html_element *state;
int indent, margins;
struct string html_string;
init_string(&html_string);
walk_tree(&html_string, no, false);
char *attr = html_string.source + 1;
char *html = html_string.source;
char *eof = html_string.source + html_string.length;
char *end;
format_table(attr, html, eof, &end, html_context);
// done_string(&html_string);
#if 0
html_context->table_level++;
table = tags_parse_table(renderer, no, (part->document || part->box.x));
if (!table) goto ret0;
table->part = part;
/* XXX: This tag soup handling needs to be done outside the create
* parser state. Something to do with link numbering. */
/* It needs to be done _before_ processing the actual table, too.
* Otherwise i.e. <form> tags between <table> and <tr> are broken. */
tags_draw_table_bad_html(renderer, table);
state = init_html_parser_state(html_context, ELEMENT_DONT_KILL,
ALIGN_LEFT, 0, 0);
margins = /*par_elformat.blockquote_level + */par_elformat.leftmargin + par_elformat.rightmargin;
if (get_table_cellpadding(html_context, table)) goto ret2;
distribute_table_widths(table);
if (!part->document && part->box.x == 1) {
int total_width = table->real_width + margins;
int_bounds(&total_width, table->real_width, par_elformat.width);
int_lower_bound(&part->box.width, total_width);
part->cy += table->real_height;
goto ret2;
}
#ifdef HTML_TABLE_2ND_PASS
check_table_widths(html_context, table);
#endif
get_table_heights(html_context, table);
if (!part->document) {
int_lower_bound(&part->box.width, table->real_width + margins);
part->cy += table->real_height;
goto ret2;
}
node = part->document->nodes.next;
node->box.height = part->box.y - node->box.y + part->cy;
indent = get_table_indent(html_context, table);
/* FIXME: See bug 432. It should be possible to align the caption at
* the top, bottom or the sides. */
draw_table_caption(html_context, table, indent + part->box.x, part->box.y + part->cy);
draw_table_cells(table, indent, part->cy, html_context);
draw_table_frames(table, indent, part->cy, html_context);
part->cy += table->real_height;
part->cx = -1;
new_node = (struct node *)mem_alloc(sizeof(*new_node));
if (new_node) {
set_box(&new_node->box, node->box.x, part->box.y + part->cy,
node->box.width, 0);
add_to_list(part->document->nodes, new_node);
}
ret2:
part->link_num = table->link_num;
int_lower_bound(&part->box.height, part->cy);
html_context->part = part; /* Might've changed in draw_table_cells(). */
done_html_parser_state(html_context, state);
free_table(table);
ret0:
html_context->table_level--;
if (!html_context->table_level) free_table_cache();
#endif
}

8
src/document/xml/tables.h
View File

@ -1,8 +0,0 @@
#ifndef EL__DOCUMENT_XML_TABLES_H
#define EL__DOCUMENT_XML_TABLES_H
struct source_renderer;
void tags_format_table(struct source_renderer *renderer, void *node);
#endif

4
src/ecmascript/ecmascript.cpp
View File

@ -14,10 +14,10 @@
#include "dialogs/status.h"
#include "document/document.h"
#include "document/libdom/mapa.h"
#include "document/libdom/renderer.h"
#include "document/libdom/renderer2.h"
#include "document/renderer.h"
#include "document/view.h"
#include "document/xml/renderer.h"
#include "document/xml/renderer2.h"
#include "ecmascript/ecmascript.h"
#include "ecmascript/libdom/parse.h"
#ifdef CONFIG_MUJS

6
src/ecmascript/mujs.cpp
View File

@ -17,8 +17,8 @@
#include "dialogs/menu.h"
#include "dialogs/status.h"
#include "document/html/frames.h"
#include "document/xml/renderer.h"
#include "document/xml/renderer2.h"
#include "document/libdom/renderer.h"
#include "document/libdom/renderer2.h"
#include "document/document.h"
#include "document/forms.h"
#include "document/renderer.h"
@ -57,8 +57,6 @@
#include "viewer/text/view.h"
#include "viewer/text/vs.h"
#include <libxml++/libxml++.h>
/*** Global methods */

4
src/ecmascript/quickjs.cpp
View File

@ -17,8 +17,8 @@
#include "dialogs/menu.h"
#include "dialogs/status.h"
#include "document/html/frames.h"
#include "document/xml/renderer.h"
#include "document/xml/renderer2.h"
#include "document/libdom/renderer.h"
#include "document/libdom/renderer2.h"
#include "document/document.h"
#include "document/forms.h"
#include "document/renderer.h"

6
src/ecmascript/spidermonkey.cpp
View File

@ -19,8 +19,8 @@
#include "dialogs/menu.h"
#include "dialogs/status.h"
#include "document/html/frames.h"
#include "document/xml/renderer.h"
#include "document/xml/renderer2.h"
#include "document/libdom/renderer.h"
#include "document/libdom/renderer2.h"
#include "document/document.h"
#include "document/forms.h"
#include "document/renderer.h"
@ -64,8 +64,6 @@
#include <js/SourceText.h>
#include <js/Warnings.h>
#include <libxml++/libxml++.h>
/*** Global methods */