aniani/elinks
1
0
Fork 0
mirror of https://github.com/rkd77/elinks.git synced 2024-12-04 14:46:47 -05:00
Code
1509fab35a
elinks/src/document/plain/renderer.c

994 lines
23 KiB
C
Raw Blame History

/* 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/renderer.h"
#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"
struct plain_renderer {
/* The document being renderered */
struct document *document;
/* The data and data length of the defragmented cache entry */
char *source;
int length;
/* The convert table that should be used for converting line strings to
* the rendered strings. */
struct conv_table *convert_table;
/* The default template char data for text */
struct screen_char template_;
/* The maximum width any line can have (used for wrapping text) */
int max_width;
/* The current line number */
int lineno;
/* Are we doing line compression */
unsigned int compress:1;
};
#define realloc_document_links(doc, size) \
ALIGN_LINK(&(doc)->links, (doc)->nlinks, size)
static struct screen_char *
realloc_line(struct document *document, int x, int y)
{
struct line *line = realloc_lines(document, y);
if (!line) return NULL;
if (x != line->length) {
if (!ALIGN_LINE(&line->chars, line->length, x))
return NULL;
line->length = x;
}
return line->chars;
}
static inline struct link *
add_document_link(struct document *document, char *uri, int length,
int x, int y)
{
struct link *link;
struct point *point;
if (!realloc_document_links(document, document->nlinks + 1))
return NULL;
link = &document->links[document->nlinks];
if (!realloc_points(link, length))
return NULL;
link->npoints = length;
link->type = LINK_HYPERTEXT;
link->where = uri;
link->color.background = document->options.default_style.color.background;
link->color.foreground = document->options.default_color.link;
link->number = document->nlinks;
for (point = link->points; length > 0; length--, point++, x++) {
point->x = x;
point->y = y;
}
document->nlinks++;
document->links_sorted = 0;
return link;
}
/* Searches a word to find an email adress or an URI to add as a link. */
static inline struct link *
check_link_word(struct document *document, char *uri, int length,
int x, int y)
{
struct uri test;
char *where = NULL;
char *mailto = (char *)memchr(uri, '@', length);
int keep = uri[length];
struct link *new_link;
assert(document);
if_assert_failed return NULL;
uri[length] = 0;
if (mailto && mailto > uri && mailto - uri < length - 1) {
where = straconcat("mailto:", uri, (char *) NULL);
} else if (parse_uri(&test, uri) == URI_ERRNO_OK
&& test.protocol != PROTOCOL_UNKNOWN
&& (test.datalen || test.hostlen)) {
where = memacpy(uri, length);
}
uri[length] = keep;
if (!where) return NULL;
/* We need to reparse the URI and normalize it so that the protocol and
* host part are converted to lowercase. */
normalize_uri(NULL, where);
new_link = add_document_link(document, where, length, x, y);
if (!new_link) mem_free(where);
return new_link;
}
#define url_char(c) ( \
(c) > ' ' \
&& (c) != '<' \
&& (c) != '>' \
&& (c) != '(' \
&& (c) != ')' \
&& !isquote(c))
static inline int
get_uri_length(char *line, int length)
{
int uri_end = 0;
while (uri_end < length
&& url_char(line[uri_end]))
uri_end++;
for (; uri_end > 0; uri_end--) {
if (line[uri_end - 1] != '.'
&& line[uri_end - 1] != ',')
break;
}
return uri_end;
}
static int
print_document_link(struct plain_renderer *renderer, int lineno,
char *line, int line_pos, int width,
int expanded, struct screen_char *pos, int cells)
{
struct document *document = renderer->document;
char *start = &line[line_pos];
int len = get_uri_length(start, width - line_pos);
int screen_column = cells + expanded;
struct link *new_link;
int link_end = line_pos + len;
char saved_char;
struct document_options *doc_opts = &document->options;
struct screen_char template_ = renderer->template_;
int i;
if (!len) return 0;
new_link = check_link_word(document, start, len, screen_column,
lineno);
if (!new_link) return 0;
saved_char = line[link_end];
line[link_end] = '\0';
if (0)
; /* Shut up compiler */
#ifdef CONFIG_GLOBHIST
else if (get_global_history_item(start))
new_link->color.foreground = doc_opts->default_color.vlink;
#endif
#ifdef CONFIG_BOOKMARKS
else if (get_bookmark(start))
new_link->color.foreground = doc_opts->default_color.bookmark_link;
#endif
else
new_link->color.foreground = doc_opts->default_color.link;
line[link_end] = saved_char;
new_link->color.background = doc_opts->default_style.color.background;
set_term_color(&template_, &new_link->color,
doc_opts->color_flags, doc_opts->color_mode);
for (i = len; i; i--) {
template_.data = line[line_pos++];
copy_screen_chars(pos++, &template_, 1);
}
return len;
}
#define RED_COLOR_MASK 0x00FF0000
#define GREEN_COLOR_MASK 0x0000FF00
#define BLUE_COLOR_MASK 0x000000FF
#define RED_COLOR(color) (((color) & RED_COLOR_MASK) >> 16)
#define GREEN_COLOR(color) (((color) & GREEN_COLOR_MASK) >> 8)
#define BLUE_COLOR(color) (((color) & BLUE_COLOR_MASK) >> 0)
static void
decode_esc_color(char *text, int *line_pos, int width,
struct screen_char *template_, color_mode_T mode,
int *was_reversed)
{
struct screen_char ch;
struct color_pair color;
char *buf, *tail, *begin, *end;
int k, foreground, background, f1, b1; /* , intensity; */
#ifdef CONFIG_256_COLORS
int foreground256, background256;
int was_256 = 0;
#endif
int was_background = 0;
int was_foreground = 0;
int was_24 = 0;
unsigned char back_red = 0, back_green = 0, back_blue = 0;
unsigned char fore_red = 0, fore_green = 0, fore_blue = 0;
++(*line_pos);
buf = (char *)&text[*line_pos];
if (*buf != '[') return;
++buf;
++(*line_pos);
k = strspn(buf, "0123456789;?");
*line_pos += k;
if (!k || (buf[k] != 'm' && buf[k] != 'l' && buf[k] != 'h')) return;
end = buf + k;
begin = tail = buf;
get_screen_char_color(template_, &color, 0, mode);
back_red = RED_COLOR(color.background);
back_green = GREEN_COLOR(color.background);
back_blue = BLUE_COLOR(color.background);
fore_red = RED_COLOR(color.foreground);
fore_green = GREEN_COLOR(color.foreground);
fore_blue = BLUE_COLOR(color.foreground);
set_term_color(&ch, &color, 0, COLOR_MODE_16);
b1 = background = (ch.c.color[0] >> 4) & 7;
f1 = foreground = ch.c.color[0] & 15;
#ifdef CONFIG_256_COLORS
set_term_color(&ch, &color, 0, COLOR_MODE_256);
foreground256 = ch.c.color[0];
background256 = ch.c.color[1];
#endif
while (tail < end) {
unsigned char kod = (unsigned char)strtol(begin, &tail, 10);
begin = tail + 1;
if (was_background) {
switch (was_background) {
case 1:
if (kod == 2) {
was_background = 2;
continue;
}
#ifdef CONFIG_256_COLORS
if (kod == 5) {
was_background = 5;
continue;
}
#endif
was_background = 0;
continue;
case 2:
back_red = kod;
was_background = 3;
continue;
case 3:
back_green = kod;
was_background = 4;
continue;
case 4:
back_blue = kod;
was_background = 0;
was_24 = 1;
continue;
#ifdef CONFIG_256_COLORS
case 5:
background256 = kod;
was_background = 0;
was_256 = 1;
continue;
#endif
default:
was_background = 0;
continue;
}
}
if (was_foreground) {
switch (was_foreground) {
case 1:
if (kod == 2) {
was_foreground = 2;
continue;
}
#ifdef CONFIG_256_COLORS
if (kod == 5) {
was_foreground = 5;
continue;
}
#endif
was_foreground = 0;
continue;
case 2:
fore_red = kod;
was_foreground = 3;
continue;
case 3:
fore_green = kod;
was_foreground = 4;
continue;
case 4:
fore_blue = kod;
was_foreground = 0;
was_24 = 1;
continue;
#ifdef CONFIG_256_COLORS
case 5:
foreground256 = kod;
was_foreground = 0;
was_256 = 1;
continue;
#endif
default:
was_foreground = 0;
continue;
}
}
switch (kod) {
case 0:
background = 0;
foreground = 7;
back_red = back_green = back_blue = 0;
fore_red = fore_green = fore_blue = 255;
break;
case 7:
if (*was_reversed == 0) {
background = f1 & 7;
foreground = b1;
*was_reversed = 1;
}
break;
case 27:
if (*was_reversed == 1) {
background = f1 & 7;
foreground = b1;
*was_reversed = 0;
}
break;
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
foreground = kod - 30;
break;
case 38:
was_foreground = 1;
break;
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
background = kod - 40;
break;
case 48:
was_background = 1;
break;
default:
break;
}
}
#ifdef CONFIG_256_COLORS
if (was_256) {
color.background = get_term_color256(background256);
color.foreground = get_term_color256(foreground256);
} else
#endif
{
color.background = get_term_color16(background);
color.foreground = get_term_color16(foreground);
}
if (was_24) {
color.background = (back_red << 16) | (back_green << 8) | back_blue;
color.foreground = (fore_red << 16) | (fore_green << 8) | fore_blue;
}
set_term_color(template_, &color, 0, mode);
}
static inline int
add_document_line(struct plain_renderer *renderer,
char *line, int line_width)
{
struct document *document = renderer->document;
struct screen_char *template_ = &renderer->template_;
struct screen_char saved_renderer_template = *template_;
struct screen_char *pos, *startpos;
struct document_options *doc_opts = &document->options;
int was_reversed = 0;
#ifdef CONFIG_UTF8
int utf8 = doc_opts->utf8;
#endif /* CONFIG_UTF8 */
int cells = 0;
int lineno = renderer->lineno;
int expanded = 0;
int width = line_width;
int line_pos;
line = convert_string(renderer->convert_table, line, width,
document->options.cp, CSM_NONE, &width,
NULL, NULL);
if (!line) return 0;
/* Now expand tabs */
for (line_pos = 0; line_pos < width;) {
unsigned char line_char = (unsigned char)line[line_pos];
int charlen = 1;
int cell = 1;
#ifdef CONFIG_UTF8
unicode_val_T data;
if (utf8) {
char *line_char2 = &line[line_pos];
charlen = utf8charlen((char *)&line_char);
data = utf8_to_unicode(&line_char2, &line[width]);
if (data == UCS_NO_CHAR) {
line_pos += charlen;
continue;
}
cell = unicode_to_cell(data);
}
#endif /* CONFIG_UTF8 */
if (line_char == ASCII_TAB
&& (line_pos + charlen == width
|| line[line_pos + charlen] != ASCII_BS)) {
int tab_width = 7 - ((cells + expanded) & 7);
expanded += tab_width;
} else if (line_char == ASCII_BS) {
#if 0
This does not work: Suppose we have seventeen spaces
followed by a back-space; that will call for sixteen
bytes of memory, but we will print seventeen spaces
before we hit the back-space -- overflow!
/* Don't count the character
* that the back-space character will delete */
if (expanded + line_pos)
expanded--;
#endif
#if 0
/* Don't count the back-space character */
if (expanded > 0)
expanded--;
#endif
}
line_pos += charlen;
cells += cell;
}
assert(expanded >= 0);
startpos = pos = realloc_line(document, width + expanded, lineno);
if (!pos) {
mem_free(line);
return 0;
}
cells = 0;
expanded = 0;
for (line_pos = 0; line_pos < width;) {
unsigned char line_char = (unsigned char)line[line_pos];
char next_char, prev_char;
int charlen = 1;
int cell = 1;
#ifdef CONFIG_UTF8
unicode_val_T data = UCS_NO_CHAR;
if (utf8) {
char *line_char2 = &line[line_pos];
charlen = utf8charlen((char *)&line_char);
data = utf8_to_unicode(&line_char2, &line[width]);
if (data == UCS_NO_CHAR) {
line_pos += charlen;
continue;
}
cell = unicode_to_cell(data);
}
#endif /* CONFIG_UTF8 */
prev_char = line_pos > 0 ? line[line_pos - 1] : '\0';
next_char = (line_pos + charlen < width) ?
line[line_pos + charlen] : '\0';
/* Do not expand tabs that precede back-spaces; this saves the
* back-space code some trouble. */
if (line_char == ASCII_TAB && next_char != ASCII_BS) {
int tab_width = 7 - ((cells + expanded) & 7);
expanded += tab_width;
template_->data = ' ';
do
copy_screen_chars(pos++, template_, 1);
while (tab_width--);
*template_ = saved_renderer_template;
} else if (line_char == ASCII_BS) {
if (!(expanded + cells)) {
/* We've backspaced to the start of the line */
goto next;
}
if (pos > startpos)
pos--; /* Backspace */
/* Handle x^H_ as _^Hx, but prevent an infinite loop
* swapping two underscores. */
if (next_char == '_' && prev_char != '_') {
/* x^H_ becomes _^Hx */
if (line_pos - 1 >= 0)
line[line_pos - 1] = next_char;
if (line_pos + charlen < width)
line[line_pos + charlen] = prev_char;
/* Go back and reparse the swapped characters */
if (line_pos - 2 >= 0) {
cells--;
line_pos--;
}
continue;
}
if ((expanded + line_pos) - 2 >= 0) {
/* Don't count the backspace character or the
* deleted character when returning the line's
* width or when expanding tabs. */
expanded -= 2;
}
if (pos->data == '_' && next_char == '_') {
/* Is _^H_ an underlined underscore
* or an emboldened underscore? */
if (expanded + line_pos >= 0
&& pos - 1 >= startpos
&& (pos - 1)->attr) {
/* There is some preceding text,
* and it has an attribute; copy it */
template_->attr |= (pos - 1)->attr;
} else {
/* Default to bold; seems more useful
* than underlining the underscore */
template_->attr |= SCREEN_ATTR_BOLD;
}
} else if (pos->data == '_') {
/* Underline _^Hx */
template_->attr |= SCREEN_ATTR_UNDERLINE;
} else if (pos->data == next_char) {
/* Embolden x^Hx */
template_->attr |= SCREEN_ATTR_BOLD;
}
/* Handle _^Hx^Hx as both bold and underlined */
if (template_->attr)
template_->attr |= pos->attr;
} else if (line_char == 27) {
decode_esc_color(line, &line_pos, width,
&saved_renderer_template,
doc_opts->color_mode, &was_reversed);
*template_ = saved_renderer_template;
} else {
int added_chars = 0;
if (document->options.plain_display_links
&& isalpha(line_char) && isalpha(next_char)) {
/* We only want to check for a URI if there are
* at least two consecutive alphabetic
* characters, or if we are at the very start of
* the line. It improves performance a bit.
* --Zas */
added_chars = print_document_link(renderer,
lineno, line,
line_pos,
width,
expanded,
pos, cells);
}
if (added_chars) {
line_pos += added_chars - 1;
cells += added_chars - 1;
pos += added_chars;
} else {
#ifdef CONFIG_UTF8
if (utf8) {
if (data == UCS_NO_CHAR) {
line_pos += charlen;
continue;
}
template_->data = (unicode_val_T)data;
copy_screen_chars(pos++, template_, 1);
if (cell == 2) {
template_->data = UCS_NO_CHAR;
copy_screen_chars(pos++,
template_, 1);
}
} else
#endif /* CONFIG_UTF8 */
{
if (!isscreensafe(line_char))
line_char = '.';
template_->data = line_char;
copy_screen_chars(pos++, template_, 1);
/* Detect copy of nul chars to screen,
* this should not occur. --Zas */
assert(line_char);
}
}
*template_ = saved_renderer_template;
}
next:
line_pos += charlen;
cells += cell;
}
mem_free(line);
realloc_line(document, pos - startpos, lineno);
return width + expanded;
}
static void
init_template(struct screen_char *template_, struct document_options *options)
{
get_screen_char_template(template_, options, options->default_style);
}
static struct node *
add_node(struct plain_renderer *renderer, int x, int width, int height)
{
struct node *node = (struct node *)mem_alloc(sizeof(*node));
if (node) {
struct document *document = renderer->document;
set_box(&node->box, x, renderer->lineno, width, height);
int_lower_bound(&document->width, width);
int_lower_bound(&document->height, height);
add_to_list(document->nodes, node);
}
return node;
}
static void
add_document_lines(struct plain_renderer *renderer)
{
char *source = renderer->source;
int length = renderer->length;
int was_empty_line = 0;
int was_wrapped = 0;
#ifdef CONFIG_UTF8
int utf8 = is_cp_utf8(renderer->document->cp);
#endif
for (; length > 0; renderer->lineno++) {
char *xsource;
int width, added, only_spaces = 1, spaces = 0, was_spaces = 0;
int last_space = 0;
int tab_spaces = 0;
int step = 0;
int cells = 0;
/* End of line detection: We handle \r, \r\n and \n types. */
for (width = 0; (width < length) &&
(cells < renderer->max_width);) {
if (source[width] == ASCII_CR)
step++;
if (source[width + step] == ASCII_LF)
step++;
if (step) break;
if (isspace((unsigned char)source[width])) {
last_space = width;
if (only_spaces)
spaces++;
else
was_spaces++;
if (source[width] == '\t')
tab_spaces += 7 - ((width + tab_spaces) % 8);
} else {
only_spaces = 0;
was_spaces = 0;
}
#ifdef CONFIG_UTF8
if (utf8) {
char *text = &source[width];
unicode_val_T data = utf8_to_unicode(&text,
&source[length]);
if (data == UCS_NO_CHAR) return;
cells += unicode_to_cell(data);
width += utf8charlen(&source[width]);
} else
#endif /* CONFIG_UTF8 */
{
cells++;
width++;
}
}
if (only_spaces && step) {
if (was_wrapped || (renderer->compress && was_empty_line)) {
/* Successive empty lines will appear as one. */
length -= step + spaces;
source += step + spaces;
renderer->lineno--;
assert(renderer->lineno >= 0);
continue;
}
was_empty_line = 1;
/* No need to keep whitespaces on an empty line. */
source += spaces;
length -= spaces;
width -= spaces;
} else {
was_empty_line = 0;
was_wrapped = !step;
if (was_spaces && step) {
/* Drop trailing whitespaces. */
width -= was_spaces;
step += was_spaces;
}
if (!step && (width < length) && last_space) {
width = last_space;
step = 1;
}
}
assert(width >= 0);
/* We will touch the supplied source, so better replicate it. */
xsource = memacpy(source, width);
if (!xsource) continue;
added = add_document_line(renderer, xsource, width);
mem_free(xsource);
if (added) {
/* Add (search) nodes on a line by line basis */
add_node(renderer, 0, added, 1);
}
/* Skip end of line chars too. */
width += step;
length -= width;
source += width;
}
assert(!length);
}
static void
fixup_tables(struct plain_renderer *renderer)
{
int y;
for (y = 0; y < renderer->lineno; y++) {
int x;
struct line *prev_line = y > 0 ? &renderer->document->data[y - 1] : NULL;
struct line *line = &renderer->document->data[y];
struct line *next_line = y < renderer->lineno - 1 ? &renderer->document->data[y + 1] : NULL;
for (x = 0; x < line->length; x++) {
int dir;
#ifdef CONFIG_UTF8
unicode_val_T ch = line->chars[x].data;
unicode_val_T prev_char, next_char, up_char, down_char;
#else
unsigned char ch = line->chars[x].data;
unsigned char prev_char, next_char, up_char, down_char;
#endif
if (ch != '+' && ch != '-' && ch != '|') {
continue;
}
prev_char = x > 0 ? line->chars[x - 1].data : ' ';
next_char = x < line->length - 1 ? line->chars[x + 1].data : ' ';
up_char = (prev_line && x < prev_line->length) ? prev_line->chars[x].data : ' ';
down_char = (next_line && x < next_line->length) ? next_line->chars[x].data : ' ';
switch (ch) {
case '+':
dir = 0;
if (up_char == '|' || up_char == BORDER_SVLINE) dir |= 1;
if (next_char == '-' || next_char == BORDER_SHLINE) dir |= 2;
if (down_char == '|' || down_char == BORDER_SVLINE) dir |= 4;
if (prev_char == '-' || prev_char == BORDER_SHLINE) dir |= 8;
switch (dir) {
case 15:
line->chars[x].data = BORDER_SCROSS;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 13:
line->chars[x].data = BORDER_SLTEE;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 7:
line->chars[x].data = BORDER_SRTEE;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 6:
line->chars[x].data = BORDER_SULCORNER;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 12:
line->chars[x].data = BORDER_SURCORNER;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 3:
line->chars[x].data = BORDER_SDLCORNER;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 9:
line->chars[x].data = BORDER_SDRCORNER;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 11:
line->chars[x].data = BORDER_SUTEE;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
case 14:
line->chars[x].data = BORDER_SDTEE;
line->chars[x].attr = SCREEN_ATTR_FRAME;
break;
default:
break;
}
break;
case '-':
if (prev_char == BORDER_SHLINE || prev_char == BORDER_SCROSS || prev_char == '+' || prev_char == '|'
|| prev_char == BORDER_SULCORNER || prev_char == BORDER_SDLCORNER || prev_char == BORDER_SRTEE
|| prev_char == BORDER_SUTEE || prev_char == BORDER_SDTEE) {
line->chars[x].data = BORDER_SHLINE;
line->chars[x].attr = SCREEN_ATTR_FRAME;
}
break;
case '|':
if (up_char == BORDER_SVLINE || up_char == '+' || up_char == '|' || up_char == BORDER_SULCORNER
|| up_char == BORDER_SURCORNER || up_char == BORDER_SCROSS || up_char == BORDER_SRTEE || up_char == BORDER_SLTEE
|| up_char == BORDER_SDTEE) {
if (next_char == '-') {
line->chars[x].data = BORDER_SRTEE;
} else if (prev_char == BORDER_SHLINE || prev_char == '-') {
line->chars[x].data = BORDER_SLTEE;
} else {
line->chars[x].data = BORDER_SVLINE;
}
line->chars[x].attr = SCREEN_ATTR_FRAME;
}
break;
default:
continue;
}
}
}
}
void
render_plain_document(struct cache_entry *cached, struct document *document,
struct string *buffer)
{
struct conv_table *convert_table;
char *head = empty_string_or_(cached->head);
struct plain_renderer renderer;
convert_table = get_convert_table(head, document->options.cp,
document->options.assume_cp,
&document->cp,
&document->cp_status,
document->options.hard_assume);
renderer.source = buffer->source;
renderer.length = buffer->length;
renderer.document = document;
renderer.lineno = 0;
renderer.convert_table = convert_table;
renderer.compress = document->options.plain_compress_empty_lines;
renderer.max_width = document->options.wrap ? document->options.document_width
: INT_MAX;
document->color.background = document->options.default_style.color.background;
document->width = 0;
#ifdef CONFIG_UTF8
document->options.utf8 = is_cp_utf8(document->options.cp);
#endif /* CONFIG_UTF8 */
/* Setup the style */
init_template(&renderer.template_, &document->options);
add_document_lines(&renderer);
if (document->options.plain_fixup_tables) {
fixup_tables(&renderer);
}
}
View Git Blame Copy Permalink