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         file->save = anjuta_token_new_static (ANJUTA_TOKEN_FILE,  NULL);
 114         file->content = anjuta_token_new_static (ANJUTA_TOKEN_FILE,  NULL);
 115
 116         if (g_file_load_contents (file->file, NULL, &content, &length, NULL, error))
 117         {
 118                 AnjutaToken *token;
 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
 266         /* Find all token needing an update */
 267
 268         /* Find following tokens */
 269         for (last = token; last != NULL; last = anjuta_token_next (last))
 270         {
 271                 /* Get all tokens in group */
 272                 last = anjuta_token_last (last);
 273
 274                 gint flags = anjuta_token_get_flags (last);
 275                 if (!(flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))) break;
 276         }
 277
 278         /* Find first modified token */
 279         for (;;)
 280         {
 281                 gint flags = anjuta_token_get_flags (token);
 282                 if (flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))
 283                 {
 284                         /* Check previous token */
 285                         for (prev = token; prev != NULL; prev = anjuta_token_previous (prev))
 286                         {
 287                                 gint flags = anjuta_token_get_flags (prev);
 288                                 if (!(flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))) break;
 289                                 token = prev;
 290                         }
 291
 292                         break;
 293                 }
 294                 if (token == last)
 295                 {
 296                         /* No changed */
 297                         return TRUE;
 298                 }
 299                 token = anjuta_token_next (token);
 300         }
 301
 302         /* Find previous token */
 303         for (prev = token; prev != NULL; prev = anjuta_token_previous (prev))
 304         {
 305                 gint flags = anjuta_token_get_flags (prev);
 306                 if ((anjuta_token_get_length (prev) != 0) && !(flags & (ANJUTA_TOKEN_ADDED | ANJUTA_TOKEN_REMOVED))) break;
 307         }
 308
 309         /* Delete removed token and compute length of added token */
 310         added = 0;
 311         for (next = token; (next != NULL) && (next != last);)
 312         {
 313                 gint flags = anjuta_token_get_flags (next);
 314
 315                 if (flags & ANJUTA_TOKEN_REMOVED)
 316                 {
 317                         next = anjuta_token_file_remove_token (file, next);
 318                         continue;
 319                 }
 320                 else if (flags & ANJUTA_TOKEN_ADDED)
 321                 {
 322                         added += anjuta_token_get_length (next);
 323                 }
 324                 next = anjuta_token_next (next);
 325         }
 326
 327         /* Add new token */
 328         if (added != 0)
 329         {
 330                 gchar *value;
 331                 AnjutaToken *add;
 332                 AnjutaToken *start = NULL;
 333
 334                 value = g_new (gchar, added);
 335                 add = anjuta_token_prepend_child (file->save, anjuta_token_new_string_len (ANJUTA_TOKEN_NAME, value, added));
 336
 337                 /* Find token position */
 338                 if (prev != NULL)
 339                 {
 340                         start = anjuta_token_file_find_position (file, prev);
 341                         if (start != NULL) start = anjuta_token_split (start, anjuta_token_get_length (prev));
 342                 }
 343
 344                 /* Insert token */
 345                 add = anjuta_token_new_static_len (ANJUTA_TOKEN_NAME, value, added);
 346                 if (start == NULL)
 347                 {
 348                         anjuta_token_prepend_child (file->content, add);
 349                 }
 350                 else
 351                 {
 352                         anjuta_token_insert_after (start, add);
 353                 }
 354
 355                 for (next = token; (next != NULL) && (next != last); next = anjuta_token_next (next))
 356                 {
 357                         gint flags = anjuta_token_get_flags (next);
 358
 359
 360                         if (flags & ANJUTA_TOKEN_ADDED)
 361                         {
 362                                 guint len = anjuta_token_get_length (next);
 363
 364                                 if (len > 0)
 365                                 {
 366                                         memcpy(value, anjuta_token_get_string (next), len);
 367                                         anjuta_token_set_string (next, value, len);
 368                                         value += len;
 369                                 }
 370                                 anjuta_token_clear_flags (next, ANJUTA_TOKEN_ADDED);
 371                         }
 372                 }
 373         }
 374         file->dirty = TRUE;
 375
 376         return TRUE;
 377 }
 378
 379 /**
 380  * anjuta_token_file_get_token_position:
 381  * @file: #AnjutaTokenFile object
 382  * @token: token
 383  *
 384  * Returns the position of the token in the file. This position is a number
 385  * which doesn't correspond to a line number or a character but respect the
 386  * order of token in the file.
 387  *
 388  * Returns: The position of the token or 0 if the token is not in the file.
 389  */
 390 gsize
 391 anjuta_token_file_get_token_position (AnjutaTokenFile *file, AnjutaToken *token)
 392 {
 393         AnjutaToken *content;
 394         const gchar *string;
 395         gsize pos = 1;
 396
 397
 398         do
 399         {
 400                 string = anjuta_token_get_string (token);
 401                 if (string != NULL) break;
 402
 403                 /* token is a group or an empty token, looks for group members or
 404                  * following token */
 405                 token = anjuta_token_next_after_children (token);
 406         } while (token != NULL);
 407
 408         for (content = file->content; content != NULL; content = anjuta_token_next (content))
 409         {
 410                 const gchar *start;
 411                 gsize len;
 412
 413                 start = anjuta_token_get_string (content);
 414                 len = anjuta_token_get_length (content);
 415
 416                 if ((string >= start) && ((string - start) < len))
 417                 {
 418                         pos += string - start;
 419                         break;
 420                 }
 421                 else
 422                 {
 423                         pos += len;
 424                 }
 425         }
 426
 427         return content == NULL ? 0 : pos;
 428 }
 429
 430
 431 gboolean
 432 anjuta_token_file_get_token_location (AnjutaTokenFile *file, AnjutaTokenFileLocation *location, AnjutaToken *token)
 433 {
 434         AnjutaTokenFileLocation loc = {NULL, 1, 1};
 435         AnjutaToken *pos;
 436         const gchar *target;
 437
 438         anjuta_token_dump (token);
 439         do
 440         {
 441                 target = anjuta_token_get_string (token);
 442                 if (target != NULL) break;
 443
 444                 /* token is a group or an empty token, looks for group members or
 445                  * following token */
 446                 token = anjuta_token_next_after_children (token);
 447         } while (token != NULL);
 448
 449         for (pos = file->content; pos != NULL; pos = anjuta_token_next (pos))
 450         {
 451                 if (!(anjuta_token_get_flags (pos) & ANJUTA_TOKEN_REMOVED) && (anjuta_token_get_length (pos) > 0))
 452                 {
 453                         const gchar *ptr;
 454                         const gchar *end;
 455
 456                         ptr = anjuta_token_get_string (pos);
 457                         end = ptr + anjuta_token_get_length (pos);
 458
 459                         for (; ptr != end; ptr++)
 460                         {
 461                                 if (*ptr == '\n')
 462                                 {
 463                                         /* New line */
 464                                         loc.line++;
 465                                         loc.column = 1;
 466                                 }
 467                                 else
 468                                 {
 469                                         loc.column++;
 470                                 }
 471
 472                                 if (ptr == target)
 473                                 {
 474                                         if (location != NULL)
 475                                         {
 476                                                 location->filename = file->file == NULL ? NULL : g_file_get_parse_name (file->file);
 477                                                 location->line = loc.line;
 478                                                 location->column = loc.column;
 479                                         }
 480
 481                                         return TRUE;
 482                                 }
 483                         }
 484                 }
 485         }
 486
 487         return FALSE;
 488 }
 489
 490 GFile*
 491 anjuta_token_file_get_file (AnjutaTokenFile *file)
 492 {
 493         return file->file;
 494 }
 495
 496 AnjutaToken*
 497 anjuta_token_file_get_content (AnjutaTokenFile *file)
 498 {
 499         if (file->content == NULL)
 500         {
 501                 anjuta_token_file_load (file, NULL);
 502         }
 503
 504         return file->content;
 505 }
 506
 507 gboolean
 508 anjuta_token_file_is_dirty (AnjutaTokenFile *file)
 509 {
 510         return file->dirty;
 511 }
 512
 513 /* GObject functions
 514  *---------------------------------------------------------------------------*/
 515
 516 /* dispose is the first destruction step. It is used to unref object created
 517  * with instance_init in order to break reference counting cycles. This
 518  * function could be called several times. All function should still work
 519  * after this call. It has to called its parents.*/
 520
 521 static void
 522 anjuta_token_file_dispose (GObject *object)
 523 {
 524         AnjutaTokenFile *file = ANJUTA_TOKEN_FILE (object);
 525
 526         anjuta_token_file_unload (file);
 527
 528         if (file->file) g_object_unref (file->file);
 529         file->file = NULL;
 530
 531         G_OBJECT_CLASS (parent_class)->dispose (object);
 532 }
 533
 534 /* instance_init is the constructor. All functions should work after this
 535  * call. */
 536
 537 static void
 538 anjuta_token_file_instance_init (AnjutaTokenFile *file)
 539 {
 540         file->file = NULL;
 541         file->content = NULL;
 542         file->save = NULL;
 543 }
 544
 545 /* class_init intialize the class itself not the instance */
 546
 547 static void
 548 anjuta_token_file_class_init (AnjutaTokenFileClass * klass)
 549 {
 550         GObjectClass *gobject_class;
 551
 552         g_return_if_fail (klass != NULL);
 553
 554         parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
 555         gobject_class = G_OBJECT_CLASS (klass);
 556
 557         gobject_class->dispose = anjuta_token_file_dispose;
 558 }
 559
 560 GType
 561 anjuta_token_file_get_type (void)
 562 {
 563         static GType type = 0;
 564
 565         if (!type)
 566         {
 567                 static const GTypeInfo type_info =
 568                 {
 569                         sizeof (AnjutaTokenFileClass),
 570                         (GBaseInitFunc) NULL,
 571                         (GBaseFinalizeFunc) NULL,
 572                         (GClassInitFunc) anjuta_token_file_class_init,
 573                         (GClassFinalizeFunc) NULL,
 574                         NULL,           /* class_data */
 575                         sizeof (AnjutaTokenFile),
 576                         0,              /* n_preallocs */
 577                         (GInstanceInitFunc) anjuta_token_file_instance_init,
 578                         NULL            /* value_table */
 579                 };
 580
 581                 type = g_type_register_static (G_TYPE_OBJECT,
 582                                             "AnjutaTokenFile", &type_info, 0);
 583         }
 584
 585         return type;
 586 }
 587
 588
 589 /* Constructor & Destructor
 590  *---------------------------------------------------------------------------*/
 591
 592 AnjutaTokenFile *
 593 anjuta_token_file_new (GFile *gfile)
 594 {
 595         AnjutaTokenFile *file = g_object_new (ANJUTA_TOKEN_FILE_TYPE, NULL);
 596
 597         if (gfile) file->file =  g_object_ref (gfile);
 598         file->dirty = gfile != NULL;
 599
 600         return file;
 601 };
 602
 603 void
 604 anjuta_token_file_free (AnjutaTokenFile *tfile)
 605 {
 606         g_object_unref (tfile);
 607 }