--- /dev/null
+/* Output stream for attributed text, producing ANSI escape sequences.
+ Copyright (C) 2006 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 2, 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, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
+
+#include <config.h>
+
+/* Specification. */
+#include "term-ostream.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "error.h"
+#include "exit.h"
+#include "fatal-signal.h"
+#include "full-write.h"
+#include "xalloc.h"
+#include "xsize.h"
+#include "gettext.h"
+
+#define _(str) gettext (str)
+
+
+/* Including <curses.h> or <term.h> is dangerous, because it also declares
+ a lot of junk, such as variables PC, UP, and other. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Gets the capability information for terminal type TYPE.
+ Returns 1 if successful, 0 if TYPE is unknown, -1 on other error. */
+extern int tgetent (char *bp, const char *type);
+
+/* Retrieves the value of a numerical capability.
+ Returns -1 if it is not available. */
+extern int tgetnum (const char *id);
+
+/* Retrieves the value of a boolean capability.
+ Returns 1 if it available, 0 otherwise. */
+extern int tgetflag (const char *id);
+
+/* Retrieves the value of a string capability.
+ Returns NULL if it is not available.
+ Also, if AREA != NULL, stores it at *AREA and advances *AREA. */
+extern const char * tgetstr (const char *id, char **area);
+
+/* Instantiates a string capability with format strings.
+ The return value is statically allocated and must not be freed. */
+extern char * tparm (const char *str, ...);
+
+/* Retrieves a string that causes cursor positioning to (column, row).
+ This function is necessary because the string returned by tgetstr ("cm")
+ is in a special format. */
+extern const char * tgoto (const char *cm, int column, int row);
+
+/* Retrieves the value of a string capability.
+ OUTCHARFUN is called in turn for each 'char' of the result.
+ This function is necessary because string capabilities can contain
+ padding commands. */
+extern void tputs (const char *cp, int affcnt, int (*outcharfun) (int));
+
+/* The ncurses functions for color handling (see ncurses/base/lib_color.c)
+ are overkill: Most terminal emulators support only a fixed, small number
+ of colors. */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* ANSI C and ISO C99 6.7.2.1.(4) forbid use of bit fields for types other
+ than 'int' or 'unsigned int'.
+ On the other hand, C++ forbids conversion between enum types and integer
+ types without an explicit cast. */
+#ifdef __cplusplus
+# define BITFIELD_TYPE(orig_type,integer_type) orig_type
+#else
+# define BITFIELD_TYPE(orig_type,integer_type) integer_type
+#endif
+
+/* Attributes that can be set on a character. */
+typedef struct
+{
+ BITFIELD_TYPE(term_color_t, signed int) color : 4;
+ BITFIELD_TYPE(term_color_t, signed int) bgcolor : 4;
+ BITFIELD_TYPE(term_weight_t, unsigned int) weight : 1;
+ BITFIELD_TYPE(term_posture_t, unsigned int) posture : 1;
+ BITFIELD_TYPE(term_underline_t, unsigned int) underline : 1;
+} attributes_t;
+
+struct term_ostream : struct ostream
+{
+fields:
+ /* The file descriptor used for output. Note that ncurses termcap emulation
+ uses the baud rate information from file descriptor 1 (stdout) if it is
+ a tty, or from file descriptor 2 (stderr) otherwise. */
+ int fd;
+ char *filename;
+ /* Values from the terminal type's terminfo/termcap description.
+ See terminfo(5) for details. */
+ /* terminfo termcap */
+ int max_colors; /* colors Co */
+ int no_color_video; /* ncv NC */
+ char *set_a_foreground; /* setaf AF */
+ char *set_foreground; /* setf Sf */
+ char *set_a_background; /* setab AB */
+ char *set_background; /* setb Sb */
+ char *orig_pair; /* op op */
+ char *enter_bold_mode; /* bold md */
+ char *enter_italics_mode; /* sitm ZH */
+ char *exit_italics_mode; /* ritm ZR */
+ char *enter_underline_mode; /* smul us */
+ char *exit_underline_mode; /* rmul ue */
+ char *exit_attribute_mode; /* sgr0 me */
+ /* Inferred values. */
+ bool supports_foreground;
+ bool supports_background;
+ bool supports_weight;
+ bool supports_posture;
+ bool supports_underline;
+ /* Variable state. */
+ char *buffer; /* Buffer for the current line. */
+ attributes_t *attrbuffer; /* Buffer for the simplified attributes; same
+ length as buffer. */
+ size_t buflen; /* Number of bytes stored so far. */
+ size_t allocated; /* Allocated size of the buffer. */
+ attributes_t curr_attr; /* Current attributes. */
+ attributes_t simp_attr; /* Simplified current attributes. */
+};
+
+/* Simplify attributes, according to the terminal's capabilities. */
+static attributes_t
+simplify_attributes (term_ostream_t stream, attributes_t attr)
+{
+ if ((attr.color != COLOR_DEFAULT || attr.bgcolor != COLOR_DEFAULT)
+ && stream->no_color_video > 0)
+ {
+ /* When colors and attributes can not be represented simultaneously,
+ we give preference to the color. */
+ if (stream->no_color_video & 2)
+ /* Colors conflict with underlining. */
+ attr.underline = UNDERLINE_OFF;
+ if (stream->no_color_video & 32)
+ /* Colors conflict with bold weight. */
+ attr.weight = WEIGHT_NORMAL;
+ }
+ if (!stream->supports_foreground)
+ attr.color = COLOR_DEFAULT;
+ if (!stream->supports_background)
+ attr.bgcolor = COLOR_DEFAULT;
+ if (!stream->supports_weight)
+ attr.weight = WEIGHT_DEFAULT;
+ if (!stream->supports_posture)
+ attr.posture = POSTURE_DEFAULT;
+ if (!stream->supports_underline)
+ attr.underline = UNDERLINE_DEFAULT;
+ return attr;
+}
+
+/* While a line is being output, we need to be careful to restore the
+ terminal's settings in case of a fatal signal or an exit() call. */
+
+/* File descriptor to which out_char shall output escape sequences. */
+static int out_fd = -1;
+
+/* Filename of out_fd. */
+static const char *out_filename;
+
+/* Output a single char to out_fd. Ignore errors. */
+static int
+out_char_unchecked (int c)
+{
+ char bytes[1];
+
+ bytes[0] = (char)c;
+ full_write (out_fd, bytes, 1);
+ return 0;
+}
+
+/* State that informs the exit handler what to do. */
+static const char *restore_colors;
+static const char *restore_weight;
+static const char *restore_posture;
+static const char *restore_underline;
+
+/* The exit handler. */
+static void
+restore (void)
+{
+ /* Only do something while some output was interrupted. */
+ if (out_fd >= 0)
+ {
+ if (restore_colors != NULL)
+ tputs (restore_colors, 1, out_char_unchecked);
+ if (restore_weight != NULL)
+ tputs (restore_weight, 1, out_char_unchecked);
+ if (restore_posture != NULL)
+ tputs (restore_posture, 1, out_char_unchecked);
+ if (restore_underline != NULL)
+ tputs (restore_underline, 1, out_char_unchecked);
+ }
+}
+
+/* Compare two sets of attributes for equality. */
+static inline bool
+equal_attributes (attributes_t attr1, attributes_t attr2)
+{
+ return (attr1.color == attr2.color
+ && attr1.bgcolor == attr2.bgcolor
+ && attr1.weight == attr2.weight
+ && attr1.posture == attr2.posture
+ && attr1.underline == attr2.underline);
+}
+
+/* Convert a color in RGB encoding to BGR encoding. */
+static inline int
+color_bgr (term_color_t color)
+{
+ return ((color & 4) >> 2) | (color & 2) | ((color & 1) << 2);
+}
+
+/* Output a single char to out_fd. */
+static int
+out_char (int c)
+{
+ char bytes[1];
+
+ bytes[0] = (char)c;
+ /* We have to write directly to the file descriptor, not to a buffer with
+ the same destination, because of the padding and sleeping that tputs()
+ does. */
+ if (full_write (out_fd, bytes, 1) < 1)
+ error (EXIT_FAILURE, errno, _("error writing to %s"), out_filename);
+ return 0;
+}
+
+/* Output escape sequences to switch from OLD_ATTR to NEW_ATTR. */
+static void
+out_attr_change (term_ostream_t stream,
+ attributes_t old_attr, attributes_t new_attr)
+{
+ bool cleared_attributes;
+
+ /* We don't know the default colors of the terminal. The only way to switch
+ back to a default color is to use stream->orig_pair. */
+ if ((new_attr.color == COLOR_DEFAULT && old_attr.color != COLOR_DEFAULT)
+ || (new_attr.bgcolor == COLOR_DEFAULT && old_attr.bgcolor != COLOR_DEFAULT))
+ {
+ assert (stream->supports_foreground || stream->supports_background);
+ tputs (stream->orig_pair, 1, out_char);
+ old_attr.color = COLOR_DEFAULT;
+ old_attr.bgcolor = COLOR_DEFAULT;
+ }
+ if (new_attr.color != old_attr.color)
+ {
+ assert (stream->supports_foreground);
+ assert (new_attr.color != COLOR_DEFAULT);
+ if (stream->set_a_foreground != NULL)
+ tputs (tparm (stream->set_a_foreground, new_attr.color), 1, out_char);
+ else
+ tputs (tparm (stream->set_foreground, color_bgr (new_attr.color)),
+ 1, out_char);
+ }
+ if (new_attr.bgcolor != old_attr.bgcolor)
+ {
+ assert (stream->supports_background);
+ assert (new_attr.bgcolor != COLOR_DEFAULT);
+ if (stream->set_a_background != NULL)
+ tputs (tparm (stream->set_a_background, new_attr.bgcolor), 1, out_char);
+ else
+ tputs (tparm (stream->set_background, color_bgr (new_attr.bgcolor)),
+ 1, out_char);
+ }
+
+ cleared_attributes = false;
+ if (new_attr.weight != old_attr.weight)
+ {
+ assert (stream->supports_weight);
+ if (new_attr.weight == WEIGHT_BOLD)
+ tputs (stream->enter_bold_mode, 1, out_char);
+ else
+ {
+ /* The simplest way to clear bold mode is exit_attribute_mode.
+ With xterm, you can also do it with "Esc [ 0 m", but this escape
+ sequence is not contained in the terminfo description. */
+ tputs (stream->exit_attribute_mode, 1, out_char);
+ /* We don't know whether exit_attribute_mode clears also the
+ italics or underline mode. */
+ cleared_attributes = true;
+ }
+ }
+ if (new_attr.posture != old_attr.posture
+ || (cleared_attributes && new_attr.posture != POSTURE_DEFAULT))
+ {
+ assert (stream->supports_posture);
+ if (new_attr.posture == POSTURE_ITALIC)
+ tputs (stream->enter_italics_mode, 1, out_char);
+ else
+ {
+ if (stream->exit_italics_mode != NULL)
+ tputs (stream->exit_italics_mode, 1, out_char);
+ else if (!cleared_attributes)
+ tputs (stream->exit_attribute_mode, 1, out_char);
+ }
+ }
+ if (new_attr.underline != old_attr.underline
+ || (cleared_attributes && new_attr.underline != UNDERLINE_DEFAULT))
+ {
+ assert (stream->supports_underline);
+ if (new_attr.underline == UNDERLINE_ON)
+ tputs (stream->enter_underline_mode, 1, out_char);
+ else
+ {
+ if (stream->exit_underline_mode != NULL)
+ tputs (stream->exit_underline_mode, 1, out_char);
+ else if (!cleared_attributes)
+ tputs (stream->exit_attribute_mode, 1, out_char);
+ }
+ }
+}
+
+/* Output the buffered line atomically.
+ The terminal is assumed to have the default state (regarding colors and
+ attributes) before this call. It is left in default state after this
+ call (regardless of stream->curr_attr). */
+static void
+output_buffer (term_ostream_t stream)
+{
+ attributes_t default_attr;
+ attributes_t attr;
+ const char *cp;
+ const attributes_t *ap;
+ size_t len;
+ size_t n;
+
+ default_attr.color = COLOR_DEFAULT;
+ default_attr.bgcolor = COLOR_DEFAULT;
+ default_attr.weight = WEIGHT_DEFAULT;
+ default_attr.posture = POSTURE_DEFAULT;
+ default_attr.underline = UNDERLINE_DEFAULT;
+
+ attr = default_attr;
+
+ cp = stream->buffer;
+ ap = stream->attrbuffer;
+ len = stream->buflen;
+
+ /* See how much we can output without blocking signals. */
+ for (n = 0; n < len && equal_attributes (ap[n], attr); n++)
+ ;
+ if (n > 0)
+ {
+ if (full_write (stream->fd, cp, n) < n)
+ error (EXIT_FAILURE, errno, _("error writing to %s"), stream->filename);
+ cp += n;
+ ap += n;
+ len -= n;
+ }
+ if (len > 0)
+ {
+ /* Block fatal signals, so that a SIGINT or similar doesn't interrupt
+ us without the possibility of restoring the terminal's state. */
+ block_fatal_signals ();
+
+ /* Enable the exit handler for restoring the terminal's state. */
+ restore_colors =
+ (stream->supports_foreground || stream->supports_background
+ ? stream->orig_pair
+ : NULL);
+ restore_weight =
+ (stream->supports_weight ? stream->exit_attribute_mode : NULL);
+ restore_posture =
+ (stream->supports_posture
+ ? (stream->exit_italics_mode != NULL
+ ? stream->exit_italics_mode
+ : stream->exit_attribute_mode)
+ : NULL);
+ restore_underline =
+ (stream->supports_underline
+ ? (stream->exit_underline_mode != NULL
+ ? stream->exit_underline_mode
+ : stream->exit_attribute_mode)
+ : NULL);
+ out_fd = stream->fd;
+ out_filename = stream->filename;
+
+ while (len > 0)
+ {
+ /* Activate the attributes in *ap. */
+ out_attr_change (stream, attr, *ap);
+ attr = *ap;
+ /* See how many characters we can output without further attribute
+ changes. */
+ for (n = 1; n < len && equal_attributes (ap[n], attr); n++)
+ ;
+ if (full_write (stream->fd, cp, n) < n)
+ error (EXIT_FAILURE, errno, _("error writing to %s"),
+ stream->filename);
+ cp += n;
+ ap += n;
+ len -= n;
+ }
+
+ /* Switch back to the default attributes. */
+ out_attr_change (stream, attr, default_attr);
+
+ /* Disable the exit handler. */
+ out_fd = -1;
+ out_filename = NULL;
+
+ /* Unblock fatal signals. */
+ unblock_fatal_signals ();
+ }
+ stream->buflen = 0;
+}
+
+/* Implementation of ostream_t methods. */
+
+static void
+term_ostream::write_mem (term_ostream_t stream, const void *data, size_t len)
+{
+ const char *cp = (const char *) data;
+ while (len > 0)
+ {
+ /* Look for the next newline. */
+ const char *newline = (const char *) memchr (cp, '\n', len);
+ size_t n = (newline != NULL ? newline - cp : len);
+
+ /* Copy n bytes into the buffer. */
+ if (n > stream->allocated - stream->buflen)
+ {
+ size_t new_allocated =
+ xmax (xsum (stream->buflen, n),
+ xsum (stream->allocated, stream->allocated));
+ if (size_overflow_p (new_allocated))
+ error (EXIT_FAILURE, 0,
+ _("%s: too much output, buffer size overflow"),
+ "term_ostream");
+ stream->buffer = (char *) xrealloc (stream->buffer, new_allocated);
+ stream->attrbuffer =
+ (attributes_t *)
+ xrealloc (stream->attrbuffer,
+ new_allocated * sizeof (attributes_t));
+ stream->allocated = new_allocated;
+ }
+ memcpy (stream->buffer + stream->buflen, cp, n);
+ {
+ attributes_t attr = stream->simp_attr;
+ attributes_t *ap = stream->attrbuffer + stream->buflen;
+ attributes_t *ap_end = ap + n;
+ for (; ap < ap_end; ap++)
+ *ap = attr;
+ }
+ stream->buflen += n;
+
+ if (newline != NULL)
+ {
+ output_buffer (stream);
+ if (full_write (stream->fd, "\n", 1) < 1)
+ error (EXIT_FAILURE, errno, _("error writing to %s"),
+ stream->filename);
+ cp += n + 1; /* cp = newline + 1; */
+ len -= n + 1;
+ }
+ else
+ break;
+ }
+}
+
+static void
+term_ostream::flush (term_ostream_t stream)
+{
+ output_buffer (stream);
+}
+
+static void
+term_ostream::free (term_ostream_t stream)
+{
+ term_ostream_flush (stream);
+ free (stream->filename);
+ if (stream->set_a_foreground != NULL)
+ free (stream->set_a_foreground);
+ if (stream->set_foreground != NULL)
+ free (stream->set_foreground);
+ if (stream->set_a_background != NULL)
+ free (stream->set_a_background);
+ if (stream->set_background != NULL)
+ free (stream->set_background);
+ if (stream->orig_pair != NULL)
+ free (stream->orig_pair);
+ if (stream->enter_bold_mode != NULL)
+ free (stream->enter_bold_mode);
+ if (stream->enter_italics_mode != NULL)
+ free (stream->enter_italics_mode);
+ if (stream->exit_italics_mode != NULL)
+ free (stream->exit_italics_mode);
+ if (stream->enter_underline_mode != NULL)
+ free (stream->enter_underline_mode);
+ if (stream->exit_underline_mode != NULL)
+ free (stream->exit_underline_mode);
+ if (stream->exit_attribute_mode != NULL)
+ free (stream->exit_attribute_mode);
+ free (stream->buffer);
+ free (stream);
+}
+
+/* Implementation of term_ostream_t methods. */
+
+term_color_t
+term_ostream::get_color (term_ostream_t stream)
+{
+ return stream->curr_attr.color;
+}
+
+void
+term_ostream::set_color (term_ostream_t stream, term_color_t color)
+{
+ stream->curr_attr.color = color;
+ stream->simp_attr = simplify_attributes (stream, stream->curr_attr);
+}
+
+term_color_t
+term_ostream::get_bgcolor (term_ostream_t stream)
+{
+ return stream->curr_attr.bgcolor;
+}
+
+void
+term_ostream::set_bgcolor (term_ostream_t stream, term_color_t color)
+{
+ stream->curr_attr.bgcolor = color;
+ stream->simp_attr = simplify_attributes (stream, stream->curr_attr);
+}
+
+term_weight_t
+term_ostream::get_weight (term_ostream_t stream)
+{
+ return stream->curr_attr.weight;
+}
+
+void
+term_ostream::set_weight (term_ostream_t stream, term_weight_t weight)
+{
+ stream->curr_attr.weight = weight;
+ stream->simp_attr = simplify_attributes (stream, stream->curr_attr);
+}
+
+term_posture_t
+term_ostream::get_posture (term_ostream_t stream)
+{
+ return stream->curr_attr.posture;
+}
+
+void
+term_ostream::set_posture (term_ostream_t stream, term_posture_t posture)
+{
+ stream->curr_attr.posture = posture;
+ stream->simp_attr = simplify_attributes (stream, stream->curr_attr);
+}
+
+term_underline_t
+term_ostream::get_underline (term_ostream_t stream)
+{
+ return stream->curr_attr.underline;
+}
+
+void
+term_ostream::set_underline (term_ostream_t stream, term_underline_t underline)
+{
+ stream->curr_attr.underline = underline;
+ stream->simp_attr = simplify_attributes (stream, stream->curr_attr);
+}
+
+/* Constructor. */
+
+static inline char *
+xstrdup0 (const char *str)
+{
+ return (str != NULL ? xstrdup (str) : NULL);
+}
+
+term_ostream_t
+term_ostream_create (int fd, const char *filename)
+{
+ term_ostream_t stream = XMALLOC (struct term_ostream_representation);
+ const char *term;
+
+ stream->base.vtable = &term_ostream_vtable;
+ stream->fd = fd;
+ stream->filename = xstrdup (filename);
+
+ /* Defaults. */
+ stream->max_colors = -1;
+ stream->no_color_video = -1;
+ stream->set_a_foreground = NULL;
+ stream->set_foreground = NULL;
+ stream->set_a_background = NULL;
+ stream->set_background = NULL;
+ stream->orig_pair = NULL;
+ stream->enter_bold_mode = NULL;
+ stream->enter_italics_mode = NULL;
+ stream->exit_italics_mode = NULL;
+ stream->enter_underline_mode = NULL;
+ stream->exit_underline_mode = NULL;
+ stream->exit_attribute_mode = NULL;
+
+ /* Retrieve the terminal type. */
+ term = getenv ("TERM");
+ if (term != NULL && term[0] != '\0')
+ {
+ struct { char buf[1024]; char canary[4]; } termcapbuf;
+ int retval;
+
+ /* Call tgetent, being defensive against buffer overflow. */
+ memcpy (termcapbuf.canary, "CnRy", 4);
+ retval = tgetent (termcapbuf.buf, term);
+ if (memcmp (termcapbuf.canary, "CnRy", 4) != 0)
+ /* Buffer overflow! */
+ abort ();
+
+ /* Retrieve particular values depending on the terminal type. */
+ stream->max_colors = tgetnum ("Co");
+ stream->no_color_video = tgetnum ("nc");
+ stream->set_a_foreground = xstrdup0 (tgetstr ("AF", NULL));
+ stream->set_foreground = xstrdup0 (tgetstr ("Sf", NULL));
+ stream->set_a_background = xstrdup0 (tgetstr ("AB", NULL));
+ stream->set_background = xstrdup0 (tgetstr ("Sb", NULL));
+ stream->orig_pair = xstrdup0 (tgetstr ("op", NULL));
+ stream->enter_bold_mode = xstrdup0 (tgetstr ("md", NULL));
+ stream->enter_italics_mode = xstrdup0 (tgetstr ("ZH", NULL));
+ stream->exit_italics_mode = xstrdup0 (tgetstr ("ZR", NULL));
+ stream->enter_underline_mode = xstrdup0 (tgetstr ("us", NULL));
+ stream->exit_underline_mode = xstrdup0 (tgetstr ("ue", NULL));
+ stream->exit_attribute_mode = xstrdup0 (tgetstr ("me", NULL));
+ }
+
+ /* Infer the capabilities. */
+ stream->supports_foreground =
+ (stream->max_colors >= 8
+ && (stream->set_a_foreground != NULL || stream->set_foreground != NULL)
+ && stream->orig_pair != NULL);
+ stream->supports_background =
+ (stream->max_colors >= 8
+ && (stream->set_a_background != NULL || stream->set_background != NULL)
+ && stream->orig_pair != NULL);
+ stream->supports_weight =
+ (stream->enter_bold_mode != NULL && stream->exit_attribute_mode != NULL);
+ stream->supports_posture =
+ (stream->enter_italics_mode != NULL
+ && (stream->exit_italics_mode != NULL
+ || stream->exit_attribute_mode != NULL));
+ stream->supports_underline =
+ (stream->enter_underline_mode != NULL
+ && (stream->exit_underline_mode != NULL
+ || stream->exit_attribute_mode != NULL));
+
+ /* Initialize the buffer. */
+ stream->allocated = 120;
+ stream->buffer = XNMALLOC (stream->allocated, char);
+ stream->attrbuffer = XNMALLOC (stream->allocated, attributes_t);
+ stream->buflen = 0;
+
+ /* Initialize the current attributes. */
+ stream->curr_attr.color = COLOR_DEFAULT;
+ stream->curr_attr.bgcolor = COLOR_DEFAULT;
+ stream->curr_attr.weight = WEIGHT_DEFAULT;
+ stream->curr_attr.posture = POSTURE_DEFAULT;
+ stream->curr_attr.underline = UNDERLINE_DEFAULT;
+ stream->simp_attr = simplify_attributes (stream, stream->curr_attr);
+
+ /* Register an exit handler. */
+ {
+ static bool registered = false;
+ if (!registered)
+ {
+ atexit (restore);
+ registered = true;
+ }
+ }
+
+ return stream;
+}
projects / thirdparty / gettext.git / commitdiff
