gimpconfigwriter.c 18.9 KB
Newer Older
1
/* LIBGIMP - The GIMP Library
2 3 4 5 6
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * GimpConfigWriter
 * Copyright (C) 2003  Sven Neumann <sven@gimp.org>
 *
7
 * This library is free software: you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 3 of the License, or (at your option) any later version.
11
 *
12
 * This library is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library.  If not, see
19
 * <https://www.gnu.org/licenses/>.
20 21 22 23
 */

#include "config.h"

24
#include <string.h>
25

26
#include <gio/gio.h>
27 28

#ifdef G_OS_WIN32
29 30 31
#include <gio/gwin32outputstream.h>
#else
#include <gio/gunixoutputstream.h>
32 33
#endif

34 35
#include "libgimpbase/gimpbase.h"

36 37
#include "gimpconfigtypes.h"

38 39
#include "gimpconfigwriter.h"
#include "gimpconfig-iface.h"
40
#include "gimpconfig-error.h"
41
#include "gimpconfig-serialize.h"
42
#include "gimpconfig-utils.h"
43

44
#include "libgimp/libgimp-intl.h"
45 46


47 48 49 50 51 52 53 54 55 56
/**
 * SECTION: gimpconfigwriter
 * @title: GimpConfigWriter
 * @short_description: Functions for writing config info to a file for
 *                     libgimpconfig.
 *
 * Functions for writing config info to a file for libgimpconfig.
 **/


57 58
struct _GimpConfigWriter
{
59 60 61 62 63 64 65
  GOutputStream *output;
  GFile         *file;
  GError        *error;
  GString       *buffer;
  gboolean       comment;
  gint           depth;
  gint           marker;
66 67 68
};


69 70 71 72
static inline void  gimp_config_writer_flush        (GimpConfigWriter  *writer);
static inline void  gimp_config_writer_newline      (GimpConfigWriter  *writer);
static gboolean     gimp_config_writer_close_output (GimpConfigWriter  *writer,
                                                     GError           **error);
73

74 75 76
static inline void
gimp_config_writer_flush (GimpConfigWriter *writer)
{
77 78
  GError *error = NULL;

79 80 81
  if (! writer->output)
    return;

82 83 84
  if (! g_output_stream_write_all (writer->output,
                                   writer->buffer->str,
                                   writer->buffer->len,
85
                                   NULL, NULL, &error))
86 87 88
    {
      g_set_error (&writer->error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
                   _("Error writing to '%s': %s"),
89 90 91
                   writer->file ?
                   gimp_file_get_utf8_name (writer->file) : "output stream",
                   error->message);
92 93
      g_clear_error (&error);
    }
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

  g_string_truncate (writer->buffer, 0);
}

static inline void
gimp_config_writer_newline (GimpConfigWriter *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);
}
111

112 113 114 115 116 117 118 119 120 121 122 123 124
/**
 * gimp_config_writer_new_file:
 * @filename: a filename
 * @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 #GimpConfigWriter and sets it up to write to
 * @filename. If @atomic is %TRUE, a temporary file is used to avoid
 * possible race conditions. The temporary file is then moved to
 * @filename when the writer is closed.
 *
 * Return value: a new #GimpConfigWriter or %NULL in case of an error
125
 *
126
 * Since: 2.4
127
 **/
128
GimpConfigWriter *
129
gimp_config_writer_new_file (const gchar  *filename,
Sven Neumann's avatar
Sven Neumann committed
130 131 132
                             gboolean      atomic,
                             const gchar  *header,
                             GError      **error)
133 134
{
  GimpConfigWriter *writer;
135
  GFile            *file;
136 137 138 139

  g_return_val_if_fail (filename != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

140
  file = g_file_new_for_path (filename);
141

142
  writer = gimp_config_writer_new_gfile (file, atomic, header, error);
143

144
  g_object_unref (file);
145 146 147 148

  return writer;
}

149 150 151 152 153 154 155 156 157 158 159 160 161 162
/**
 * gimp_config_writer_new_gfile:
 * @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 #GimpConfigWriter 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.
 *
 * Return value: a new #GimpConfigWriter or %NULL in case of an error
 *
163
 * Since: 2.10
164 165 166 167 168 169 170 171
 **/
GimpConfigWriter *
gimp_config_writer_new_gfile (GFile        *file,
                              gboolean      atomic,
                              const gchar  *header,
                              GError      **error)
{
  GimpConfigWriter *writer;
172
  GOutputStream    *output;
173
  GFile            *dir;
174 175

  g_return_val_if_fail (G_IS_FILE (file), NULL);
176
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
177

178 179 180 181 182 183 184 185 186 187 188 189 190 191
  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': "),
                        gimp_file_get_utf8_name (dir),
                        gimp_file_get_utf8_name (file));
    }
  g_object_unref (dir);

  if (error && *error)
    return NULL;

192 193
  if (atomic)
    {
194 195 196
      output = G_OUTPUT_STREAM (g_file_replace (file,
                                                NULL, FALSE, G_FILE_CREATE_NONE,
                                                NULL, error));
197
      if (! output)
198 199 200
        g_prefix_error (error,
                        _("Could not create temporary file for '%s': "),
                        gimp_file_get_utf8_name (file));
201 202 203
    }
  else
    {
204 205
      output = G_OUTPUT_STREAM (g_file_replace (file,
                                                NULL, FALSE,
206
                                                G_FILE_CREATE_REPLACE_DESTINATION,
207
                                                NULL, error));
208
    }
209

210
  if (! output)
211
    return NULL;
212

213 214 215 216 217 218 219 220 221 222 223
  writer = g_slice_new0 (GimpConfigWriter);

  writer->output = output;
  writer->file   = g_object_ref (file);
  writer->buffer = g_string_new (NULL);

  if (header)
    {
      gimp_config_writer_comment (writer, header);
      gimp_config_writer_linefeed (writer);
    }
224 225 226 227

  return writer;
}

228 229 230 231 232 233 234 235 236 237 238
/**
 * gimp_config_writer_new_stream:
 * @output: a #GOutputStream
 * @header: text to include as comment at the top of the file
 * @error: return location for errors
 *
 * Creates a new #GimpConfigWriter and sets it up to write to
 * @output.
 *
 * Return value: a new #GimpConfigWriter or %NULL in case of an error
 *
239
 * Since: 2.10
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
 **/
GimpConfigWriter *
gimp_config_writer_new_stream (GOutputStream  *output,
                               const gchar    *header,
                               GError        **error)
{
  GimpConfigWriter *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 (GimpConfigWriter);

  writer->output = g_object_ref (output);
  writer->buffer = g_string_new (NULL);

  if (header)
    {
      gimp_config_writer_comment (writer, header);
      gimp_config_writer_linefeed (writer);
    }

  return writer;
}

265 266 267 268 269 270
/**
 * gimp_config_writer_new_fd:
 * @fd:
 *
 * Return value: a new #GimpConfigWriter or %NULL in case of an error
 *
271
 * Since: 2.4
272
 **/
273
GimpConfigWriter *
274
gimp_config_writer_new_fd (gint fd)
275 276 277 278 279
{
  GimpConfigWriter *writer;

  g_return_val_if_fail (fd > 0, NULL);

280
  writer = g_slice_new0 (GimpConfigWriter);
281

282
#ifdef G_OS_WIN32
283
  writer->output = g_win32_output_stream_new ((gpointer) fd, FALSE);
284 285 286 287
#else
  writer->output = g_unix_output_stream_new (fd, FALSE);
#endif

288 289 290 291 292
  writer->buffer = g_string_new (NULL);

  return writer;
}

293 294 295 296 297 298
/**
 * gimp_config_writer_new_string:
 * @string:
 *
 * Return value: a new #GimpConfigWriter or %NULL in case of an error
 *
299
 * Since: 2.4
300
 **/
301 302 303 304 305 306 307
GimpConfigWriter *
gimp_config_writer_new_string (GString *string)
{
  GimpConfigWriter *writer;

  g_return_val_if_fail (string != NULL, NULL);

308
  writer = g_slice_new0 (GimpConfigWriter);
309 310 311 312 313 314

  writer->buffer = string;

  return writer;
}

315 316 317 318 319 320 321 322 323 324
/**
 * gimp_config_writer_comment_mode:
 * @writer: a #GimpConfigWriter
 * @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 gimprc that documents the default settings.
 *
 * Since comments have to start at the beginning of a line, this
325
 * function will insert a newline if necessary.
326
 *
327
 * Since: 2.4
328
 **/
329 330 331 332 333 334 335 336 337 338 339
void
gimp_config_writer_comment_mode (GimpConfigWriter *writer,
                                 gboolean          enable)
{
  g_return_if_fail (writer != NULL);

  if (writer->error)
    return;

  enable = (enable ? TRUE : FALSE);

340 341
  if (writer->comment == enable)
    return;
342 343

  writer->comment = enable;
344 345 346 347 348 349 350 351

  if (enable)
    {
     if (writer->buffer->len == 0)
       g_string_append_len (writer->buffer, "# ", 2);
     else
       gimp_config_writer_newline (writer);
    }
352 353 354
}


355 356 357 358 359
/**
 * gimp_config_writer_open:
 * @writer: a #GimpConfigWriter
 * @name: name of the element to open
 *
360
 * This function writes the opening parenthesis followed by @name.
361 362
 * It also increases the indentation level and sets a mark that
 * can be used by gimp_config_writer_revert().
363
 *
364
 * Since: 2.4
365
 **/
366 367
void
gimp_config_writer_open (GimpConfigWriter *writer,
Sven Neumann's avatar
Sven Neumann committed
368
                         const gchar      *name)
369 370
{
  g_return_if_fail (writer != NULL);
371
  g_return_if_fail (name != NULL);
372 373 374 375 376 377 378 379

  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)
380
    gimp_config_writer_newline (writer);
381 382 383 384 385 386

  writer->depth++;

  g_string_append_printf (writer->buffer, "(%s", name);
}

387 388 389 390 391 392 393 394
/**
 * gimp_config_writer_print:
 * @writer: a #GimpConfigWriter
 * @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.
395
 *
396
 * Since: 2.4
397
 **/
398 399
void
gimp_config_writer_print (GimpConfigWriter  *writer,
Sven Neumann's avatar
Sven Neumann committed
400 401
                          const gchar       *string,
                          gint               len)
402 403 404 405 406 407 408 409 410 411
{
  g_return_if_fail (writer != NULL);
  g_return_if_fail (len == 0 || string != NULL);

  if (writer->error)
    return;

  if (len < 0)
    len = strlen (string);

412 413 414 415 416
  if (len)
    {
      g_string_append_c (writer->buffer, ' ');
      g_string_append_len (writer->buffer, string, len);
    }
417 418
}

419 420 421 422
/**
 * gimp_config_writer_printf:
 * @writer: a #GimpConfigWriter
 * @format: a format string as described for g_strdup_printf().
423
 * @...: list of arguments according to @format
424 425
 *
 * A printf-like function for #GimpConfigWriter.
426
 *
427
 * Since: 2.4
428
 **/
429 430
void
gimp_config_writer_printf (GimpConfigWriter *writer,
Sven Neumann's avatar
Sven Neumann committed
431 432
                           const gchar      *format,
                           ...)
433 434 435 436 437 438 439 440 441 442 443 444 445 446
{
  gchar   *buffer;
  va_list  args;

  g_return_if_fail (writer != NULL);
  g_return_if_fail (format != NULL);

  if (writer->error)
    return;

  va_start (args, format);
  buffer = g_strdup_vprintf (format, args);
  va_end (args);

447
  g_string_append_c (writer->buffer, ' ');
448 449 450 451 452
  g_string_append (writer->buffer, buffer);

  g_free (buffer);
}

453 454 455 456 457 458 459
/**
 * gimp_config_writer_string:
 * @writer: a #GimpConfigWriter
 * @string: a NUL-terminated string
 *
 * Writes a string value to @writer. The @string is quoted and special
 * characters are escaped.
460
 *
461
 * Since: 2.4
462
 **/
463
void
464 465
gimp_config_writer_string (GimpConfigWriter *writer,
                           const gchar      *string)
466 467 468 469 470 471
{
  g_return_if_fail (writer != NULL);

  if (writer->error)
    return;

472 473
  g_string_append_c (writer->buffer, ' ');
  gimp_config_string_append_escaped (writer->buffer, string);
474 475
}

476 477
/**
 * gimp_config_writer_identifier:
478 479
 * @writer:     a #GimpConfigWriter
 * @identifier: a NUL-terminated string
480 481 482
 *
 * Writes an identifier to @writer. The @string is *not* quoted and special
 * characters are *not* escaped.
483
 *
484
 * Since: 2.4
485 486 487 488 489 490 491 492 493 494 495 496 497 498
 **/
void
gimp_config_writer_identifier (GimpConfigWriter *writer,
                               const gchar      *identifier)
{
  g_return_if_fail (writer != NULL);
  g_return_if_fail (identifier != NULL);

  if (writer->error)
    return;

  g_string_append_printf (writer->buffer, " %s", identifier);
}

499 500 501 502 503 504 505

/**
 * gimp_config_writer_data:
 * @writer: a #GimpConfigWriter
 * @length:
 * @data:
 *
506
 * Since: 2.4
507
 **/
508 509 510 511 512 513 514 515
void
gimp_config_writer_data (GimpConfigWriter *writer,
                         gint              length,
                         const guint8     *data)
{
  gint i;

  g_return_if_fail (writer != NULL);
516 517
  g_return_if_fail (length >= 0);
  g_return_if_fail (data != NULL || length == 0);
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534

  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, "\"");
}

535 536 537 538 539 540 541
/**
 * gimp_config_writer_revert:
 * @writer: a #GimpConfigWriter
 *
 * Reverts all changes to @writer that were done since the last call
 * to gimp_config_writer_open(). This can only work if you didn't call
 * gimp_config_writer_close() yet.
542
 *
543
 * Since: 2.4
544
 **/
545 546 547 548 549 550 551 552
void
gimp_config_writer_revert (GimpConfigWriter *writer)
{
  g_return_if_fail (writer != NULL);

  if (writer->error)
    return;

553 554 555
  g_return_if_fail (writer->depth > 0);
  g_return_if_fail (writer->marker != -1);

556 557 558
  g_string_truncate (writer->buffer, writer->marker);

  writer->depth--;
559
  writer->marker = -1;
560 561
}

562 563 564 565 566
/**
 * gimp_config_writer_close:
 * @writer: a #GimpConfigWriter
 *
 * Closes an element opened with gimp_config_writer_open().
567
 *
568
 * Since: 2.4
569
 **/
570 571 572 573 574 575 576 577
void
gimp_config_writer_close (GimpConfigWriter *writer)
{
  g_return_if_fail (writer != NULL);

  if (writer->error)
    return;

578 579
  g_return_if_fail (writer->depth > 0);

580 581 582 583 584 585
  g_string_append_c (writer->buffer, ')');

  if (--writer->depth == 0)
    {
      g_string_append_c (writer->buffer, '\n');

586
      gimp_config_writer_flush (writer);
587 588 589
    }
}

590 591 592 593 594 595 596 597 598 599 600 601 602
/**
 * gimp_config_writer_finish:
 * @writer: a #GimpConfigWriter
 * @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 frees it afterwards.
 * It closes all open elements, appends an optional comment and
 * releases all resources allocated by @writer. You must not access
 * the @writer afterwards.
 *
 * Return value: %TRUE if everything could be successfully written,
 *               %FALSE otherwise
603
 *
604
 * Since: 2.4
605
 **/
606 607
gboolean
gimp_config_writer_finish (GimpConfigWriter  *writer,
Sven Neumann's avatar
Sven Neumann committed
608 609
                           const gchar       *footer,
                           GError           **error)
610 611 612 613 614 615 616 617 618 619 620 621 622
{
  gboolean success = TRUE;

  g_return_val_if_fail (writer != NULL, FALSE);
  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  if (writer->depth < 0)
    {
      g_warning ("gimp_config_writer_finish: depth < 0 !!");
    }
  else
    {
      while (writer->depth)
Sven Neumann's avatar
Sven Neumann committed
623
        gimp_config_writer_close (writer);
624 625 626 627 628 629 630 631
    }

  if (footer)
    {
      gimp_config_writer_linefeed (writer);
      gimp_config_writer_comment (writer, footer);
    }

632
  if (writer->output)
633
    {
634
      success = gimp_config_writer_close_output (writer, error);
635

636 637
      if (writer->file)
        g_object_unref (writer->file);
638

639 640
      g_string_free (writer->buffer, TRUE);
    }
641

642 643
  if (writer->error)
    {
644 645 646 647 648
      if (error && *error == NULL)
        g_propagate_error (error, writer->error);
      else
        g_clear_error (&writer->error);

649
      success = FALSE;
650 651
    }

652 653
  g_slice_free (GimpConfigWriter, writer);

654 655 656 657 658 659 660
  return success;
}

void
gimp_config_writer_linefeed (GimpConfigWriter *writer)
{
  g_return_if_fail (writer != NULL);
661

662 663 664
  if (writer->error)
    return;

665
  if (writer->output && writer->buffer->len == 0 && !writer->comment)
666
    {
667 668 669
      GError *error = NULL;

      if (! g_output_stream_write_all (writer->output, "\n", 1,
670
                                       NULL, NULL, &error))
671 672 673
        {
          g_set_error (&writer->error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
                       _("Error writing to '%s': %s"),
674 675 676
                       writer->file ?
                       gimp_file_get_utf8_name (writer->file) : "output stream",
                       error->message);
677 678
          g_clear_error (&error);
        }
679 680 681
    }
  else
    {
682
      gimp_config_writer_newline (writer);
683
    }
684 685
}

686 687 688 689 690 691 692 693
/**
 * gimp_config_writer_comment:
 * @writer: a #GimpConfigWriter
 * @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.
694
 *
695
 * Since: 2.4
696
 **/
697 698
void
gimp_config_writer_comment (GimpConfigWriter *writer,
Sven Neumann's avatar
Sven Neumann committed
699
                            const gchar      *comment)
700
{
701
  const gchar *s;
702
  gboolean     comment_mode;
703 704 705 706
  gint         i, len, space;

#define LINE_LENGTH 75

707 708 709 710 711
  g_return_if_fail (writer != NULL);

  if (writer->error)
    return;

712 713
  g_return_if_fail (writer->depth == 0);

714 715 716
  if (!comment)
    return;

717 718
  comment_mode = writer->comment;
  gimp_config_writer_comment_mode (writer, TRUE);
719

720
  len = strlen (comment);
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740

  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;
741 742 743

      if (len > 0)
        gimp_config_writer_newline (writer);
744 745
    }

746 747
  gimp_config_writer_comment_mode (writer, comment_mode);
  gimp_config_writer_newline (writer);
748

749 750 751 752 753 754
  if (writer->depth == 0)
    gimp_config_writer_flush (writer);

#undef LINE_LENGTH
}

755
static gboolean
756 757
gimp_config_writer_close_output (GimpConfigWriter  *writer,
                                 GError           **error)
758
{
759 760
  g_return_val_if_fail (writer->output != NULL, FALSE);

761 762
  if (writer->error)
    {
763 764
      g_object_unref (writer->output);
      writer->output = NULL;
765

766
      return FALSE;
767 768
    }

769
  if (writer->file)
Sven Neumann's avatar
Sven Neumann committed
770
    {
771
      GError *my_error = NULL;
Sven Neumann's avatar
Sven Neumann committed
772

773 774 775 776 777 778 779
      if (! g_output_stream_close (writer->output, NULL, &my_error))
        {
          g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
                       _("Error writing '%s': %s"),
                       gimp_file_get_utf8_name (writer->file),
                       my_error->message);
          g_clear_error (&my_error);
780

781 782 783 784 785
          g_object_unref (writer->output);
          writer->output = NULL;

          return FALSE;
        }
786 787
    }

788 789
  g_object_unref (writer->output);
  writer->output = NULL;
790 791 792

  return TRUE;
}