PIKApp/libpikaconfig/pikaconfigwriter.c

850 lines
20 KiB
C
Raw Normal View History

2023-09-26 00:35:21 +02:00
/* LIBPIKA - The PIKA Library
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* PikaConfigWriter
* Copyright (C) 2003 Sven Neumann <sven@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <gio/gio.h>
#ifdef G_OS_WIN32
#include <gio/gwin32outputstream.h>
#else
#include <gio/gunixoutputstream.h>
#endif
#include "libpikabase/pikabase.h"
#include "pikaconfigtypes.h"
#include "pikaconfigwriter.h"
#include "pikaconfig-iface.h"
#include "pikaconfig-error.h"
#include "pikaconfig-serialize.h"
#include "pikaconfig-utils.h"
#include "libpika/libpika-intl.h"
/**
* SECTION: pikaconfigwriter
* @title: PikaConfigWriter
* @short_description: Functions for writing config info to a file for
* libpikaconfig.
*
* Functions for writing config info to a file for libpikaconfig.
**/
struct _PikaConfigWriter
{
gint ref_count;
gboolean finished;
GOutputStream *output;
GFile *file;
GError *error;
GString *buffer;
gboolean comment;
gint depth;
gint marker;
};
G_DEFINE_BOXED_TYPE (PikaConfigWriter, pika_config_writer,
pika_config_writer_ref, pika_config_writer_unref)
static inline void pika_config_writer_flush (PikaConfigWriter *writer);
static inline void pika_config_writer_newline (PikaConfigWriter *writer);
static gboolean pika_config_writer_close_output (PikaConfigWriter *writer,
GError **error);
static inline void
pika_config_writer_flush (PikaConfigWriter *writer)
{
GError *error = NULL;
if (! writer->output)
return;
if (! g_output_stream_write_all (writer->output,
writer->buffer->str,
writer->buffer->len,
NULL, NULL, &error))
{
g_set_error (&writer->error, PIKA_CONFIG_ERROR, PIKA_CONFIG_ERROR_WRITE,
_("Error writing to '%s': %s"),
writer->file ?
pika_file_get_utf8_name (writer->file) : "output stream",
error->message);
g_clear_error (&error);
}
g_string_truncate (writer->buffer, 0);
}
static inline void
pika_config_writer_newline (PikaConfigWriter *writer)
{
gint i;
g_string_append_c (writer->buffer, '\n');
if (writer->comment)
g_string_append_len (writer->buffer, "# ", 2);
for (i = 0; i < writer->depth; i++)
g_string_append_len (writer->buffer, " ", 4);
}
/**
* pika_config_writer_new_from_file:
* @file: a #GFile
* @atomic: if %TRUE the file is written atomically
* @header: text to include as comment at the top of the file
* @error: return location for errors
*
* Creates a new #PikaConfigWriter and sets it up to write to
* @file. If @atomic is %TRUE, a temporary file is used to avoid
* possible race conditions. The temporary file is then moved to @file
* when the writer is closed.
*
* Returns: (nullable): a new #PikaConfigWriter or %NULL in case of an error
*
* Since: 2.10
**/
PikaConfigWriter *
pika_config_writer_new_from_file (GFile *file,
gboolean atomic,
const gchar *header,
GError **error)
{
PikaConfigWriter *writer;
GOutputStream *output;
GFile *dir;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
dir = g_file_get_parent (file);
if (dir && ! g_file_query_exists (dir, NULL))
{
if (! g_file_make_directory_with_parents (dir, NULL, error))
g_prefix_error (error,
_("Could not create directory '%s' for '%s': "),
pika_file_get_utf8_name (dir),
pika_file_get_utf8_name (file));
}
g_object_unref (dir);
if (error && *error)
return NULL;
if (atomic)
{
output = G_OUTPUT_STREAM (g_file_replace (file,
NULL, FALSE, G_FILE_CREATE_NONE,
NULL, error));
if (! output)
g_prefix_error (error,
_("Could not create temporary file for '%s': "),
pika_file_get_utf8_name (file));
}
else
{
output = G_OUTPUT_STREAM (g_file_replace (file,
NULL, FALSE,
G_FILE_CREATE_REPLACE_DESTINATION,
NULL, error));
}
if (! output)
return NULL;
writer = g_slice_new0 (PikaConfigWriter);
writer->ref_count = 1;
writer->output = output;
writer->file = g_object_ref (file);
writer->buffer = g_string_new (NULL);
if (header)
{
pika_config_writer_comment (writer, header);
pika_config_writer_linefeed (writer);
}
return writer;
}
/**
* pika_config_writer_new_from_stream:
* @output: a #GOutputStream
* @header: text to include as comment at the top of the file
* @error: return location for errors
*
* Creates a new #PikaConfigWriter and sets it up to write to
* @output.
*
* Returns: (nullable): a new #PikaConfigWriter or %NULL in case of an error
*
* Since: 2.10
**/
PikaConfigWriter *
pika_config_writer_new_from_stream (GOutputStream *output,
const gchar *header,
GError **error)
{
PikaConfigWriter *writer;
g_return_val_if_fail (G_IS_OUTPUT_STREAM (output), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
writer = g_slice_new0 (PikaConfigWriter);
writer->ref_count = 1;
writer->output = g_object_ref (output);
writer->buffer = g_string_new (NULL);
if (header)
{
pika_config_writer_comment (writer, header);
pika_config_writer_linefeed (writer);
}
return writer;
}
/**
* pika_config_writer_new_from_fd:
* @fd:
*
* Returns: (nullable): a new #PikaConfigWriter or %NULL in case of an error
*
* Since: 2.4
**/
PikaConfigWriter *
pika_config_writer_new_from_fd (gint fd)
{
PikaConfigWriter *writer;
g_return_val_if_fail (fd > 0, NULL);
writer = g_slice_new0 (PikaConfigWriter);
writer->ref_count = 1;
#ifdef G_OS_WIN32
writer->output = g_win32_output_stream_new ((gpointer) fd, FALSE);
#else
writer->output = g_unix_output_stream_new (fd, FALSE);
#endif
writer->buffer = g_string_new (NULL);
return writer;
}
/**
* pika_config_writer_new_from_string:
* @string:
*
* Returns: (nullable): a new #PikaConfigWriter or %NULL in case of an error
*
* Since: 2.4
**/
PikaConfigWriter *
pika_config_writer_new_from_string (GString *string)
{
PikaConfigWriter *writer;
g_return_val_if_fail (string != NULL, NULL);
writer = g_slice_new0 (PikaConfigWriter);
writer->ref_count = 1;
writer->buffer = string;
return writer;
}
/**
* pika_config_writer_ref:
* @writer: #PikaConfigWriter to ref
*
* Adds a reference to a #PikaConfigWriter.
*
* Returns: the same @writer.
*
* Since: 3.0
*/
PikaConfigWriter *
pika_config_writer_ref (PikaConfigWriter *writer)
{
g_return_val_if_fail (writer != NULL, NULL);
writer->ref_count++;
return writer;
}
/**
* pika_config_writer_unref:
* @writer: #PikaConfigWriter to unref
*
* Unref a #PikaConfigWriter. If the reference count drops to zero, the
* writer is freed.
*
* Note that at least one of the references has to be dropped using
* pika_config_writer_finish().
*
* Since: 3.0
*/
void
pika_config_writer_unref (PikaConfigWriter *writer)
{
g_return_if_fail (writer != NULL);
writer->ref_count--;
if (writer->ref_count < 1)
{
if (! writer->finished)
{
GError *error = NULL;
g_printerr ("%s: dropping last reference via unref(), you should "
"call pika_config_writer_finish()\n", G_STRFUNC);
if (! pika_config_writer_finish (writer, NULL, &error))
{
g_printerr ("%s: error on finishing writer: %s\n",
G_STRFUNC, error->message);
}
}
else
{
g_slice_free (PikaConfigWriter, writer);
}
}
}
/**
* pika_config_writer_comment_mode:
* @writer: a #PikaConfigWriter
* @enable: %TRUE to enable comment mode, %FALSE to disable it
*
* This function toggles whether the @writer should create commented
* or uncommented output. This feature is used to generate the
* system-wide installed pikarc that documents the default settings.
*
* Since comments have to start at the beginning of a line, this
* function will insert a newline if necessary.
*
* Since: 2.4
**/
void
pika_config_writer_comment_mode (PikaConfigWriter *writer,
gboolean enable)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
if (writer->error)
return;
enable = (enable ? TRUE : FALSE);
if (writer->comment == enable)
return;
writer->comment = enable;
if (enable)
{
if (writer->buffer->len == 0)
g_string_append_len (writer->buffer, "# ", 2);
else
pika_config_writer_newline (writer);
}
}
/**
* pika_config_writer_open:
* @writer: a #PikaConfigWriter
* @name: name of the element to open
*
* This function writes the opening parenthesis followed by @name.
* It also increases the indentation level and sets a mark that
* can be used by pika_config_writer_revert().
*
* Since: 2.4
**/
void
pika_config_writer_open (PikaConfigWriter *writer,
const gchar *name)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
g_return_if_fail (name != NULL);
if (writer->error)
return;
/* store the current buffer length so we can revert to this state */
writer->marker = writer->buffer->len;
if (writer->depth > 0)
pika_config_writer_newline (writer);
writer->depth++;
g_string_append_printf (writer->buffer, "(%s", name);
}
/**
* pika_config_writer_print:
* @writer: a #PikaConfigWriter
* @string: a string to write
* @len: number of bytes from @string or -1 if @string is NUL-terminated.
*
* Appends a space followed by @string to the @writer. Note that string
* must not contain any special characters that might need to be escaped.
*
* Since: 2.4
**/
void
pika_config_writer_print (PikaConfigWriter *writer,
const gchar *string,
gint len)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
g_return_if_fail (len == 0 || string != NULL);
if (writer->error)
return;
if (len < 0)
len = strlen (string);
if (len)
{
g_string_append_c (writer->buffer, ' ');
g_string_append_len (writer->buffer, string, len);
}
}
/**
* pika_config_writer_printf: (skip)
* @writer: a #PikaConfigWriter
* @format: a format string as described for g_strdup_printf().
* @...: list of arguments according to @format
*
* A printf-like function for #PikaConfigWriter.
*
* Since: 2.4
**/
void
pika_config_writer_printf (PikaConfigWriter *writer,
const gchar *format,
...)
{
gchar *buffer;
va_list args;
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
g_return_if_fail (format != NULL);
if (writer->error)
return;
va_start (args, format);
buffer = g_strdup_vprintf (format, args);
va_end (args);
g_string_append_c (writer->buffer, ' ');
g_string_append (writer->buffer, buffer);
g_free (buffer);
}
/**
* pika_config_writer_string:
* @writer: a #PikaConfigWriter
* @string: a NUL-terminated string
*
* Writes a string value to @writer. The @string is quoted and special
* characters are escaped.
*
* Since: 2.4
**/
void
pika_config_writer_string (PikaConfigWriter *writer,
const gchar *string)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
if (writer->error)
return;
g_string_append_c (writer->buffer, ' ');
pika_config_string_append_escaped (writer->buffer, string);
}
/**
* pika_config_writer_identifier:
* @writer: a #PikaConfigWriter
* @identifier: a NUL-terminated string
*
* Writes an identifier to @writer. The @string is *not* quoted and special
* characters are *not* escaped.
*
* Since: 2.4
**/
void
pika_config_writer_identifier (PikaConfigWriter *writer,
const gchar *identifier)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
g_return_if_fail (identifier != NULL);
if (writer->error)
return;
g_string_append_printf (writer->buffer, " %s", identifier);
}
/**
* pika_config_writer_data:
* @writer: a #PikaConfigWriter
* @length:
* @data:
*
* Since: 2.4
**/
void
pika_config_writer_data (PikaConfigWriter *writer,
gint length,
const guint8 *data)
{
gint i;
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
g_return_if_fail (length >= 0);
g_return_if_fail (data != NULL || length == 0);
if (writer->error)
return;
g_string_append (writer->buffer, " \"");
for (i = 0; i < length; i++)
{
if (g_ascii_isalpha (data[i]))
g_string_append_c (writer->buffer, data[i]);
else
g_string_append_printf (writer->buffer, "\\%o", data[i]);
}
g_string_append (writer->buffer, "\"");
}
/**
* pika_config_writer_revert:
* @writer: a #PikaConfigWriter
*
* Reverts all changes to @writer that were done since the last call
* to pika_config_writer_open(). This can only work if you didn't call
* pika_config_writer_close() yet.
*
* Since: 2.4
**/
void
pika_config_writer_revert (PikaConfigWriter *writer)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
if (writer->error)
return;
g_return_if_fail (writer->depth > 0);
g_return_if_fail (writer->marker != -1);
g_string_truncate (writer->buffer, writer->marker);
writer->depth--;
writer->marker = -1;
}
/**
* pika_config_writer_close:
* @writer: a #PikaConfigWriter
*
* Closes an element opened with pika_config_writer_open().
*
* Since: 2.4
**/
void
pika_config_writer_close (PikaConfigWriter *writer)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
if (writer->error)
return;
g_return_if_fail (writer->depth > 0);
g_string_append_c (writer->buffer, ')');
if (--writer->depth == 0)
{
g_string_append_c (writer->buffer, '\n');
pika_config_writer_flush (writer);
}
}
/**
* pika_config_writer_finish:
* @writer: a #PikaConfigWriter
* @footer: text to include as comment at the bottom of the file
* @error: return location for possible errors
*
* This function finishes the work of @writer and unrefs it
* afterwards. It closes all open elements, appends an optional
* comment and releases all resources allocated by @writer.
*
* Using any function except pika_config_writer_ref() or
* pika_config_writer_unref() after this function is forbidden
* and will trigger warnings.
*
* Returns: %TRUE if everything could be successfully written,
* %FALSE otherwise
*
* Since: 2.4
**/
gboolean
pika_config_writer_finish (PikaConfigWriter *writer,
const gchar *footer,
GError **error)
{
gboolean success = TRUE;
g_return_val_if_fail (writer != NULL, FALSE);
g_return_val_if_fail (writer->finished == FALSE, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (writer->depth < 0)
{
g_warning ("pika_config_writer_finish: depth < 0 !!");
}
else
{
while (writer->depth)
pika_config_writer_close (writer);
}
if (footer)
{
pika_config_writer_linefeed (writer);
pika_config_writer_comment (writer, footer);
}
if (writer->output)
{
success = pika_config_writer_close_output (writer, error);
g_clear_object (&writer->file);
g_string_free (writer->buffer, TRUE);
writer->buffer = NULL;
}
if (writer->error)
{
if (error && *error == NULL)
g_propagate_error (error, writer->error);
else
g_clear_error (&writer->error);
success = FALSE;
}
writer->finished = TRUE;
pika_config_writer_unref (writer);
return success;
}
void
pika_config_writer_linefeed (PikaConfigWriter *writer)
{
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
if (writer->error)
return;
if (writer->output && writer->buffer->len == 0 && !writer->comment)
{
GError *error = NULL;
if (! g_output_stream_write_all (writer->output, "\n", 1,
NULL, NULL, &error))
{
g_set_error (&writer->error, PIKA_CONFIG_ERROR, PIKA_CONFIG_ERROR_WRITE,
_("Error writing to '%s': %s"),
writer->file ?
pika_file_get_utf8_name (writer->file) : "output stream",
error->message);
g_clear_error (&error);
}
}
else
{
pika_config_writer_newline (writer);
}
}
/**
* pika_config_writer_comment:
* @writer: a #PikaConfigWriter
* @comment: the comment to write (ASCII only)
*
* Appends the @comment to @str and inserts linebreaks and hash-marks to
* format it as a comment. Note that this function does not handle non-ASCII
* characters.
*
* Since: 2.4
**/
void
pika_config_writer_comment (PikaConfigWriter *writer,
const gchar *comment)
{
const gchar *s;
gboolean comment_mode;
gint i, len, space;
#define LINE_LENGTH 75
g_return_if_fail (writer != NULL);
g_return_if_fail (writer->finished == FALSE);
if (writer->error)
return;
g_return_if_fail (writer->depth == 0);
if (!comment)
return;
comment_mode = writer->comment;
pika_config_writer_comment_mode (writer, TRUE);
len = strlen (comment);
while (len > 0)
{
for (s = comment, i = 0, space = 0;
*s != '\n' && (i <= LINE_LENGTH || space == 0) && i < len;
s++, i++)
{
if (g_ascii_isspace (*s))
space = i;
}
if (i > LINE_LENGTH && space && *s != '\n')
i = space;
g_string_append_len (writer->buffer, comment, i);
i++;
comment += i;
len -= i;
if (len > 0)
pika_config_writer_newline (writer);
}
pika_config_writer_comment_mode (writer, comment_mode);
pika_config_writer_newline (writer);
if (writer->depth == 0)
pika_config_writer_flush (writer);
#undef LINE_LENGTH
}
static gboolean
pika_config_writer_close_output (PikaConfigWriter *writer,
GError **error)
{
g_return_val_if_fail (writer->output != NULL, FALSE);
if (writer->error)
{
GCancellable *cancellable = g_cancellable_new ();
/* Cancel the overwrite initiated by g_file_replace(). */
g_cancellable_cancel (cancellable);
g_output_stream_close (writer->output, cancellable, NULL);
g_object_unref (cancellable);
g_clear_object (&writer->output);
return FALSE;
}
if (writer->file)
{
GError *my_error = NULL;
if (! g_output_stream_close (writer->output, NULL, &my_error))
{
g_set_error (error, PIKA_CONFIG_ERROR, PIKA_CONFIG_ERROR_WRITE,
_("Error writing '%s': %s"),
pika_file_get_utf8_name (writer->file),
my_error->message);
g_clear_error (&my_error);
g_clear_object (&writer->output);
return FALSE;
}
}
g_clear_object (&writer->output);
return TRUE;
}