plugins/am-project/ac-writer.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4; coding: utf-8 -*- */
   2 /* ac-writer.c
   3  *
   4  * Copyright (C) 2009  Sébastien Granjoux
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <string.h>
  28
  29 #include "ac-writer.h"
  30 #include "ac-scanner.h"
  31 #include "ac-parser.h"
  32 #include "amp-node.h"
  33 #include "amp-module.h"
  34 #include "amp-package.h"
  35
  36
  37 #include "am-project-private.h"
  38
  39 #include <libanjuta/anjuta-debug.h>
  40 #include <libanjuta/anjuta-utils.h>
  41
  42 /* Types
  43   *---------------------------------------------------------------------------*/
  44
  45
  46 /* Helper functions
  47  *---------------------------------------------------------------------------*/
  48
  49 /* Private functions
  50  *---------------------------------------------------------------------------*/
  51
  52 static AnjutaToken *
  53 anjuta_token_find_position (AnjutaToken *list, gboolean after, AnjutaTokenType type, AnjutaToken *sibling)
  54 {
  55         AnjutaToken *tok;
  56         AnjutaToken *pos = sibling;
  57
  58         if (sibling == NULL)
  59         {
  60                 AnjutaToken *last = NULL;
  61                 gboolean found = FALSE;
  62
  63                 for (tok = list; tok != NULL; tok = anjuta_token_next (tok))
  64                 {
  65                         AnjutaTokenType current = anjuta_token_get_type (tok);
  66
  67                         if ((current >= AC_TOKEN_FIRST_ORDERED_MACRO) && (current <= AC_TOKEN_LAST_ORDERED_MACRO))
  68                         {
  69                                 /* Find a valid position */
  70                                 if (after)
  71                                 {
  72                                         /*  1. After the last similar macro
  73                                          *  2. After the last macro with a higher priority
  74                                          *  3. At the end of the file
  75                                          */
  76                                         if (current == type)
  77                                         {
  78                                                 pos = tok;
  79                                                 found = TRUE;
  80                                         }
  81                                         else if (!found && (current < type))
  82                                         {
  83                                                 pos = tok;
  84                                         }
  85                                 }
  86                                 else
  87                                 {
  88                                         /*  1. Before the first similar macro
  89                                          *  2. Before the first macro with an lower priority
  90                                          *  3. At the beginning of the file
  91                                          */
  92                                         if (current == type)
  93                                         {
  94                                                 pos = tok;
  95                                                 break;
  96                                         }
  97                                         else if (!found && (current > type))
  98                                         {
  99                                                 pos = tok;
 100                                                 found = TRUE;
 101                                         }
 102                                 }
 103                         }
 104                         last = tok;
 105                 }
 106
 107
 108                 if (after && (pos == NULL)) pos = last;
 109         }
 110
 111         if (after)
 112         {
 113                 for (; pos != NULL; pos = anjuta_token_next (pos))
 114                 {
 115                         AnjutaTokenType current = anjuta_token_get_type (pos);
 116
 117                         if (current == ANJUTA_TOKEN_EOL) break;
 118                 }
 119         }
 120
 121
 122         return pos;
 123 }
 124
 125 static AnjutaToken*
 126 find_tokens (AnjutaToken *list, AnjutaTokenType* types)
 127 {
 128         AnjutaToken *tok;
 129
 130         for (tok = list; tok != NULL; tok = anjuta_token_next (tok))
 131         {
 132                 AnjutaTokenType *type;
 133                 for (type = types; *type != 0; type++)
 134                 {
 135                         if (anjuta_token_get_type (tok) == *type)
 136                         {
 137                                 return tok;
 138                         }
 139                 }
 140         }
 141
 142         return NULL;
 143 }
 144
 145 static AnjutaToken *
 146 skip_comment (AnjutaToken *token)
 147 {
 148         if (token == NULL) return NULL;
 149
 150         for (;;)
 151         {
 152                 for (;;)
 153                 {
 154                         AnjutaToken *next = anjuta_token_next (token);
 155
 156                         if (next == NULL) return token;
 157
 158                         switch (anjuta_token_get_type (token))
 159                         {
 160                         case ANJUTA_TOKEN_FILE:
 161                         case SPACE:
 162                                 token = next;
 163                                 continue;
 164                         case COMMENT:
 165                                 token = next;
 166                                 break;
 167                         default:
 168                                 return token;
 169                         }
 170                         break;
 171                 }
 172
 173                 for (;;)
 174                 {
 175                         AnjutaToken *next = anjuta_token_next (token);
 176
 177                         if (next == NULL) return token;
 178                         token = next;
 179                         if (anjuta_token_get_type (token) == END_OF_LINE) break;
 180                 }
 181         }
 182 }
 183
 184 /* Find an already existing property using the same token */
 185 static AmpProperty *
 186 find_similar_property (AnjutaProjectNode *node, AmpProperty *property)
 187 {
 188         GList *item;
 189
 190         for (item = anjuta_project_node_get_properties (node); item != NULL; item = g_list_next (item))
 191         {
 192                 AmpProperty *prop = (AmpProperty *)item->data;
 193
 194                 if ((((AmpPropertyInfo *)prop->base.info)->token_type == ((AmpPropertyInfo *)property->base.info)->token_type) && (prop->token != NULL))
 195                 {
 196                         return prop;
 197                 }
 198         }
 199
 200         return NULL;
 201 }
 202
 203 /* Public functions
 204  *---------------------------------------------------------------------------*/
 205
 206 gboolean
 207 amp_project_update_ac_property (AmpProject *project, AnjutaProjectProperty *property)
 208 {
 209         AnjutaToken *token;
 210         AnjutaToken *arg;
 211         AnjutaToken *args;
 212         AmpProperty *prop;
 213         AmpPropertyInfo *info;
 214
 215         if (g_strcmp0 (((AmpPropertyInfo *)property->info)->value, property->value) == 0)
 216         {
 217                 /* Remove property */
 218                 info = (AmpPropertyInfo *)property->info;
 219                 prop = (AmpProperty *)property;
 220
 221                 if (info->position == -1)
 222                 {
 223                         token = prop->token;
 224
 225                         anjuta_token_remove_list (anjuta_token_list (token));
 226                 }
 227
 228                 anjuta_project_node_remove_property (ANJUTA_PROJECT_NODE (project), property);
 229         }
 230         else
 231         {
 232                 info = (AmpPropertyInfo *)property->info;
 233                 prop = find_similar_property (ANJUTA_PROJECT_NODE (project), (AmpProperty *)property);
 234                 args = prop != NULL ? prop->token : NULL;
 235
 236                 prop = (AmpProperty *)property;
 237
 238                 if (args == NULL)
 239                 {
 240                         AnjutaToken *group;
 241                         AnjutaToken *configure;
 242                         const char *suffix;
 243
 244                         configure = amp_project_get_configure_token (project);
 245                         token = anjuta_token_find_position (configure, TRUE, info->token_type, NULL);
 246                         if (token == NULL)
 247                         {
 248                                 token = skip_comment (configure);
 249                                 if (token == NULL)
 250                                 {
 251                                         token = anjuta_token_append_child (configure, anjuta_token_new_string (COMMENT | ANJUTA_TOKEN_ADDED, "#"));
 252                                         token = anjuta_token_insert_after (token, anjuta_token_new_string (SPACE | ANJUTA_TOKEN_ADDED, " Created by Anjuta project manager"));
 253                                         token = anjuta_token_insert_after (token, anjuta_token_new_string (END_OF_LINE | ANJUTA_TOKEN_ADDED, "\n"));
 254                                         token = anjuta_token_insert_after (token, anjuta_token_new_string (END_OF_LINE | ANJUTA_TOKEN_ADDED, "\n"));
 255                                 }
 256                         }
 257
 258                         suffix = info->suffix;
 259                         token = anjuta_token_insert_after (token, anjuta_token_new_string (AC_TOKEN_AC_INIT | ANJUTA_TOKEN_ADDED, suffix));
 260                         if (suffix[strlen(suffix) - 1] == '(')
 261                         {
 262                                 group = anjuta_token_insert_after (token, anjuta_token_new_static (ANJUTA_TOKEN_LIST | ANJUTA_TOKEN_ADDED, NULL));
 263                                 args = group;
 264                                 token = anjuta_token_insert_after (group, anjuta_token_new_static (ANJUTA_TOKEN_LAST | ANJUTA_TOKEN_ADDED, NULL));
 265                                 anjuta_token_merge (group, token);
 266                         }
 267                         anjuta_token_insert_after (token, anjuta_token_new_string (END_OF_LINE | ANJUTA_TOKEN_ADDED, "\n"));
 268                 }
 269                 if (args != NULL)
 270                 {
 271                         guint pos;
 272
 273                         token = anjuta_token_new_string (ANJUTA_TOKEN_NAME | ANJUTA_TOKEN_ADDED, prop->base.value);
 274                         arg = anjuta_token_insert_before (token, anjuta_token_new_static (ANJUTA_TOKEN_ITEM | ANJUTA_TOKEN_ADDED, NULL));
 275                         anjuta_token_merge (arg, token);
 276
 277                         pos = info->position;
 278                         if (pos == -1) pos = 0;
 279                         anjuta_token_replace_nth_word (args, pos, arg);
 280                         anjuta_token_style_format (project->arg_list, args);
 281                 }
 282         }
 283
 284         amp_project_update_configure (project, token);
 285
 286         return TRUE;
 287 }
 288
 289 /* Module objects
 290  *---------------------------------------------------------------------------*/
 291
 292 static AnjutaToken *
 293 amp_project_write_module_list (AmpProject *project, const gchar *name, gboolean after, AnjutaToken* sibling)
 294 {
 295         AnjutaToken *pos;
 296         AnjutaToken *token;
 297         AnjutaToken *configure;
 298
 299         configure = amp_project_get_configure_token (project);
 300
 301         pos = anjuta_token_find_position (configure, after, AC_TOKEN_PKG_CHECK_MODULES, sibling);
 302
 303         pos = anjuta_token_insert_token_list (after, pos,
 304                     ANJUTA_TOKEN_EOL, "\n",
 305                     NULL);
 306
 307         pos = anjuta_token_insert_token_list (after, pos,
 308                     ANJUTA_TOKEN_EOL, "\n",
 309                     NULL);
 310         amp_project_update_configure (project, pos);
 311
 312         token = anjuta_token_insert_token_list (FALSE, pos,
 313                         AC_TOKEN_AC_CONFIG_FILES, "PKG_CHECK_MODULES(",
 314                         ANJUTA_TOKEN_LIST, NULL,
 315                         ANJUTA_TOKEN_NAME, name,
 316                         ANJUTA_TOKEN_COMMA, ",",
 317                         ANJUTA_TOKEN_LAST, NULL,
 318                         RIGHT_PAREN, ")",
 319                         NULL);
 320
 321         return token;
 322 }
 323
 324
 325 gboolean
 326 amp_module_node_create_token (AmpProject  *project, AmpModuleNode *module, GError **error)
 327 {
 328         gboolean after;
 329         AnjutaToken *token;
 330         AnjutaToken *prev;
 331         AnjutaToken *next;
 332         AnjutaProjectNode *sibling;
 333
 334         /* Add in configure.ac */
 335         /* Find a sibling if possible */
 336         prev = NULL;
 337         after = TRUE;
 338         for (sibling = anjuta_project_node_prev_sibling (ANJUTA_PROJECT_NODE (module)); sibling != NULL; sibling = anjuta_project_node_prev_sibling (sibling))
 339         {
 340                 if (anjuta_project_node_get_node_type (sibling) == ANJUTA_PROJECT_MODULE)
 341                 {
 342                         prev = amp_module_node_get_token (AMP_MODULE_NODE (sibling));
 343                         if (prev != NULL)
 344                         {
 345                                 prev = anjuta_token_list (prev);
 346                                 break;
 347                         }
 348                 }
 349         }
 350         if (prev == NULL)
 351         {
 352                 after = FALSE;
 353                 for (sibling = anjuta_project_node_next_sibling (ANJUTA_PROJECT_NODE (module)); sibling != NULL; sibling = anjuta_project_node_next_sibling (sibling))
 354                 {
 355                         if (anjuta_project_node_get_node_type (sibling) == ANJUTA_PROJECT_MODULE)
 356                         {
 357                                 prev = amp_module_node_get_token (AMP_MODULE_NODE (sibling));
 358                                 if (prev != NULL)
 359                                 {
 360                                         prev = anjuta_token_list (prev);
 361                                         break;
 362                                 }
 363                         }
 364                 }
 365         }
 366
 367         token = amp_project_write_module_list (project, anjuta_project_node_get_name (ANJUTA_PROJECT_NODE (module)), after, prev);
 368         next = anjuta_token_next (token);
 369         next = anjuta_token_next (next);
 370         next = anjuta_token_next (next);
 371         amp_module_node_add_token (module, next);
 372
 373         amp_project_update_configure (project, token);
 374
 375         return TRUE;
 376 }
 377
 378 gboolean
 379 amp_module_node_delete_token (AmpProject  *project, AmpModuleNode *module, GError **error)
 380 {
 381         AnjutaToken *token;
 382
 383         token = amp_module_node_get_token (module);
 384         if (token != NULL)
 385         {
 386                 AnjutaToken *eol;
 387
 388                 token = anjuta_token_list (token);
 389                 anjuta_token_set_flags (token, ANJUTA_TOKEN_REMOVED);
 390                 eol = anjuta_token_next_item (token);
 391                 if (anjuta_token_get_type (eol) == ANJUTA_TOKEN_EOL)
 392                 {
 393                         anjuta_token_set_flags (eol, ANJUTA_TOKEN_REMOVED);
 394                 }
 395                 eol = anjuta_token_next_item (eol);
 396                 if (anjuta_token_get_type (eol) == ANJUTA_TOKEN_EOL)
 397                 {
 398                         anjuta_token_set_flags (eol, ANJUTA_TOKEN_REMOVED);
 399                 }
 400
 401                 amp_project_update_configure (project, token);
 402         }
 403
 404         return TRUE;
 405 }
 406
 407 /* Package objects
 408  *---------------------------------------------------------------------------*/
 409
 410 gboolean
 411 amp_package_node_create_token (AmpProject  *project, AmpPackageNode *package, GError **error)
 412 {
 413         AmpModuleNode *module;
 414         AnjutaProjectNode *sibling;
 415         gboolean after;
 416         AnjutaToken *token;
 417         AnjutaToken *prev;
 418         AnjutaToken *args;
 419
 420
 421         /* Get parent module */
 422         module = AMP_MODULE_NODE (anjuta_project_node_parent_type (ANJUTA_PROJECT_NODE (package), ANJUTA_PROJECT_MODULE));
 423         if (module == NULL) return FALSE;
 424
 425
 426         /* Add in configure.ac */
 427         /* Find a sibling if possible */
 428         if ((sibling = anjuta_project_node_prev_sibling (ANJUTA_PROJECT_NODE (package))) != NULL)
 429         {
 430                 prev = amp_package_node_get_token (AMP_PACKAGE_NODE (sibling));
 431                 after = TRUE;
 432                 args = anjuta_token_list (prev);
 433         }
 434         else if ((sibling = anjuta_project_node_next_sibling (ANJUTA_PROJECT_NODE (package))) != NULL)
 435         {
 436                 prev = amp_package_node_get_token (AMP_PACKAGE_NODE (sibling));
 437                 after = FALSE;
 438                 args = anjuta_token_list (prev);
 439         }
 440         else
 441         {
 442                 prev = NULL;
 443                 args = NULL;
 444         }
 445
 446         /* Check if a valid source variable is already defined */
 447         if (args == NULL)
 448         {
 449                 args = amp_module_node_get_token (module);
 450         }
 451
 452         if (args != NULL)
 453         {
 454                 AnjutaTokenStyle *style;
 455                 const gchar *name;
 456
 457                 name = anjuta_project_node_get_name (ANJUTA_PROJECT_NODE (package));
 458                 style = anjuta_token_style_new_from_base (project->ac_space_list);
 459                 //anjuta_token_style_update (style, args);
 460
 461                 token = anjuta_token_new_string (ANJUTA_TOKEN_NAME | ANJUTA_TOKEN_ADDED, name);
 462
 463                 if (after)
 464                 {
 465                         anjuta_token_insert_word_after (args, prev, token);
 466                 }
 467                 else
 468                 {
 469                         anjuta_token_insert_word_before (args, prev, token);
 470                 }
 471
 472                 /* Try to use the same style than the current target list */
 473                 anjuta_token_style_format (style, args);
 474                 anjuta_token_style_free (style);
 475
 476                 amp_project_update_configure (project, token);
 477
 478                 amp_package_node_add_token (package, token);
 479         }
 480
 481         return TRUE;
 482 }
 483
 484 gboolean
 485 amp_package_node_delete_token (AmpProject  *project, AmpPackageNode *package, GError **error)
 486 {
 487         AnjutaProjectNode *module;
 488         AnjutaToken *token;
 489
 490         /* Get parent module */
 491         module = anjuta_project_node_parent_type (ANJUTA_PROJECT_NODE (package), ANJUTA_PROJECT_MODULE);
 492         if (module == NULL)
 493         {
 494                 return FALSE;
 495         }
 496
 497         token = amp_package_node_get_token (package);
 498         if (token != NULL)
 499         {
 500                 AnjutaToken *args;
 501                 AnjutaTokenStyle *style;
 502
 503                 args = anjuta_token_list (token);
 504
 505                 /* Try to use the same style than the current target list */
 506                 style = anjuta_token_style_new_from_base (project->ac_space_list);
 507                 anjuta_token_style_update (style, args);
 508
 509                 anjuta_token_remove_word (token);
 510
 511                 anjuta_token_style_format (style, args);
 512                 anjuta_token_style_free (style);
 513
 514                 amp_project_update_configure (project, args);
 515         }
 516
 517         return TRUE;
 518 }