libanjuta/anjuta-token-file.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta-token-file.c
   4  * Copyright (C) Sébastien Granjoux 2009 <seb.sfo@free.fr>
   5  *
   6  * This program is free software: you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14  * See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "anjuta-token-file.h"
  21
  22 #include "anjuta-debug.h"
  23
  24 #include <glib-object.h>
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 /* Types declarations
  30  *---------------------------------------------------------------------------*/
  31
  32 struct _AnjutaTokenFile
  33 {
  34         GObject parent;
  35
  36         GFile* file;                            /* Corresponding GFile */
  37
  38         AnjutaToken *content;           /* Current file content */
  39
  40         AnjutaToken *save;                      /* List of memory block used */
  41
  42         gboolean dirty;                                 /* Set when the file has been modified */
  43 };
  44
  45 struct _AnjutaTokenFileClass
  46 {
  47         GObjectClass parent_class;
  48 };
  49
  50 static GObjectClass *parent_class = NULL;
  51
  52 /* Helpers functions
  53  *---------------------------------------------------------------------------*/
  54
  55 /* Private functions
  56  *---------------------------------------------------------------------------*/
  57
  58 static AnjutaToken*
  59 anjuta_token_file_find_position (AnjutaTokenFile *file, AnjutaToken *token)
  60 {
  61         AnjutaToken *start;
  62         const gchar *pos;
  63         const gchar *ptr;
  64         const gchar *end;
  65
  66         if (token == NULL) return NULL;
  67
  68         if (anjuta_token_get_length (token) == 0)
  69         {
  70                 AnjutaToken *last = anjuta_token_last (token);
  71
  72                 for (; (token != NULL) && (token != last); token = anjuta_token_next (token))
  73                 {
  74                         if (anjuta_token_get_length (token) != 0) break;
  75                 }
  76
  77                 if (anjuta_token_get_length (token) == 0) return NULL;
  78         }
  79
  80         pos = anjuta_token_get_string (token);
  81         for (start = file->content; start != NULL; start = anjuta_token_next (start))
  82         {
  83                 guint len = anjuta_token_get_length (start);
  84
  85                 if (len)
  86                 {
  87                         ptr = anjuta_token_get_string (start);
  88                         end = ptr + len;
  89
  90                         if ((pos >= ptr) && (pos < end)) break;
  91                 }
  92         }
  93         if ((start != NULL) && (ptr != pos))
  94         {
  95                 start = anjuta_token_split (start, pos - ptr);
  96                 start = anjuta_token_next (start);
  97         }
  98
  99         return start;
 100 }
 101
 102 /* Public functions
 103  *---------------------------------------------------------------------------*/
 104
 105 AnjutaToken*
 106 anjuta_token_file_load (AnjutaTokenFile *file, GError **error)
 107 {
 108         gchar *content;
 109         gsize length;
 110
 111         anjuta_token_file_unload (file);
 112
 113         if (g_file_load_contents (file->file, NULL, &content, &length, NULL, error))
 114         {
 115                 AnjutaToken *token;
 116
 117                 file->save = anjuta_token_new_static (ANJUTA_TOKEN_FILE,  NULL);
 118                 file->content = anjuta_token_new_static (ANJUTA_TOKEN_FILE,  NULL);
 119
 120                 token = anjuta_token_new_string_len (ANJUTA_TOKEN_FILE, content, length);
 121                 anjuta_token_prepend_child (file->save, token);
 122
 123                 token = anjuta_token_new_static (ANJUTA_TOKEN_FILE, content);
 124                 anjuta_token_prepend_child (file->content, token);
 125                 file->dirty = FALSE;
 126         }
 127
 128         return file->content;
 129 }
 130
 131 gboolean
 132 anjuta_token_file_unload (AnjutaTokenFile *file)
 133 {
 134         if (file->content != NULL) anjuta_token_free (file->content);
 135         file->content = NULL;
 136
 137         if (file->save != NULL) anjuta_token_free (file->save);
 138         file->save = NULL;
 139
 140         return TRUE;
 141 }
 142
 143 gboolean
 144 anjuta_token_file_save (AnjutaTokenFile *file, GError **error)
 145 {
 146         GFileOutputStream *stream;
 147         gboolean ok = TRUE;
 148         GError *err = NULL;
 149         AnjutaToken *token;
 150
 151         stream = g_file_replace (file->file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &err);
 152         if (stream == NULL)
 153         {
 154                 if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
 155                 {
 156                         /* Perhaps parent directory is missing, try to create it */
 157                         GFile *parent = g_file_get_parent (file->file);
 158
 159                         if (g_file_make_directory_with_parents (parent, NULL, NULL))
 160                         {
 161                                 g_object_unref (parent);
 162                                 g_clear_error (&err);
 163                                 stream = g_file_replace (file->file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error);
 164                                 if (stream == NULL) return FALSE;
 165                         }
 166                         else
 167                         {
 168                                 g_object_unref (parent);
 169                                 g_propagate_error (error, err);
 170
 171                                 return FALSE;
 172                         }
 173                 }
 174                 else
 175                 {
 176                         g_propagate_error (error, err);
 177                         return FALSE;
 178                 }
 179         }
 180
 181         for (token = file->content; token != NULL; token = anjuta_token_next (token))
 182         {
 183                 if (!(anjuta_token_get_flags (token) & ANJUTA_TOKEN_REMOVED) && (anjuta_token_get_length (token)))
 184                 {
 185                         if (g_output_stream_write (G_OUTPUT_STREAM (stream), anjuta_token_get_string (token), anjuta_token_get_length (token) * sizeof (char), NULL, error) < 0)
 186                         {
 187                                 ok = FALSE;
 188                                 break;
 189                         }
 190                 }
 191         }
 192
 193         ok = ok && g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, NULL);
 194         g_object_unref (stream);
 195         file->dirty = FALSE;
 196
 197         return ok;
 198 }
 199
 200 void
 201 anjuta_token_file_move (AnjutaTokenFile *file, GFile *new_file)
 202 {
 203         if (file->file) g_object_unref (file->file);
 204         file->file = new_file != NULL ? g_object_ref (new_file) : NULL;
 205         file->dirty = new_file != NULL;
 206 }
 207
 208 static void
 209 remove_raw_token (AnjutaToken *token, gpointer user_data)
 210 {
 211         AnjutaTokenFile *file = (AnjutaTokenFile *)user_data;
 212
 213         if ((anjuta_token_get_length (token) > 0))
 214         {
 215                 AnjutaToken *pos = anjuta_token_file_find_position (file, token);
 216                 guint len = anjuta_token_get_length (token);
 217
 218                 if (pos != NULL)
 219                 {
 220                         while (len != 0)
 221                         {
 222                                 guint flen = anjuta_token_get_length (pos);
 223                                 if (len < flen)
 224                                 {
 225                                         pos = anjuta_token_split (pos, len);
 226                                         flen = len;
 227                                 }
 228                                 pos = anjuta_token_free (pos);
 229                                 len -= flen;
 230                         }
 231                 }
 232         }
 233 }
 234
 235 static AnjutaToken *
 236 anjuta_token_file_remove_token (AnjutaTokenFile *file, AnjutaToken *token)
 237 {
 238         AnjutaToken *next = NULL;
 239
 240         if (token != NULL) next = anjuta_token_foreach_post_order (token, remove_raw_token, file);
 241
 242         next = anjuta_token_free (token);
 243         file->dirty = TRUE;
 244
 245         return next;
 246 }
 247
 248 /**
 249  * anjuta_token_file_update:
 250  * @file: a #AnjutaTokenFile derived class object.
 251  * @token: Token to update.
 252  *
 253  * Update the file with all changed token starting from @token. The function can
 254  * return an error if the token is not in the file.
 255  *
 256  * Return value: TRUE is the update is done without error.
 257  */
 258 gboolean
 259 anjuta_token_file_update (AnjutaTokenFile *file, AnjutaToken *token)
 260 {
 261         AnjutaToken *prev;
 262         AnjutaToken *next;
 263         AnjutaToken *last;
 264         guint added;
 265         gchar *value;
 266
 267         /* Find all token needing an update */
 268
 269         /* Find following tokens */
 270         for (last = token; last != NULL; last = anjuta_token_next (last))
 271         {
 272                 /* Get all tokens in group */
 273                 last = anjuta_token_last (last);
 274
 275                 gint flags = anjuta_token_get_flags (last);
 276                 if (!(flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))) break;
 277         }
 278
 279         /* Find first modified token */
 280         for (;;)
 281         {
 282                 gint flags = anjuta_token_get_flags (token);
 283                 if (flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))
 284                 {
 285                         /* Check previous token */
 286                         for (prev = token; prev != NULL; prev = anjuta_token_previous (prev))
 287                         {
 288                                 gint flags = anjuta_token_get_flags (prev);
 289                                 if (!(flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))) break;
 290                                 token = prev;
 291                         }
 292
 293                         break;
 294                 }
 295                 if (token == last)
 296                 {
 297                         /* No changed */
 298                         return TRUE;
 299                 }
 300                 token = anjuta_token_next (token);
 301         }
 302
 303         /* Find previous token */
 304         for (prev = token; prev != NULL; prev = anjuta_token_previous (prev))
 305         {
 306                 gint flags = anjuta_token_get_flags (prev);
 307                 if ((anjuta_token_get_length (prev) != 0) && !(flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))) break;
 308         }
 309
 310         /* Delete removed token and compute length of added token */
 311         added = 0;
 312         for (next = token; (next != NULL) && (next != last);)
 313         {
 314                 gint flags = anjuta_token_get_flags (next);
 315
 316                 if (flags & ANJUTA_TOKEN_ADDED)
 317                 {
 318                         added += anjuta_token_get_length (next);
 319                 }
 320                 next = anjuta_token_next (next);
 321         }
 322
 323         /* Add new token */
 324         if (added != 0)
 325         {
 326                 AnjutaToken *add;
 327                 AnjutaToken *start = NULL;
 328
 329                 value = g_new (gchar, added);
 330                 add = anjuta_token_prepend_child (file->save, anjuta_token_new_string_len (ANJUTA_TOKEN_NAME, value, added));
 331
 332                 /* Find token position */
 333                 if (prev != NULL)
 334                 {
 335                         start = anjuta_token_file_find_position (file, prev);
 336                         if (start != NULL) start = anjuta_token_split (start, anjuta_token_get_length (prev));
 337                 }
 338
 339                 /* Insert token */
 340                 add = anjuta_token_new_static_len (ANJUTA_TOKEN_NAME, value, added);
 341                 if (start == NULL)
 342                 {
 343                         anjuta_token_prepend_child (file->content, add);
 344                 }
 345                 else
 346                 {
 347                         anjuta_token_insert_after (start, add);
 348                 }
 349         }
 350
 351         for (next = token; (next != NULL) && (next != last);)
 352         {
 353                 gint flags = anjuta_token_get_flags (next);
 354
 355                 if (flags & ANJUTA_TOKEN_ADDED)
 356                 {
 357                         guint len = anjuta_token_get_length (next);
 358
 359                         if (len > 0)
 360                         {
 361                                 memcpy(value, anjuta_token_get_string (next), len);
 362                                 anjuta_token_set_string (next, value, len);
 363                                 value += len;
 364                         }
 365                         anjuta_token_clear_flags (next, ANJUTA_TOKEN_ADDED);
 366                 }
 367                 else if (flags & ANJUTA_TOKEN_REMOVED)
 368                 {
 369                         next = anjuta_token_file_remove_token (file, next);
 370                         continue;
 371                 }
 372                 next = anjuta_token_next (next);
 373         }
 374
 375         file->dirty = TRUE;
 376
 377         return TRUE;
 378 }
 379
 380 /**
 381  * anjuta_token_file_get_token_position:
 382  * @file: #AnjutaTokenFile object
 383  * @token: token
 384  *
 385  * Returns the position of the token in the file. This position is a number
 386  * which doesn't correspond to a line number or a character but respect the
 387  * order of token in the file.
 388  *
 389  * Returns: The position of the token or 0 if the token is not in the file.
 390  */
 391 gsize
 392 anjuta_token_file_get_token_position (AnjutaTokenFile *file, AnjutaToken *token)
 393 {
 394         AnjutaToken *content;
 395         const gchar *string;
 396         gsize pos = 1;
 397
 398
 399         do
 400         {
 401                 string = anjuta_token_get_string (token);
 402                 if (string != NULL) break;
 403
 404                 /* token is a group or an empty token, looks for group members or
 405                  * following token */
 406                 token = anjuta_token_next_after_children (token);
 407         } while (token != NULL);
 408
 409         for (content = file->content; content != NULL; content = anjuta_token_next (content))
 410         {
 411                 const gchar *start;
 412                 gsize len;
 413
 414                 start = anjuta_token_get_string (content);
 415                 len = anjuta_token_get_length (content);
 416
 417                 if ((string >= start) && ((string - start) < len))
 418                 {
 419                         pos += string - start;
 420                         break;
 421                 }
 422                 else
 423                 {
 424                         pos += len;
 425                 }
 426         }
 427
 428         return content == NULL ? 0 : pos;
 429 }
 430
 431
 432 gboolean
 433 anjuta_token_file_get_token_location (AnjutaTokenFile *file, AnjutaTokenFileLocation *location, AnjutaToken *token)
 434 {
 435         AnjutaTokenFileLocation loc = {NULL, 1, 1};
 436         AnjutaToken *pos;
 437         const gchar *target;
 438
 439         anjuta_token_dump (token);
 440         do
 441         {
 442                 target = anjuta_token_get_string (token);
 443                 if (target != NULL) break;
 444
 445                 /* token is a group or an empty token, looks for group members or
 446                  * following token */
 447                 token = anjuta_token_next_after_children (token);
 448         } while (token != NULL);
 449
 450         for (pos = file->content; pos != NULL; pos = anjuta_token_next (pos))
 451         {
 452                 if (!(anjuta_token_get_flags (pos) & ANJUTA_TOKEN_REMOVED) && (anjuta_token_get_length (pos) > 0))
 453                 {
 454                         const gchar *ptr;
 455                         const gchar *end;
 456
 457                         ptr = anjuta_token_get_string (pos);
 458                         end = ptr + anjuta_token_get_length (pos);
 459
 460                         for (; ptr != end; ptr++)
 461                         {
 462                                 if (*ptr == '\n')
 463                                 {
 464                                         /* New line */
 465                                         loc.line++;
 466                                         loc.column = 1;
 467                                 }
 468                                 else
 469                                 {
 470                                         loc.column++;
 471                                 }
 472
 473                                 if (ptr == target)
 474                                 {
 475                                         if (location != NULL)
 476                                         {
 477                                                 location->filename = file->file == NULL ? NULL : g_file_get_parse_name (file->file);
 478                                                 location->line = loc.line;
 479                                                 location->column = loc.column;
 480                                         }
 481
 482                                         return TRUE;
 483                                 }
 484                         }
 485                 }
 486         }
 487
 488         return FALSE;
 489 }
 490
 491 GFile*
 492 anjuta_token_file_get_file (AnjutaTokenFile *file)
 493 {
 494         return file->file;
 495 }
 496
 497 AnjutaToken*
 498 anjuta_token_file_get_content (AnjutaTokenFile *file)
 499 {
 500         if (file->content == NULL)
 501         {
 502                 anjuta_token_file_load (file, NULL);
 503         }
 504
 505         return file->content;
 506 }
 507
 508 gboolean
 509 anjuta_token_file_is_dirty (AnjutaTokenFile *file)
 510 {
 511         return file->dirty;
 512 }
 513
 514 /* GObject functions
 515  *---------------------------------------------------------------------------*/
 516
 517 /* dispose is the first destruction step. It is used to unref object created
 518  * with instance_init in order to break reference counting cycles. This
 519  * function could be called several times. All function should still work
 520  * after this call. It has to called its parents.*/
 521
 522 static void
 523 anjuta_token_file_dispose (GObject *object)
 524 {
 525         AnjutaTokenFile *file = ANJUTA_TOKEN_FILE (object);
 526
 527         anjuta_token_file_unload (file);
 528
 529         if (file->file) g_object_unref (file->file);
 530         file->file = NULL;
 531
 532         G_OBJECT_CLASS (parent_class)->dispose (object);
 533 }
 534
 535 /* instance_init is the constructor. All functions should work after this
 536  * call. */
 537
 538 static void
 539 anjuta_token_file_instance_init (AnjutaTokenFile *file)
 540 {
 541         file->file = NULL;
 542         file->content = NULL;
 543         file->save = NULL;
 544 }
 545
 546 /* class_init intialize the class itself not the instance */
 547
 548 static void
 549 anjuta_token_file_class_init (AnjutaTokenFileClass * klass)
 550 {
 551         GObjectClass *gobject_class;
 552
 553         g_return_if_fail (klass != NULL);
 554
 555         parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
 556         gobject_class = G_OBJECT_CLASS (klass);
 557
 558         gobject_class->dispose = anjuta_token_file_dispose;
 559 }
 560
 561 GType
 562 anjuta_token_file_get_type (void)
 563 {
 564         static GType type = 0;
 565
 566         if (!type)
 567         {
 568                 static const GTypeInfo type_info =
 569                 {
 570                         sizeof (AnjutaTokenFileClass),
 571                         (GBaseInitFunc) NULL,
 572                         (GBaseFinalizeFunc) NULL,
 573                         (GClassInitFunc) anjuta_token_file_class_init,
 574                         (GClassFinalizeFunc) NULL,
 575                         NULL,           /* class_data */
 576                         sizeof (AnjutaTokenFile),
 577                         0,              /* n_preallocs */
 578                         (GInstanceInitFunc) anjuta_token_file_instance_init,
 579                         NULL            /* value_table */
 580                 };
 581
 582                 type = g_type_register_static (G_TYPE_OBJECT,
 583                                             "AnjutaTokenFile", &type_info, 0);
 584         }
 585
 586         return type;
 587 }
 588
 589
 590 /* Constructor & Destructor
 591  *---------------------------------------------------------------------------*/
 592
 593 AnjutaTokenFile *
 594 anjuta_token_file_new (GFile *gfile)
 595 {
 596         AnjutaTokenFile *file = g_object_new (ANJUTA_TOKEN_FILE_TYPE, NULL);
 597
 598         if (gfile) file->file =  g_object_ref (gfile);
 599         file->dirty = gfile != NULL;
 600
 601         return file;
 602 };
 603
 604 void
 605 anjuta_token_file_free (AnjutaTokenFile *tfile)
 606 {
 607         g_object_unref (tfile);
 608 }