vasilito
facf0c92e0
Red Bear OS is a full fork. All sources must be available from git clone with zero network access. Removed gitignore rules that excluded fetched source trees under recipes/*/source/, local/recipes/kde/*/source/, local/recipes/qt/*/source/, and vendor source trees. Build artifacts (target/, build/, source.tar, *.o, *.so) remain excluded. 127291 files added — kernel, relibc, base, bootloader, pkgar, all KDE/Qt frameworks, mesa, wayland, DRM drivers, and every other recipe source.
550 lines
17 KiB
C
550 lines
17 KiB
C
/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
|
|
|
|
#if !IS_CPLUSPLUS
|
|
#define html_ostream_representation any_ostream_representation
|
|
#endif
|
|
#line 1 "html-ostream.oo.c"
|
|
/* Output stream that produces HTML output.
|
|
Copyright (C) 2006-2009, 2019-2020 Free Software Foundation, Inc.
|
|
Written by Bruno Haible <bruno@clisp.org>, 2006.
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
|
|
|
#include <config.h>
|
|
|
|
/* Specification. */
|
|
#include "html-ostream.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "gl_xlist.h"
|
|
#include "gl_array_list.h"
|
|
#include "minmax.h"
|
|
#include "unistr.h"
|
|
#include "xalloc.h"
|
|
|
|
#line 40 "html-ostream.c"
|
|
#include "html_ostream.priv.h"
|
|
|
|
const typeinfo_t html_ostream_typeinfo = { "html_ostream" };
|
|
|
|
static const typeinfo_t * const html_ostream_superclasses[] =
|
|
{ html_ostream_SUPERCLASSES };
|
|
|
|
#define super ostream_vtable
|
|
|
|
#line 51 "html-ostream.oo.c"
|
|
|
|
/* Emit an HTML attribute value.
|
|
quote is either '"' or '\''. */
|
|
static void
|
|
write_attribute_value (html_ostream_t stream, const char *value, char quote)
|
|
{
|
|
/* Need to escape the '<', '>', '&', quote characters. */
|
|
ostream_t destination = stream->destination;
|
|
const char *p = value;
|
|
|
|
for (;;)
|
|
{
|
|
const char *q = p;
|
|
|
|
while (*q != '\0' && *q != '<' && *q != '>' && *q != '&' && *q != quote)
|
|
q++;
|
|
if (p < q)
|
|
ostream_write_mem (destination, p, q - p);
|
|
if (*q == '\0')
|
|
break;
|
|
switch (*q)
|
|
{
|
|
case '<':
|
|
ostream_write_str (destination, "<");
|
|
break;
|
|
case '>':
|
|
ostream_write_str (destination, ">");
|
|
break;
|
|
case '&':
|
|
ostream_write_str (destination, "&");
|
|
break;
|
|
case '"':
|
|
ostream_write_str (destination, """);
|
|
break;
|
|
case '\'':
|
|
ostream_write_str (destination, "'");
|
|
break;
|
|
default:
|
|
abort ();
|
|
}
|
|
p = q + 1;
|
|
}
|
|
}
|
|
|
|
/* Implementation of ostream_t methods. */
|
|
|
|
static void
|
|
verify_invariants (html_ostream_t stream)
|
|
{
|
|
/* Verify the invariant regarding size(class_stack). */
|
|
if (gl_list_size (stream->class_stack)
|
|
!= MAX (stream->curr_class_stack_size, stream->last_class_stack_size))
|
|
abort ();
|
|
}
|
|
|
|
/* Removes the excess elements of class_stack.
|
|
Needs to be called after max(curr_class_stack_size,last_class_stack_size)
|
|
may have been reduced. */
|
|
static void
|
|
shrink_class_stack (html_ostream_t stream)
|
|
{
|
|
size_t keep =
|
|
MAX (stream->curr_class_stack_size, stream->last_class_stack_size);
|
|
size_t i = gl_list_size (stream->class_stack);
|
|
while (i > keep)
|
|
{
|
|
i--;
|
|
free ((char *) gl_list_get_at (stream->class_stack, i));
|
|
gl_list_remove_at (stream->class_stack, i);
|
|
}
|
|
}
|
|
|
|
/* Emits <span> or </span> tags, to follow the increase / decrease of the
|
|
class_stack from last_class_stack_size to curr_class_stack_size.
|
|
When done, sets last_class_stack_size to curr_class_stack_size. */
|
|
static void
|
|
emit_pending_spans (html_ostream_t stream, bool shrink_stack)
|
|
{
|
|
if (stream->curr_class_stack_size > stream->last_class_stack_size)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = stream->last_class_stack_size; i < stream->curr_class_stack_size; i++)
|
|
{
|
|
char *classname = (char *) gl_list_get_at (stream->class_stack, i);
|
|
|
|
ostream_write_str (stream->destination, "<span class=\"");
|
|
ostream_write_str (stream->destination, classname);
|
|
ostream_write_str (stream->destination, "\">");
|
|
}
|
|
stream->last_class_stack_size = stream->curr_class_stack_size;
|
|
}
|
|
else if (stream->curr_class_stack_size < stream->last_class_stack_size)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = stream->last_class_stack_size; i > stream->curr_class_stack_size; i--)
|
|
ostream_write_str (stream->destination, "</span>");
|
|
stream->last_class_stack_size = stream->curr_class_stack_size;
|
|
if (shrink_stack)
|
|
shrink_class_stack (stream);
|
|
}
|
|
/* Here last_class_stack_size == curr_class_stack_size. */
|
|
if (shrink_stack)
|
|
verify_invariants (stream);
|
|
}
|
|
|
|
static void
|
|
html_ostream__write_mem (html_ostream_t stream, const void *data, size_t len)
|
|
{
|
|
if (len > 0)
|
|
{
|
|
#define BUFFERSIZE 2048
|
|
char inbuffer[BUFFERSIZE];
|
|
size_t inbufcount;
|
|
|
|
inbufcount = stream->buflen;
|
|
if (inbufcount > 0)
|
|
memcpy (inbuffer, stream->buf, inbufcount);
|
|
for (;;)
|
|
{
|
|
/* At this point, inbuffer[0..inbufcount-1] is filled. */
|
|
{
|
|
/* Combine the previous rest with a chunk of new input. */
|
|
size_t n =
|
|
(len <= BUFFERSIZE - inbufcount ? len : BUFFERSIZE - inbufcount);
|
|
|
|
if (n > 0)
|
|
{
|
|
memcpy (inbuffer + inbufcount, data, n);
|
|
data = (const char *) data + n;
|
|
inbufcount += n;
|
|
len -= n;
|
|
}
|
|
}
|
|
{
|
|
/* Handle complete UTF-8 characters. */
|
|
const char *inptr = inbuffer;
|
|
size_t insize = inbufcount;
|
|
|
|
while (insize > 0)
|
|
{
|
|
unsigned char c0;
|
|
ucs4_t uc;
|
|
int nbytes;
|
|
|
|
c0 = ((const unsigned char *) inptr)[0];
|
|
if (insize < (c0 < 0xc0 ? 1 : c0 < 0xe0 ? 2 : c0 < 0xf0 ? 3 :
|
|
c0 < 0xf8 ? 4 : c0 < 0xfc ? 5 : 6))
|
|
break;
|
|
|
|
nbytes = u8_mbtouc (&uc, (const unsigned char *) inptr, insize);
|
|
|
|
if (uc == '\n')
|
|
{
|
|
verify_invariants (stream);
|
|
/* Emit </span> tags to follow the decrease of the class stack
|
|
from last_class_stack_size to 0. Then emit the newline.
|
|
Then prepare for emitting <span> tags to go back from 0
|
|
to curr_class_stack_size. */
|
|
size_t prev_class_stack_size = stream->curr_class_stack_size;
|
|
stream->curr_class_stack_size = 0;
|
|
emit_pending_spans (stream, false);
|
|
stream->curr_class_stack_size = prev_class_stack_size;
|
|
ostream_write_str (stream->destination, "<br/>");
|
|
shrink_class_stack (stream);
|
|
verify_invariants (stream);
|
|
}
|
|
else
|
|
{
|
|
emit_pending_spans (stream, true);
|
|
|
|
switch (uc)
|
|
{
|
|
case '"':
|
|
ostream_write_str (stream->destination, """);
|
|
break;
|
|
case '&':
|
|
ostream_write_str (stream->destination, "&");
|
|
break;
|
|
case '<':
|
|
ostream_write_str (stream->destination, "<");
|
|
break;
|
|
case '>':
|
|
/* Needed to avoid "]]>" in the output. */
|
|
ostream_write_str (stream->destination, ">");
|
|
break;
|
|
case ' ':
|
|
/* Needed because HTML viewers merge adjacent spaces
|
|
and drop spaces adjacent to <br> and similar. */
|
|
ostream_write_str (stream->destination, " ");
|
|
break;
|
|
default:
|
|
if (uc >= 0x20 && uc < 0x7F)
|
|
{
|
|
/* Output ASCII characters as such. */
|
|
char bytes[1];
|
|
bytes[0] = uc;
|
|
ostream_write_mem (stream->destination, bytes, 1);
|
|
}
|
|
else
|
|
{
|
|
/* Output non-ASCII characters in #&nnn;
|
|
notation. */
|
|
char bytes[32];
|
|
sprintf (bytes, "&#%d;", (int) uc);
|
|
ostream_write_str (stream->destination, bytes);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
inptr += nbytes;
|
|
insize -= nbytes;
|
|
}
|
|
/* Put back the unconverted part. */
|
|
if (insize > BUFSIZE)
|
|
abort ();
|
|
if (len == 0)
|
|
{
|
|
if (insize > 0)
|
|
memcpy (stream->buf, inptr, insize);
|
|
stream->buflen = insize;
|
|
break;
|
|
}
|
|
if (insize > 0)
|
|
memmove (inbuffer, inptr, insize);
|
|
inbufcount = insize;
|
|
}
|
|
}
|
|
#undef BUFFERSIZE
|
|
}
|
|
}
|
|
|
|
static void
|
|
html_ostream__flush (html_ostream_t stream, ostream_flush_scope_t scope)
|
|
{
|
|
verify_invariants (stream);
|
|
/* stream->buf[] contains only a few bytes that don't correspond to a
|
|
character. Can't flush it. */
|
|
/* Close the open <span> tags, and prepare for reopening the same <span>
|
|
tags. */
|
|
size_t prev_class_stack_size = stream->curr_class_stack_size;
|
|
stream->curr_class_stack_size = 0;
|
|
emit_pending_spans (stream, false);
|
|
stream->curr_class_stack_size = prev_class_stack_size;
|
|
shrink_class_stack (stream);
|
|
verify_invariants (stream);
|
|
|
|
if (scope != FLUSH_THIS_STREAM)
|
|
ostream_flush (stream->destination, scope);
|
|
}
|
|
|
|
static void
|
|
html_ostream__free (html_ostream_t stream)
|
|
{
|
|
stream->curr_class_stack_size = 0;
|
|
emit_pending_spans (stream, true);
|
|
if (stream->hyperlink_ref != NULL)
|
|
{
|
|
/* Close the current <a> element. */
|
|
ostream_write_str (stream->destination, "</a>");
|
|
free (stream->hyperlink_ref);
|
|
}
|
|
verify_invariants (stream);
|
|
gl_list_free (stream->class_stack);
|
|
free (stream);
|
|
}
|
|
|
|
/* Implementation of html_ostream_t methods. */
|
|
|
|
static void
|
|
html_ostream__begin_span (html_ostream_t stream, const char *classname)
|
|
{
|
|
verify_invariants (stream);
|
|
if (stream->last_class_stack_size > stream->curr_class_stack_size
|
|
&& strcmp ((char *) gl_list_get_at (stream->class_stack,
|
|
stream->curr_class_stack_size),
|
|
classname) != 0)
|
|
emit_pending_spans (stream, true);
|
|
/* Now either
|
|
last_class_stack_size <= curr_class_stack_size
|
|
- in this case we have to append the given CLASSNAME -
|
|
or
|
|
last_class_stack_size > curr_class_stack_size
|
|
&& class_stack[curr_class_stack_size] == CLASSNAME
|
|
- in this case we only need to increment curr_class_stack_size. */
|
|
if (stream->last_class_stack_size <= stream->curr_class_stack_size)
|
|
gl_list_add_at (stream->class_stack, stream->curr_class_stack_size,
|
|
xstrdup (classname));
|
|
stream->curr_class_stack_size++;
|
|
verify_invariants (stream);
|
|
}
|
|
|
|
static void
|
|
html_ostream__end_span (html_ostream_t stream, const char *classname)
|
|
{
|
|
verify_invariants (stream);
|
|
if (stream->curr_class_stack_size > 0)
|
|
{
|
|
char *innermost_active_span =
|
|
(char *) gl_list_get_at (stream->class_stack,
|
|
stream->curr_class_stack_size - 1);
|
|
if (strcmp (innermost_active_span, classname) == 0)
|
|
{
|
|
stream->curr_class_stack_size--;
|
|
shrink_class_stack (stream);
|
|
verify_invariants (stream);
|
|
return;
|
|
}
|
|
}
|
|
/* Improperly nested begin_span/end_span calls. */
|
|
abort ();
|
|
}
|
|
|
|
static const char *
|
|
html_ostream__get_hyperlink_ref (html_ostream_t stream)
|
|
{
|
|
return stream->hyperlink_ref;
|
|
}
|
|
|
|
static void
|
|
html_ostream__set_hyperlink_ref (html_ostream_t stream, const char *ref)
|
|
{
|
|
char *ref_copy = (ref != NULL ? xstrdup (ref) : NULL);
|
|
|
|
verify_invariants (stream);
|
|
if (stream->hyperlink_ref != NULL)
|
|
{
|
|
/* Close the open <span> tags, and prepare for reopening the same <span>
|
|
tags. */
|
|
size_t prev_class_stack_size = stream->curr_class_stack_size;
|
|
stream->curr_class_stack_size = 0;
|
|
emit_pending_spans (stream, false);
|
|
stream->curr_class_stack_size = prev_class_stack_size;
|
|
/* Close the current <a> element. */
|
|
ostream_write_str (stream->destination, "</a>");
|
|
shrink_class_stack (stream);
|
|
|
|
free (stream->hyperlink_ref);
|
|
}
|
|
stream->hyperlink_ref = ref_copy;
|
|
if (stream->hyperlink_ref != NULL)
|
|
{
|
|
/* Close the open <span> tags, and prepare for reopening the same <span>
|
|
tags. */
|
|
size_t prev_class_stack_size = stream->curr_class_stack_size;
|
|
stream->curr_class_stack_size = 0;
|
|
emit_pending_spans (stream, false);
|
|
stream->curr_class_stack_size = prev_class_stack_size;
|
|
/* Open an <a> element. */
|
|
ostream_write_str (stream->destination, "<a href=\"");
|
|
write_attribute_value (stream, stream->hyperlink_ref, '"');
|
|
ostream_write_str (stream->destination, "\">");
|
|
shrink_class_stack (stream);
|
|
}
|
|
verify_invariants (stream);
|
|
}
|
|
|
|
static void
|
|
html_ostream__flush_to_current_style (html_ostream_t stream)
|
|
{
|
|
verify_invariants (stream);
|
|
/* stream->buf[] contains only a few bytes that don't correspond to a
|
|
character. Can't flush it. */
|
|
/* Open all requested <span> tags. */
|
|
emit_pending_spans (stream, true);
|
|
verify_invariants (stream);
|
|
}
|
|
|
|
/* Constructor. */
|
|
|
|
html_ostream_t
|
|
html_ostream_create (ostream_t destination)
|
|
{
|
|
html_ostream_t stream = XMALLOC (struct html_ostream_representation);
|
|
|
|
stream->base.vtable = &html_ostream_vtable;
|
|
stream->destination = destination;
|
|
stream->hyperlink_ref = NULL;
|
|
stream->class_stack =
|
|
gl_list_create_empty (GL_ARRAY_LIST, NULL, NULL, NULL, true);
|
|
stream->curr_class_stack_size = 0;
|
|
stream->last_class_stack_size = 0;
|
|
stream->buflen = 0;
|
|
|
|
return stream;
|
|
}
|
|
|
|
/* Accessors. */
|
|
|
|
static ostream_t
|
|
html_ostream__get_destination (html_ostream_t stream)
|
|
{
|
|
return stream->destination;
|
|
}
|
|
|
|
/* Instanceof test. */
|
|
|
|
bool
|
|
is_instance_of_html_ostream (ostream_t stream)
|
|
{
|
|
return IS_INSTANCE (stream, ostream, html_ostream);
|
|
}
|
|
|
|
#line 456 "html-ostream.c"
|
|
|
|
const struct html_ostream_implementation html_ostream_vtable =
|
|
{
|
|
html_ostream_superclasses,
|
|
sizeof (html_ostream_superclasses) / sizeof (html_ostream_superclasses[0]),
|
|
sizeof (struct html_ostream_representation),
|
|
html_ostream__write_mem,
|
|
html_ostream__flush,
|
|
html_ostream__free,
|
|
html_ostream__begin_span,
|
|
html_ostream__end_span,
|
|
html_ostream__get_hyperlink_ref,
|
|
html_ostream__set_hyperlink_ref,
|
|
html_ostream__flush_to_current_style,
|
|
html_ostream__get_destination,
|
|
};
|
|
|
|
#if !HAVE_INLINE
|
|
|
|
/* Define the functions that invoke the methods. */
|
|
|
|
void
|
|
html_ostream_write_mem (html_ostream_t first_arg, const void *data, size_t len)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
vtable->write_mem (first_arg,data,len);
|
|
}
|
|
|
|
void
|
|
html_ostream_flush (html_ostream_t first_arg, ostream_flush_scope_t scope)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
vtable->flush (first_arg,scope);
|
|
}
|
|
|
|
void
|
|
html_ostream_free (html_ostream_t first_arg)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
vtable->free (first_arg);
|
|
}
|
|
|
|
void
|
|
html_ostream_begin_span (html_ostream_t first_arg, const char *classname)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
vtable->begin_span (first_arg,classname);
|
|
}
|
|
|
|
void
|
|
html_ostream_end_span (html_ostream_t first_arg, const char *classname)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
vtable->end_span (first_arg,classname);
|
|
}
|
|
|
|
const char *
|
|
html_ostream_get_hyperlink_ref (html_ostream_t first_arg)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
return vtable->get_hyperlink_ref (first_arg);
|
|
}
|
|
|
|
void
|
|
html_ostream_set_hyperlink_ref (html_ostream_t first_arg, const char *ref)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
vtable->set_hyperlink_ref (first_arg,ref);
|
|
}
|
|
|
|
void
|
|
html_ostream_flush_to_current_style (html_ostream_t first_arg)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
vtable->flush_to_current_style (first_arg);
|
|
}
|
|
|
|
ostream_t
|
|
html_ostream_get_destination (html_ostream_t first_arg)
|
|
{
|
|
const struct html_ostream_implementation *vtable =
|
|
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
|
|
return vtable->get_destination (first_arg);
|
|
}
|
|
|
|
#endif
|