tagmanager/tm_workspace.c

   1 /*
   2 *
   3 *   Copyright (c) 2001-2002, Biswapesh Chattopadhyay
   4 *
   5 *   This source code is released for free distribution under the terms of the
   6 *   GNU General Public License.
   7 *
   8 */
   9
  10 /*!
  11  * @file tm_workspace.h
  12  The TMWorkspace structure is meant to be used as a singleton to store application
  13  wide tag information.
  14
  15  The workspace is intended to contain a list of global tags
  16  and a set of work objects (projects or individual files). You need not use the
  17  workspace, though, to use tag manager, unless you need things like global tags
  18  and a place to store all current open projects and individual files. TMWorkspace
  19  is derived from TMWorkObject.
  20 */
  21
  22 #include "general.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <ctype.h>
  28 #include <sys/types.h>
  29 #include <string.h>
  30 #include <sys/stat.h>
  31 #ifdef HAVE_GLOB_H
  32 # include <glob.h>
  33 #endif
  34 #include <glib/gstdio.h>
  35
  36 #include "tm_tag.h"
  37 #include "tm_workspace.h"
  38 #include "tm_project.h"
  39
  40
  41 static TMWorkspace *theWorkspace = NULL;
  42 guint workspace_class_id = 0;
  43
  44 static gboolean tm_create_workspace(void)
  45 {
  46         workspace_class_id = tm_work_object_register(tm_workspace_free, tm_workspace_update
  47                   , tm_workspace_find_object);
  48         theWorkspace = g_new(TMWorkspace, 1);
  49         if (FALSE == tm_work_object_init(TM_WORK_OBJECT(theWorkspace),
  50                   workspace_class_id, NULL, TRUE))
  51         {
  52                 g_free(theWorkspace);
  53                 theWorkspace = NULL;
  54                 g_warning("Failed to initialize workspace");
  55                 return FALSE;
  56         }
  57
  58         theWorkspace->global_tags = NULL;
  59         theWorkspace->work_objects = NULL;
  60         return TRUE;
  61 }
  62
  63 void tm_workspace_free(gpointer workspace)
  64 {
  65         guint i;
  66
  67         if (workspace != theWorkspace)
  68                 return;
  69
  70 #ifdef TM_DEBUG
  71         g_message("Workspace destroyed");
  72 #endif
  73
  74         if (theWorkspace)
  75         {
  76                 if (theWorkspace->work_objects)
  77                 {
  78                         for (i=0; i < theWorkspace->work_objects->len; ++i)
  79                                 tm_work_object_free(theWorkspace->work_objects->pdata[i]);
  80                         g_ptr_array_free(theWorkspace->work_objects, TRUE);
  81                 }
  82                 if (theWorkspace->global_tags)
  83                 {
  84                         for (i=0; i < theWorkspace->global_tags->len; ++i)
  85                                 tm_tag_free(theWorkspace->global_tags->pdata[i]);
  86                         g_ptr_array_free(theWorkspace->global_tags, TRUE);
  87                 }
  88                 tm_work_object_destroy(TM_WORK_OBJECT(theWorkspace));
  89                 g_free(theWorkspace);
  90                 theWorkspace = NULL;
  91         }
  92 }
  93
  94 const TMWorkspace *tm_get_workspace()
  95 {
  96         if (NULL == theWorkspace)
  97                 tm_create_workspace();
  98         return theWorkspace;
  99 }
 100
 101 gboolean tm_workspace_add_object(TMWorkObject *work_object)
 102 {
 103         /* theWorkspace should already have been created otherwise something went wrong */
 104         if (NULL == theWorkspace)
 105                 return FALSE;
 106         if (NULL == theWorkspace->work_objects)
 107                 theWorkspace->work_objects = g_ptr_array_new();
 108         g_ptr_array_add(theWorkspace->work_objects, work_object);
 109         work_object->parent = TM_WORK_OBJECT(theWorkspace);
 110         return TRUE;
 111 }
 112
 113 gboolean tm_workspace_remove_object(TMWorkObject *w, gboolean do_free, gboolean update)
 114 {
 115         guint i;
 116         if ((NULL == theWorkspace) || (NULL == theWorkspace->work_objects)
 117                   || (NULL == w))
 118                 return FALSE;
 119
 120
 121         for (i=0; i < theWorkspace->work_objects->len; ++i)
 122         {
 123                 if (theWorkspace->work_objects->pdata[i] == w)
 124                 {
 125                         if (do_free)
 126                                 tm_work_object_free(w);
 127                         g_ptr_array_remove_index_fast(theWorkspace->work_objects, i);
 128                         if (update)
 129                                 tm_workspace_update(TM_WORK_OBJECT(theWorkspace), TRUE, FALSE, FALSE);
 130                         return TRUE;
 131                 }
 132         }
 133
 134         return FALSE;
 135 }
 136
 137 static TMTagAttrType global_tags_sort_attrs[] =
 138 {
 139         tm_tag_attr_name_t, tm_tag_attr_scope_t,
 140         tm_tag_attr_type_t, tm_tag_attr_arglist_t, 0
 141 };
 142
 143 gboolean tm_workspace_load_global_tags(const char *tags_file, gint mode)
 144 {
 145         guchar buf[BUFSIZ];
 146         FILE *fp;
 147         TMTag *tag;
 148         gboolean format_pipe = FALSE;
 149
 150         if (NULL == theWorkspace)
 151                 return FALSE;
 152         if (NULL == (fp = g_fopen(tags_file, "r")))
 153                 return FALSE;
 154         if (NULL == theWorkspace->global_tags)
 155                 theWorkspace->global_tags = g_ptr_array_new();
 156         if ((NULL == fgets((gchar*) buf, BUFSIZ, fp)) || ('\0' == *buf))
 157         {
 158                 fclose(fp);
 159                 return FALSE; /* early out on error */
 160         }
 161         else
 162         {       /* We read the first line for the format specification. */
 163                 if (buf[0] == '#' && strstr((gchar*) buf, "format=pipe") != NULL)
 164                         format_pipe = TRUE;
 165                 else if (buf[0] == '#' && strstr((gchar*) buf, "format=tagmanager") != NULL)
 166                         format_pipe = FALSE;
 167                 else
 168                 {       /* We didn't find a valid format specification, so we try to auto-detect the format
 169                          * by counting the pipe characters on the first line and asumme pipe format when
 170                          * we find more than one pipe on the line. */
 171                         guint i, pipe_cnt = 0;
 172                         for (i = 0; i < BUFSIZ && buf[i] != '\0' && pipe_cnt < 2; i++)
 173                         {
 174                                 if (buf[i] == '|')
 175                                         pipe_cnt++;
 176                         }
 177                         format_pipe = (pipe_cnt > 1);
 178                 }
 179                 rewind(fp); /* reset the file pointer, to start reading again from the beginning */
 180         }
 181         while (NULL != (tag = tm_tag_new_from_file(NULL, fp, mode, format_pipe)))
 182                 g_ptr_array_add(theWorkspace->global_tags, tag);
 183         fclose(fp);
 184
 185         /* resort the whole array, because tm_tags_find expects a sorted array and it is not sorted
 186          * when c99.tags, php.tags and latex.tags are loaded at the same time */
 187         tm_tags_sort(theWorkspace->global_tags, global_tags_sort_attrs, TRUE);
 188
 189         return TRUE;
 190 }
 191
 192 static guint tm_file_inode_hash(gconstpointer key)
 193 {
 194         struct stat file_stat;
 195         const char *filename = (const char*)key;
 196         if (g_stat(filename, &file_stat) == 0)
 197         {
 198 #ifdef TM_DEBUG
 199                 g_message ("Hash for '%s' is '%d'\n", filename, file_stat.st_ino);
 200 #endif
 201                 return g_direct_hash (GUINT_TO_POINTER (file_stat.st_ino));
 202         } else {
 203                 return 0;
 204         }
 205 }
 206
 207 static void tm_move_entries_to_g_list(gpointer key, gpointer value, gpointer user_data)
 208 {
 209         GList **pp_list = (GList**)user_data;
 210
 211         if (user_data == NULL)
 212                 return;
 213
 214         *pp_list = g_list_prepend(*pp_list, value);
 215 }
 216
 217 static void write_includes_file(FILE *fp, GList *includes_files)
 218 {
 219         GList *node;
 220
 221         node = includes_files;
 222         while (node)
 223         {
 224                 char *str = g_strdup_printf("#include \"%s\"\n", (char*)node->data);
 225                 int str_len = strlen(str);
 226                 size_t size;
 227
 228                 size = fwrite(str, str_len, 1, fp);
 229                 g_free(str);
 230                 node = g_list_next (node);
 231         }
 232 }
 233
 234
 235 static void append_to_temp_file(FILE *fp, GList *file_list)
 236 {
 237         GList *node;
 238
 239         node = file_list;
 240         while (node)
 241         {
 242                 const char *fname = node->data;
 243                 char *contents;
 244                 size_t length;
 245                 GError *err = NULL;
 246
 247                 if (! g_file_get_contents(fname, &contents, &length, &err))
 248                 {
 249                         fprintf(stderr, "Unable to read file: %s\n", err->message);
 250                         g_error_free(err);
 251                 }
 252                 else
 253                 {
 254                         size_t size;
 255                         size = fwrite(contents, length, 1, fp);
 256                         size = fwrite("\n", 1, 1, fp);  /* in case file doesn't end in newline (e.g. windows). */
 257                         g_free(contents);
 258                 }
 259                 node = g_list_next (node);
 260         }
 261 }
 262
 263 gboolean tm_workspace_create_global_tags(const char *config_dir, const char *pre_process,
 264         const char **includes, int includes_count, const char *tags_file, int lang)
 265 {
 266 #ifdef HAVE_GLOB_H
 267         glob_t globbuf;
 268         size_t idx_glob;
 269 #endif
 270         int idx_inc;
 271         char *command;
 272         guint i;
 273         FILE *fp;
 274         TMWorkObject *source_file;
 275         GPtrArray *tags_array;
 276         GHashTable *includes_files_hash;
 277         GList *includes_files = NULL;
 278 #ifdef G_OS_WIN32
 279         char *temp_file = g_strdup_printf("%s\\_%d_%ld_1.cpp", config_dir, getpid(), time(NULL));
 280         char *temp_file2 = g_strdup_printf("%s\\_%d_%ld_2.cpp", config_dir, getpid(), time(NULL));
 281 #else
 282         char *temp_file = g_strdup_printf("%s/%d_%ld_1.cpp", config_dir, getpid(), time(NULL));
 283         char *temp_file2 = g_strdup_printf("%s/%d_%ld_2.cpp", config_dir, getpid(), time(NULL));
 284 #endif
 285
 286         if (NULL == theWorkspace || NULL == (fp = g_fopen(temp_file, "w")))
 287         {
 288                 g_free(temp_file);
 289                 g_free(temp_file2);
 290                 return FALSE;
 291         }
 292
 293         includes_files_hash = g_hash_table_new_full (tm_file_inode_hash,
 294                                                                                                  g_direct_equal,
 295                                                                                                  NULL, g_free);
 296
 297 #ifdef HAVE_GLOB_H
 298         globbuf.gl_offs = 0;
 299
 300         if (includes[0][0] == '"')      /* leading \" char for glob matching */
 301         for(idx_inc = 0; idx_inc < includes_count; idx_inc++)
 302         {
 303                 int dirty_len = strlen(includes[idx_inc]);
 304                 char *clean_path = g_malloc(dirty_len - 1);
 305
 306                 strncpy(clean_path, includes[idx_inc] + 1, dirty_len - 1);
 307                 clean_path[dirty_len - 2] = 0;
 308
 309 #ifdef TM_DEBUG
 310                 g_message ("[o][%s]\n", clean_path);
 311 #endif
 312                 glob(clean_path, 0, NULL, &globbuf);
 313
 314 #ifdef TM_DEBUG
 315                 g_message ("matches: %d\n", globbuf.gl_pathc);
 316 #endif
 317
 318                 for(idx_glob = 0; idx_glob < globbuf.gl_pathc; idx_glob++)
 319                 {
 320 #ifdef TM_DEBUG
 321                         g_message (">>> %s\n", globbuf.gl_pathv[idx_glob]);
 322 #endif
 323                         if (!g_hash_table_lookup(includes_files_hash,
 324                                                                         globbuf.gl_pathv[idx_glob]))
 325                         {
 326                                 char* file_name_copy = strdup(globbuf.gl_pathv[idx_glob]);
 327                                 g_hash_table_insert(includes_files_hash, file_name_copy,
 328                                                                         file_name_copy);
 329 #ifdef TM_DEBUG
 330                                 g_message ("Added ...\n");
 331 #endif
 332                         }
 333                 }
 334                 globfree(&globbuf);
 335                 g_free(clean_path);
 336         }
 337         else
 338 #endif
 339         /* no glob support or globbing not wanted */
 340         for(idx_inc = 0; idx_inc < includes_count; idx_inc++)
 341         {
 342                 if (!g_hash_table_lookup(includes_files_hash,
 343                                                                         includes[idx_inc]))
 344                 {
 345                         char* file_name_copy = strdup(includes[idx_inc]);
 346                         g_hash_table_insert(includes_files_hash, file_name_copy,
 347                                                                 file_name_copy);
 348                 }
 349         }
 350
 351         /* Checks for duplicate file entries which would case trouble */
 352         g_hash_table_foreach(includes_files_hash, tm_move_entries_to_g_list,
 353                                                  &includes_files);
 354
 355         includes_files = g_list_reverse (includes_files);
 356
 357 #ifdef TM_DEBUG
 358         g_message ("writing out files to %s\n", temp_file);
 359 #endif
 360         if (pre_process != NULL)
 361                 write_includes_file(fp, includes_files);
 362         else
 363                 append_to_temp_file(fp, includes_files);
 364
 365         g_list_free (includes_files);
 366         g_hash_table_destroy(includes_files_hash);
 367         includes_files_hash = NULL;
 368         includes_files = NULL;
 369         fclose(fp);
 370
 371         /* FIXME: The following grep command removes the lines
 372          * G_BEGIN_DECLS and G_END_DECLS from the header files. The reason is
 373          * that in tagmanager, the files are not correctly parsed and the typedefs
 374          * following these lines are incorrectly parsed. The real fix should,
 375          * of course be in tagmanager (c) parser. This is just a temporary fix.
 376          */
 377         if (pre_process != NULL)
 378         {
 379                 int ret;
 380                 command = g_strdup_printf("%s %s | grep -v -E '^\\s*(G_BEGIN_DECLS|G_END_DECLS)\\s*$' > %s",
 381                                                           pre_process, temp_file, temp_file2);
 382 #ifdef TM_DEBUG
 383                 g_message("Executing: %s", command);
 384 #endif
 385                 ret = system(command);
 386                 g_free(command);
 387                 g_unlink(temp_file);
 388                 g_free(temp_file);
 389         }
 390         else
 391         {
 392                 /* no pre-processing needed, so temp_file2 = temp_file */
 393                 g_free(temp_file2);
 394                 temp_file2 = temp_file;
 395                 temp_file = NULL;
 396         }
 397         source_file = tm_source_file_new(temp_file2, TRUE, tm_source_file_get_lang_name(lang));
 398         if (NULL == source_file)
 399         {
 400                 g_unlink(temp_file2);
 401                 return FALSE;
 402         }
 403         g_unlink(temp_file2);
 404         g_free(temp_file2);
 405         if ((NULL == source_file->tags_array) || (0 == source_file->tags_array->len))
 406         {
 407                 tm_source_file_free(source_file);
 408                 return FALSE;
 409         }
 410         tags_array = tm_tags_extract(source_file->tags_array, tm_tag_max_t);
 411         if ((NULL == tags_array) || (0 == tags_array->len))
 412         {
 413                 if (tags_array)
 414                         g_ptr_array_free(tags_array, TRUE);
 415                 tm_source_file_free(source_file);
 416                 return FALSE;
 417         }
 418         if (FALSE == tm_tags_sort(tags_array, global_tags_sort_attrs, TRUE))
 419         {
 420                 tm_source_file_free(source_file);
 421                 return FALSE;
 422         }
 423         if (NULL == (fp = g_fopen(tags_file, "w")))
 424         {
 425                 tm_source_file_free(source_file);
 426                 return FALSE;
 427         }
 428         fprintf(fp, "# format=tagmanager\n");
 429         for (i = 0; i < tags_array->len; ++i)
 430         {
 431                 tm_tag_write(TM_TAG(tags_array->pdata[i]), fp, tm_tag_attr_type_t
 432                   | tm_tag_attr_scope_t | tm_tag_attr_arglist_t | tm_tag_attr_vartype_t
 433                   | tm_tag_attr_pointer_t);
 434         }
 435         fclose(fp);
 436         tm_source_file_free(source_file);
 437         g_ptr_array_free(tags_array, TRUE);
 438         return TRUE;
 439 }
 440
 441 TMWorkObject *tm_workspace_find_object(TMWorkObject *work_object, const char *file_name
 442   , gboolean name_only)
 443 {
 444         TMWorkObject *w = NULL;
 445         guint i;
 446
 447         if (work_object != TM_WORK_OBJECT(theWorkspace))
 448                 return NULL;
 449         if ((NULL == theWorkspace) || (NULL == theWorkspace->work_objects)
 450                 || (0 == theWorkspace->work_objects->len))
 451                 return NULL;
 452         for (i = 0; i < theWorkspace->work_objects->len; ++i)
 453         {
 454                 if (NULL != (w = tm_work_object_find(TM_WORK_OBJECT(theWorkspace->work_objects->pdata[i])
 455                           , file_name, name_only)))
 456                         return w;
 457         }
 458         return NULL;
 459 }
 460
 461 void tm_workspace_recreate_tags_array(void)
 462 {
 463         guint i, j;
 464         TMWorkObject *w;
 465         TMTagAttrType sort_attrs[] = { tm_tag_attr_name_t, tm_tag_attr_file_t
 466                 , tm_tag_attr_scope_t, tm_tag_attr_type_t, tm_tag_attr_arglist_t, 0};
 467
 468 #ifdef TM_DEBUG
 469         g_message("Recreating workspace tags array");
 470 #endif
 471
 472         if ((NULL == theWorkspace) || (NULL == theWorkspace->work_objects))
 473                 return;
 474         if (NULL != theWorkspace->work_object.tags_array)
 475                 g_ptr_array_set_size(theWorkspace->work_object.tags_array, 0);
 476         else
 477                 theWorkspace->work_object.tags_array = g_ptr_array_new();
 478
 479 #ifdef TM_DEBUG
 480         g_message("Total %d objects", theWorkspace->work_objects->len);
 481 #endif
 482         for (i=0; i < theWorkspace->work_objects->len; ++i)
 483         {
 484                 w = TM_WORK_OBJECT(theWorkspace->work_objects->pdata[i]);
 485 #ifdef TM_DEBUG
 486                 g_message("Adding tags of %s", w->file_name);
 487 #endif
 488                 if ((NULL != w) && (NULL != w->tags_array) && (w->tags_array->len > 0))
 489                 {
 490                         for (j = 0; j < w->tags_array->len; ++j)
 491                         {
 492                                 g_ptr_array_add(theWorkspace->work_object.tags_array,
 493                                           w->tags_array->pdata[j]);
 494                         }
 495                 }
 496         }
 497 #ifdef TM_DEBUG
 498         g_message("Total: %d tags", theWorkspace->work_object.tags_array->len);
 499 #endif
 500         tm_tags_sort(theWorkspace->work_object.tags_array, sort_attrs, TRUE);
 501 }
 502
 503 gboolean tm_workspace_update(TMWorkObject *workspace, gboolean force
 504   , gboolean recurse, gboolean __unused__ update_parent)
 505 {
 506         guint i;
 507         gboolean update_tags = force;
 508
 509 #ifdef TM_DEBUG
 510         g_message("Updating workspace");
 511 #endif
 512
 513         if (workspace != TM_WORK_OBJECT(theWorkspace))
 514                 return FALSE;
 515         if (NULL == theWorkspace)
 516                 return TRUE;
 517         if ((recurse) && (theWorkspace->work_objects))
 518         {
 519                 for (i=0; i < theWorkspace->work_objects->len; ++i)
 520                 {
 521                         if (TRUE == tm_work_object_update(TM_WORK_OBJECT(
 522                                   theWorkspace->work_objects->pdata[i]), FALSE, TRUE, FALSE))
 523                                 update_tags = TRUE;
 524                 }
 525         }
 526         if (update_tags)
 527                 tm_workspace_recreate_tags_array();
 528         /* workspace->analyze_time = time(NULL); */
 529         return update_tags;
 530 }
 531
 532 void tm_workspace_dump(void)
 533 {
 534         if (theWorkspace)
 535         {
 536 #ifdef TM_DEBUG
 537                 g_message("Dumping TagManager workspace tree..");
 538 #endif
 539                 tm_work_object_dump(TM_WORK_OBJECT(theWorkspace));
 540                 if (theWorkspace->work_objects)
 541                 {
 542                         guint i;
 543                         for (i=0; i < theWorkspace->work_objects->len; ++i)
 544                         {
 545                                 if (IS_TM_PROJECT(TM_WORK_OBJECT(theWorkspace->work_objects->pdata[i])))
 546                                         tm_project_dump(TM_PROJECT(theWorkspace->work_objects->pdata[i]));
 547                                 else
 548                                         tm_work_object_dump(TM_WORK_OBJECT(theWorkspace->work_objects->pdata[i]));
 549                         }
 550                 }
 551         }
 552 }
 553
 554 const GPtrArray *tm_workspace_find(const char *name, int type, TMTagAttrType *attrs
 555  , gboolean partial, langType lang)
 556 {
 557         static GPtrArray *tags = NULL;
 558         TMTag **matches[2];
 559         int len, tagCount[2]={0,0}, tagIter;
 560         gint tags_lang;
 561
 562         if ((!theWorkspace) || (!name))
 563                 return NULL;
 564         len = strlen(name);
 565         if (!len)
 566                 return NULL;
 567         if (tags)
 568                 g_ptr_array_set_size(tags, 0);
 569         else
 570                 tags = g_ptr_array_new();
 571
 572         matches[0] = tm_tags_find(theWorkspace->work_object.tags_array, name, partial, &tagCount[0]);
 573         matches[1] = tm_tags_find(theWorkspace->global_tags, name, partial, &tagCount[1]);
 574
 575         /* file tags */
 576         if (matches[0] && *matches[0])
 577         {
 578                 /* tag->atts.file.lang contains the line of the tag and
 579                  * tags->atts.entry.file->lang contains the language */
 580                 tags_lang = (*matches[0])->atts.entry.file->lang;
 581
 582                 for (tagIter=0;tagIter<tagCount[0];++tagIter)
 583                 {
 584                         if ((type & (*matches[0])->type) && (lang == -1 || tags_lang == lang))
 585                                 g_ptr_array_add(tags, *matches[0]);
 586                         if (partial)
 587                         {
 588                                 if (0 != strncmp((*matches[0])->name, name, len))
 589                                         break;
 590                         }
 591                         else
 592                         {
 593                                 if (0 != strcmp((*matches[0])->name, name))
 594                                         break;
 595                         }
 596                         ++ matches[0];
 597                 }
 598         }
 599
 600         /* global tags */
 601         if (matches[1] && *matches[1])
 602         {
 603                 int tags_lang_alt = 0;
 604                 /* tag->atts.file.lang contains the language and
 605                  * tags->atts.entry.file is NULL */
 606                 tags_lang = (*matches[1])->atts.file.lang;
 607                 /* tags_lang_alt is used to load C global tags only once for C and C++
 608                  * lang = 1 is C++, lang = 0 is C
 609                  * if we have lang 0, than accept also lang 1 for C++ */
 610                 if (tags_lang == 0)     /* C or C++ */
 611                         tags_lang_alt = 1;
 612                 else
 613                         tags_lang_alt = tags_lang; /* otherwise just ignore it */
 614
 615                 for (tagIter=0;tagIter<tagCount[1];++tagIter)
 616                 {
 617                         if ((type & (*matches[1])->type) && (lang == -1 ||
 618                                 tags_lang == lang || tags_lang_alt == lang))
 619                                 g_ptr_array_add(tags, *matches[1]);
 620
 621                         if (partial)
 622                         {
 623                                 if (0 != strncmp((*matches[1])->name, name, len))
 624                                         break;
 625                         }
 626                         else
 627                         {
 628                                 if (0 != strcmp((*matches[1])->name, name))
 629                                         break;
 630                         }
 631                         ++ matches[1];
 632                 }
 633         }
 634
 635         if (attrs)
 636                 tm_tags_sort(tags, attrs, TRUE);
 637         return tags;
 638 }
 639
 640 static gboolean match_langs(gint lang, const TMTag *tag)
 641 {
 642         if (tag->atts.entry.file)
 643         {       /* workspace tag */
 644                 if (lang == tag->atts.entry.file->lang)
 645                         return TRUE;
 646         }
 647         else
 648         {       /* global tag */
 649                 if (lang == tag->atts.file.lang)
 650                         return TRUE;
 651         }
 652         return FALSE;
 653 }
 654
 655 /* scope can be NULL.
 656  * lang can be -1 */
 657 static int
 658 fill_find_tags_array (GPtrArray *dst, const GPtrArray *src,
 659                                           const char *name, const char *scope, int type, gboolean partial,
 660                                           gint lang, gboolean first)
 661 {
 662         TMTag **match;
 663         int tagIter, count;
 664
 665         if ((!src) || (!dst) || (!name) || (!*name))
 666                 return 0;
 667
 668         match = tm_tags_find (src, name, partial, &count);
 669         if (count && match && *match)
 670         {
 671                 for (tagIter = 0; tagIter < count; ++tagIter)
 672                 {
 673                         if (! scope || (match[tagIter]->atts.entry.scope &&
 674                                 0 == strcmp(match[tagIter]->atts.entry.scope, scope)))
 675                         {
 676                                 if (type & match[tagIter]->type)
 677                                 if (lang == -1 || match_langs(lang, match[tagIter]))
 678                                 {
 679                                         g_ptr_array_add (dst, match[tagIter]);
 680                                         if (first)
 681                                                 break;
 682                                 }
 683                         }
 684                 }
 685         }
 686         return dst->len;
 687 }
 688
 689
 690 /* adapted from tm_workspace_find, Anjuta 2.02 */
 691 const GPtrArray *
 692 tm_workspace_find_scoped (const char *name, const char *scope, gint type,
 693                 TMTagAttrType *attrs, gboolean partial, langType lang, gboolean global_search)
 694 {
 695         static GPtrArray *tags = NULL;
 696
 697         if ((!theWorkspace))
 698                 return NULL;
 699
 700         if (tags)
 701                 g_ptr_array_set_size (tags, 0);
 702         else
 703                 tags = g_ptr_array_new ();
 704
 705         fill_find_tags_array (tags, theWorkspace->work_object.tags_array,
 706                                                   name, scope, type, partial, lang, FALSE);
 707         if (global_search)
 708         {
 709                 /* for a scoped tag, I think we always want the same language */
 710                 fill_find_tags_array (tags, theWorkspace->global_tags,
 711                                                           name, scope, type, partial, lang, FALSE);
 712         }
 713         if (attrs)
 714                 tm_tags_sort (tags, attrs, TRUE);
 715         return tags;
 716 }
 717
 718
 719 const TMTag *
 720 tm_get_current_function (GPtrArray * file_tags, const gulong line)
 721 {
 722         GPtrArray *const local = tm_tags_extract (file_tags, tm_tag_function_t);
 723         if (local && local->len)
 724         {
 725                 guint i;
 726                 TMTag *tag, *function_tag = NULL;
 727                 gulong function_line = 0;
 728                 glong delta;
 729
 730                 for (i = 0; (i < local->len); ++i)
 731                 {
 732                         tag = TM_TAG (local->pdata[i]);
 733                         delta = line - tag->atts.entry.line;
 734                         if (delta >= 0 && (gulong)delta < line - function_line)
 735                         {
 736                                 function_tag = tag;
 737                                 function_line = tag->atts.entry.line;
 738                         }
 739                 }
 740                 g_ptr_array_free (local, TRUE);
 741                 return function_tag;
 742         }
 743         return NULL;
 744 }
 745
 746
 747 static int
 748 find_scope_members_tags (const GPtrArray * all, GPtrArray * tags,
 749                                                  const langType langJava, const char *name,
 750                                                  const char *filename, gboolean no_definitions)
 751 {
 752         GPtrArray *local = g_ptr_array_new ();
 753         unsigned int i;
 754         TMTag *tag;
 755         size_t len = strlen (name);
 756         for (i = 0; (i < all->len); ++i)
 757         {
 758                 tag = TM_TAG (all->pdata[i]);
 759                 if (no_definitions && filename && tag->atts.entry.file &&
 760                         0 != strcmp (filename,
 761                                                  tag->atts.entry.file->work_object.short_name))
 762                 {
 763                         continue;
 764                 }
 765                 if (tag && tag->atts.entry.scope && tag->atts.entry.scope[0] != '\0')
 766                 {
 767                         if (0 == strncmp (name, tag->atts.entry.scope, len))
 768                         {
 769                                 g_ptr_array_add (local, tag);
 770                         }
 771                 }
 772         }
 773         if (local->len > 0)
 774         {
 775                 unsigned int j;
 776                 TMTag *tag2;
 777                 char backup = 0;
 778                 char *s_backup = NULL;
 779                 char *var_type = NULL;
 780                 char *scope;
 781                 for (i = 0; (i < local->len); ++i)
 782                 {
 783                         tag = TM_TAG (local->pdata[i]);
 784                         scope = tag->atts.entry.scope;
 785                         if (scope && 0 == strcmp (name, scope))
 786                         {
 787                                 g_ptr_array_add (tags, tag);
 788                                 continue;
 789                         }
 790                         s_backup = NULL;
 791                         j = 0;                          /* someone could write better code :P */
 792                         while (scope)
 793                         {
 794                                 if (s_backup)
 795                                 {
 796                                         backup = s_backup[0];
 797                                         s_backup[0] = '\0';
 798                                         if (0 == strcmp (name, tag->atts.entry.scope))
 799                                         {
 800                                                 j = local->len;
 801                                                 s_backup[0] = backup;
 802                                                 break;
 803                                         }
 804                                 }
 805                                 if (tag->atts.entry.file
 806                                         && tag->atts.entry.file->lang == langJava)
 807                                 {
 808                                         scope = strrchr (tag->atts.entry.scope, '.');
 809                                         if (scope)
 810                                                 var_type = scope + 1;
 811                                 }
 812                                 else
 813                                 {
 814                                         scope = strrchr (tag->atts.entry.scope, ':');
 815                                         if (scope)
 816                                         {
 817                                                 var_type = scope + 1;
 818                                                 scope--;
 819                                         }
 820                                 }
 821                                 if (s_backup)
 822                                 {
 823                                         s_backup[0] = backup;
 824                                 }
 825                                 if (scope)
 826                                 {
 827                                         if (s_backup)
 828                                         {
 829                                                 backup = s_backup[0];
 830                                                 s_backup[0] = '\0';
 831                                         }
 832                                         for (j = 0; (j < local->len); ++j)
 833                                         {
 834                                                 if (i == j)
 835                                                         continue;
 836                                                 tag2 = TM_TAG (local->pdata[j]);
 837                                                 if (tag2->atts.entry.var_type &&
 838                                                         0 == strcmp (var_type, tag2->atts.entry.var_type))
 839                                                 {
 840                                                         break;
 841                                                 }
 842                                         }
 843                                         if (s_backup)
 844                                                 s_backup[0] = backup;
 845                                 }
 846                                 if (j < local->len)
 847                                 {
 848                                         break;
 849                                 }
 850                                 s_backup = scope;
 851                         }
 852                         if (j == local->len)
 853                         {
 854                                 g_ptr_array_add (tags, tag);
 855                         }
 856                 }
 857         }
 858         g_ptr_array_free (local, TRUE);
 859         return (int) tags->len;
 860 }
 861
 862
 863 #if 0
 864 static int
 865 find_namespace_members_tags (const GPtrArray * all, GPtrArray * tags,
 866                                                         const langType langJava, const char *name,
 867                                                         const char *filename)
 868 {
 869         GPtrArray *local = g_ptr_array_new ();
 870         unsigned int i;
 871         TMTag *tag;
 872         size_t len = strlen (name);
 873
 874         g_return_val_if_fail (all != NULL, 0);
 875
 876         for (i = 0; (i < all->len); ++i)
 877         {
 878                 tag = TM_TAG (all->pdata[i]);
 879                 if (filename && tag->atts.entry.file &&
 880                         0 != strcmp (filename,
 881                                                  tag->atts.entry.file->work_object.short_name))
 882                 {
 883                         continue;
 884                 }
 885
 886                 if (tag && tag->atts.entry.scope && tag->atts.entry.scope[0] != '\0')
 887                 {
 888                         if (0 == strncmp (name, tag->atts.entry.scope, len))
 889                         {
 890                                 g_ptr_array_add (local, tag);
 891                         }
 892                 }
 893         }
 894
 895         if (local->len > 0)
 896         {
 897                 char *scope;
 898                 for (i = 0; (i < local->len); ++i)
 899                 {
 900                         tag = TM_TAG (local->pdata[i]);
 901                         scope = tag->atts.entry.scope;
 902
 903                         /* if we wanna complete something like
 904                          * namespace1::
 905                          * we'll just return the tags that have "namespace1"
 906                          * as their scope. So we won't return classes/members/namespaces
 907                          * under, for example, namespace2, where namespace1::namespace2
 908                          */
 909                         if (scope && 0 == strcmp (name, scope))
 910                         {
 911                                 g_ptr_array_add (tags, tag);
 912                         }
 913                 }
 914         }
 915
 916         g_ptr_array_free (local, TRUE);
 917         return (int) tags->len;
 918 }
 919
 920 const GPtrArray *
 921 tm_workspace_find_namespace_members (const GPtrArray * file_tags, const char *name,
 922                                                                  gboolean search_global)
 923 {
 924         static GPtrArray *tags = NULL;
 925         GPtrArray *local = NULL;
 926         char *new_name = (char *) name;
 927         char *filename = NULL;
 928         int found = 0, del = 0;
 929         static langType langJava = -1;
 930         TMTag *tag = NULL;
 931
 932         g_return_val_if_fail ((theWorkspace && name && name[0] != '\0'), NULL);
 933
 934         if (!tags)
 935                 tags = g_ptr_array_new ();
 936
 937         while (1)
 938         {
 939                 const GPtrArray *tags2;
 940                 int got = 0, types = (tm_tag_class_t | tm_tag_namespace_t |
 941                                                                 tm_tag_struct_t | tm_tag_typedef_t |
 942                                                                 tm_tag_union_t | tm_tag_enum_t);
 943
 944                 if (file_tags)
 945                 {
 946                         g_ptr_array_set_size (tags, 0);
 947                         got = fill_find_tags_array (tags, file_tags,
 948                                                                                   new_name, NULL, types, FALSE, -1, FALSE);
 949                 }
 950
 951
 952                 if (got)
 953                 {
 954                         tags2 = tags;
 955                 }
 956                 else
 957                 {
 958                         TMTagAttrType attrs[] = {
 959                                 tm_tag_attr_name_t, tm_tag_attr_type_t,
 960                                 tm_tag_attr_none_t
 961                         };
 962                         tags2 = tm_workspace_find (new_name, types, attrs, FALSE, -1);
 963                 }
 964
 965                 if ((tags2) && (tags2->len == 1) && (tag = TM_TAG (tags2->pdata[0])))
 966                 {
 967                         if (tag->type == tm_tag_typedef_t && tag->atts.entry.var_type
 968                                 && tag->atts.entry.var_type[0] != '\0')
 969                         {
 970                                 new_name = tag->atts.entry.var_type;
 971                                 continue;
 972                         }
 973                         filename = (tag->atts.entry.file ?
 974                                                 tag->atts.entry.file->work_object.short_name : NULL);
 975                         if (tag->atts.entry.scope && tag->atts.entry.scope[0] != '\0')
 976                         {
 977                                 del = 1;
 978                                 if (tag->atts.entry.file &&
 979                                         tag->atts.entry.file->lang == langJava)
 980                                 {
 981                                         new_name = g_strdup_printf ("%s.%s",
 982                                                                                                 tag->atts.entry.scope,
 983                                                                                                 new_name);
 984                                 }
 985                                 else
 986                                 {
 987                                         new_name = g_strdup_printf ("%s::%s",
 988                                                                                                 tag->atts.entry.scope,
 989                                                                                                 new_name);
 990                                 }
 991                         }
 992                         break;
 993                 }
 994                 else
 995                 {
 996                         return NULL;
 997                 }
 998         }
 999
1000         g_ptr_array_set_size (tags, 0);
1001
1002         if (tag && tag->atts.entry.file)
1003         {
1004                 local = tm_tags_extract (tag->atts.entry.file->work_object.tags_array,
1005                                                                  (tm_tag_function_t |
1006                                                                   tm_tag_field_t | tm_tag_enumerator_t |
1007                                                                   tm_tag_namespace_t | tm_tag_class_t ));
1008         }
1009         else
1010         {
1011                 local = tm_tags_extract (theWorkspace->work_object.tags_array,
1012                                                                  (tm_tag_function_t | tm_tag_prototype_t |
1013                                                                   tm_tag_member_t |
1014                                                                   tm_tag_field_t | tm_tag_enumerator_t |
1015                                                                   tm_tag_namespace_t | tm_tag_class_t ));
1016         }
1017
1018         if (local)
1019         {
1020                 found = find_namespace_members_tags (local, tags,
1021                                                                                  langJava, new_name, filename);
1022                 g_ptr_array_free (local, TRUE);
1023         }
1024
1025
1026         if (!found && search_global)
1027         {
1028                 GPtrArray *global = tm_tags_extract (theWorkspace->global_tags,
1029                                                                                          (tm_tag_member_t |
1030                                                                                           tm_tag_prototype_t |
1031                                                                                           tm_tag_field_t |
1032                                                                                           tm_tag_method_t |
1033                                                                                           tm_tag_function_t |
1034                                                                                           tm_tag_enumerator_t |
1035                                                                                           tm_tag_namespace_t |
1036                                                                                           tm_tag_class_t ));
1037
1038                 if (global)
1039                 {
1040                         find_namespace_members_tags (global, tags, langJava,
1041                                                                          new_name, filename);
1042 /*/
1043                         DEBUG_PRINT ("returning these");
1044                     gint i;
1045                         for (i=0; i < tags->len; i++) {
1046                                 TMTag *cur_tag;
1047
1048                                 cur_tag = (TMTag*)g_ptr_array_index (tags, i);
1049                                 tm_tag_print (cur_tag, stdout );
1050                         }
1051 /*/
1052                         g_ptr_array_free (global, TRUE);
1053                 }
1054         }
1055
1056
1057         if (del)
1058         {
1059                 g_free (new_name);
1060         }
1061
1062         return tags;
1063 }
1064 #endif
1065
1066 const GPtrArray *
1067 tm_workspace_find_scope_members (const GPtrArray * file_tags, const char *name,
1068                                                                  gboolean search_global, gboolean no_definitions)
1069 {
1070         static GPtrArray *tags = NULL;
1071         GPtrArray *local = NULL;
1072         char *new_name = (char *) name;
1073         char *filename = NULL;
1074         int found = 0, del = 0;
1075         static langType langJava = -1;
1076         TMTag *tag = NULL;
1077
1078         /* FIXME */
1079         /* langJava = getNamedLanguage ("Java"); */
1080
1081         g_return_val_if_fail ((theWorkspace && name && name[0] != '\0'), NULL);
1082
1083         if (!tags)
1084                 tags = g_ptr_array_new ();
1085
1086         while (1)
1087         {
1088                 const GPtrArray *tags2;
1089                 int got = 0, types = (tm_tag_class_t | tm_tag_namespace_t |
1090                                                                 tm_tag_struct_t | tm_tag_typedef_t |
1091                                                                 tm_tag_union_t | tm_tag_enum_t);
1092
1093                 if (file_tags)
1094                 {
1095                         g_ptr_array_set_size (tags, 0);
1096                         got = fill_find_tags_array (tags, file_tags,
1097                                                                                   new_name, NULL, types, FALSE, -1, FALSE);
1098                 }
1099                 if (got)
1100                 {
1101                         tags2 = tags;
1102                 }
1103                 else
1104                 {
1105                         TMTagAttrType attrs[] = {
1106                                 tm_tag_attr_name_t, tm_tag_attr_type_t,
1107                                 tm_tag_attr_none_t
1108                         };
1109                         tags2 = tm_workspace_find (new_name, types, attrs, FALSE, -1);
1110                 }
1111
1112                 if ((tags2) && (tags2->len == 1) && (tag = TM_TAG (tags2->pdata[0])))
1113                 {
1114                         if (tag->type == tm_tag_typedef_t && tag->atts.entry.var_type
1115                                 && tag->atts.entry.var_type[0] != '\0')
1116                         {
1117                                 char *tmp_name;
1118                                 tmp_name = tag->atts.entry.var_type;
1119                                 if (strcmp(tmp_name, new_name) == 0) {
1120                                         new_name = NULL;
1121                                 }
1122                                 else {
1123                                         new_name = tmp_name;
1124                                 }
1125                                 continue;
1126                         }
1127                         filename = (tag->atts.entry.file ?
1128                                                 tag->atts.entry.file->work_object.short_name : NULL);
1129                         if (tag->atts.entry.scope && tag->atts.entry.scope[0] != '\0')
1130                         {
1131                                 del = 1;
1132                                 if (tag->atts.entry.file &&
1133                                         tag->atts.entry.file->lang == langJava)
1134                                 {
1135                                         new_name = g_strdup_printf ("%s.%s",
1136                                                                                                 tag->atts.entry.scope,
1137                                                                                                 new_name);
1138                                 }
1139                                 else
1140                                 {
1141                                         new_name = g_strdup_printf ("%s::%s",
1142                                                                                                 tag->atts.entry.scope,
1143                                                                                                 new_name);
1144                                 }
1145                         }
1146                         break;
1147                 }
1148                 else
1149                 {
1150                         return NULL;
1151                 }
1152         }
1153
1154         g_ptr_array_set_size (tags, 0);
1155
1156         if (no_definitions && tag && tag->atts.entry.file)
1157         {
1158                 local = tm_tags_extract (tag->atts.entry.file->work_object.tags_array,
1159                                                                  (tm_tag_function_t | tm_tag_prototype_t |
1160                                                                   tm_tag_member_t | tm_tag_field_t |
1161                                                                   tm_tag_method_t | tm_tag_enumerator_t));
1162         }
1163         else
1164         {
1165                 local = tm_tags_extract (theWorkspace->work_object.tags_array,
1166                                                                  (tm_tag_function_t | tm_tag_prototype_t |
1167                                                                   tm_tag_member_t | tm_tag_field_t |
1168                                                                   tm_tag_method_t | tm_tag_enumerator_t));
1169         }
1170         if (local)
1171         {
1172                 found = find_scope_members_tags (local, tags, langJava, new_name,
1173                                                                                  filename, no_definitions);
1174                 g_ptr_array_free (local, TRUE);
1175         }
1176         if (!found && search_global)
1177         {
1178                 GPtrArray *global = tm_tags_extract (theWorkspace->global_tags,
1179                                                                                          (tm_tag_member_t |
1180                                                                                           tm_tag_prototype_t |
1181                                                                                           tm_tag_field_t |
1182                                                                                           tm_tag_method_t |
1183                                                                                           tm_tag_function_t |
1184                                                                                           tm_tag_enumerator_t
1185                                                                                           |tm_tag_struct_t | tm_tag_typedef_t |
1186                                                                                           tm_tag_union_t | tm_tag_enum_t));
1187                 if (global)
1188                 {
1189                         find_scope_members_tags (global, tags, langJava, new_name,
1190                                                                          filename, no_definitions);
1191                         g_ptr_array_free (global, TRUE);
1192                 }
1193         }
1194         if (del)
1195         {
1196                 g_free (new_name);
1197         }
1198
1199         return tags;
1200 }
1201
1202 const GPtrArray *tm_workspace_get_parents(const gchar *name)
1203 {
1204         static TMTagAttrType type[] = { tm_tag_attr_name_t, tm_tag_attr_none_t };
1205         static GPtrArray *parents = NULL;
1206         const GPtrArray *matches;
1207         guint i = 0;
1208         guint j;
1209         gchar **klasses;
1210         gchar **klass;
1211         TMTag *tag;
1212
1213         g_return_val_if_fail(name && isalpha(*name),NULL);
1214
1215         if (NULL == parents)
1216                 parents = g_ptr_array_new();
1217         else
1218                 g_ptr_array_set_size(parents, 0);
1219         matches = tm_workspace_find(name, tm_tag_class_t, type, FALSE, -1);
1220         if ((NULL == matches) || (0 == matches->len))
1221                 return NULL;
1222         g_ptr_array_add(parents, matches->pdata[0]);
1223         while (i < parents->len)
1224         {
1225                 tag = TM_TAG(parents->pdata[i]);
1226                 if ((NULL != tag->atts.entry.inheritance) && (isalpha(tag->atts.entry.inheritance[0])))
1227                 {
1228                         klasses = g_strsplit(tag->atts.entry.inheritance, ",", 10);
1229                         for (klass = klasses; (NULL != *klass); ++ klass)
1230                         {
1231                                 for (j=0; j < parents->len; ++j)
1232                                 {
1233                                         if (0 == strcmp(*klass, TM_TAG(parents->pdata[j])->name))
1234                                                 break;
1235                                 }
1236                                 if (parents->len == j)
1237                                 {
1238                                         matches = tm_workspace_find(*klass, tm_tag_class_t, type, FALSE, -1);
1239                                         if ((NULL != matches) && (0 < matches->len))
1240                                                 g_ptr_array_add(parents, matches->pdata[0]);
1241                                 }
1242                         }
1243                         g_strfreev(klasses);
1244                 }
1245                 ++ i;
1246         }
1247         return parents;
1248 }