plugins/valgrind/vgtoolview.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  *  Authors: Jeffrey Stedfast <fejj@ximian.com>
   4  *
   5  *  Copyright 2003 Ximian, Inc. (www.ximian.com)
   6  *  Copyright (C) Massimo Cora' 2005 <maxcvs@gmail.com>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21  *
  22  */
  23
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdarg.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <sys/stat.h>
  33 #include <unistd.h>
  34 #include <errno.h>
  35
  36 #include "vgtoolview.h"
  37
  38
  39 static void vg_tool_view_class_init (VgToolViewClass *klass);
  40 static void vg_tool_view_init (VgToolView *view);
  41 static void vg_tool_view_destroy (GtkObject *obj);
  42 static void vg_tool_view_finalize (GObject *obj);
  43
  44 static void tool_view_clear (VgToolView *view);
  45 static void tool_view_reset (VgToolView *view);
  46 static void tool_view_connect (VgToolView *view, int sockfd);
  47 static int  tool_view_step (VgToolView *view);
  48 static void tool_view_disconnect (VgToolView *view);
  49 static int  tool_view_save_log (VgToolView *view, gchar* uri);
  50 static int  tool_view_load_log (VgToolView *view, VgActions *actions, gchar* uri);
  51 static void tool_view_cut (VgToolView *view);
  52 static void tool_view_copy (VgToolView *view);
  53 static void tool_view_paste (VgToolView *view);
  54 static void tool_view_show_rules (VgToolView *view);
  55
  56
  57 static GtkVBoxClass *parent_class = NULL;
  58
  59 static void
  60 destroy_array_and_content (GPtrArray **array)
  61 {
  62         g_return_if_fail (array != NULL);
  63         if (*array)
  64         {
  65                 g_ptr_array_foreach (*array, (GFunc)g_free, NULL);
  66                 g_ptr_array_free (*array, TRUE);
  67                 *array = NULL;
  68         }
  69 }
  70
  71 static void
  72 allocate_array_and_content (GPtrArray **array, va_list va_args)
  73 {
  74         gchar* item;
  75
  76         g_return_if_fail (array != NULL);
  77         g_return_if_fail (*array == NULL);
  78
  79         *array = g_ptr_array_new ();
  80         for (item = va_arg (va_args, gchar *); item; item = va_arg (va_args, gchar *))
  81                 g_ptr_array_add (*array, g_strdup (item));
  82 }
  83
  84
  85 GType
  86 vg_tool_view_get_type (void)
  87 {
  88         static GType type = 0;
  89
  90         if (!type) {
  91                 static const GTypeInfo info = {
  92                         sizeof (VgToolViewClass),
  93                         NULL, /* base_class_init */
  94                         NULL, /* base_class_finalize */
  95                         (GClassInitFunc) vg_tool_view_class_init,
  96                         NULL, /* class_finalize */
  97                         NULL, /* class_data */
  98                         sizeof (VgToolView),
  99                         0,    /* n_preallocs */
 100                         (GInstanceInitFunc) vg_tool_view_init,
 101                 };
 102
 103                 type = g_type_register_static (GTK_TYPE_VBOX, "VgToolView", &info, 0);
 104         }
 105
 106         return type;
 107 }
 108
 109 static void
 110 vg_tool_view_class_init (VgToolViewClass *klass)
 111 {
 112         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 113         GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
 114
 115         parent_class = g_type_class_ref (GTK_TYPE_VBOX);
 116
 117         object_class->finalize = vg_tool_view_finalize;
 118         gtk_object_class->destroy = vg_tool_view_destroy;
 119
 120         /* virtual methods */
 121         klass->clear = tool_view_clear;
 122         klass->reset = tool_view_reset;
 123         klass->connect = tool_view_connect;
 124         klass->step = tool_view_step;
 125         klass->disconnect = tool_view_disconnect;
 126         klass->save_log = tool_view_save_log;
 127         klass->load_log = tool_view_load_log;
 128         klass->cut = tool_view_cut;
 129         klass->copy = tool_view_copy;
 130         klass->paste = tool_view_paste;
 131         klass->show_rules = tool_view_show_rules;
 132 }
 133
 134 static void
 135 vg_tool_view_init (VgToolView *view)
 136 {
 137         view->argv = NULL;
 138         view->symtab = NULL;
 139         view->srcdir = NULL;
 140         view->rules = NULL;
 141
 142         view->argv_array = NULL;
 143         view->srcdir_array = NULL;
 144 }
 145
 146 static void
 147 vg_tool_view_finalize (GObject *obj)
 148 {
 149         G_OBJECT_CLASS (parent_class)->finalize (obj);
 150 }
 151
 152 static void
 153 vg_tool_view_destroy (GtkObject *obj)
 154 {
 155         VgToolView *view = VG_TOOL_VIEW (obj);
 156         destroy_array_and_content (&view->srcdir_array);
 157         destroy_array_and_content (&view->argv_array);
 158
 159         GTK_OBJECT_CLASS (parent_class)->destroy (obj);
 160 }
 161
 162
 163 void
 164 vg_tool_view_set_argv (VgToolView *view, char *arg0, ...)
 165 {
 166         va_list va_args;
 167         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 168         destroy_array_and_content (&view->argv_array);
 169
 170         va_start (va_args, arg0);
 171         allocate_array_and_content (&view->argv_array, va_args);
 172         va_end (va_args);
 173
 174         view->argv = (const char**)view->argv_array->pdata;
 175 }
 176
 177 void
 178 vg_tool_view_set_srcdir (VgToolView *view, char *srcdir0, ...)
 179 {
 180         va_list va_args;
 181         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 182         destroy_array_and_content (&view->srcdir_array);
 183
 184         va_start (va_args, srcdir0);
 185         allocate_array_and_content (&view->srcdir_array, va_args);
 186         va_end (va_args);
 187
 188         view->srcdir = (const char**)view->srcdir_array->pdata;
 189 }
 190
 191
 192 void
 193 vg_tool_view_set_symtab (VgToolView *view, SymTab *symtab)
 194 {
 195         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 196
 197         view->symtab = symtab;
 198 }
 199
 200
 201 static void
 202 tool_view_clear (VgToolView *view)
 203 {
 204         ;
 205 }
 206
 207
 208 void
 209 vg_tool_view_clear (VgToolView *view)
 210 {
 211         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 212
 213         VG_TOOL_VIEW_GET_CLASS (view)->clear (view);
 214 }
 215
 216
 217 static void
 218 tool_view_reset (VgToolView *view)
 219 {
 220         ;
 221 }
 222
 223
 224 void
 225 vg_tool_view_reset (VgToolView *view)
 226 {
 227         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 228
 229         VG_TOOL_VIEW_GET_CLASS (view)->reset (view);
 230 }
 231
 232
 233 static void
 234 tool_view_connect (VgToolView *view, int sockfd)
 235 {
 236         ;
 237 }
 238
 239
 240 void
 241 vg_tool_view_connect (VgToolView *view, int sockfd)
 242 {
 243         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 244
 245         VG_TOOL_VIEW_GET_CLASS (view)->connect (view, sockfd);
 246 }
 247
 248
 249 static int
 250 tool_view_step (VgToolView *view)
 251 {
 252         return -1;
 253 }
 254
 255
 256 int
 257 vg_tool_view_step (VgToolView *view)
 258 {
 259         g_return_val_if_fail (VG_IS_TOOL_VIEW (view), -1);
 260
 261         return VG_TOOL_VIEW_GET_CLASS (view)->step (view);
 262 }
 263
 264
 265 static void
 266 tool_view_disconnect (VgToolView *view)
 267 {
 268         ;
 269 }
 270
 271
 272 void
 273 vg_tool_view_disconnect (VgToolView *view)
 274 {
 275         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 276
 277         VG_TOOL_VIEW_GET_CLASS (view)->disconnect (view);
 278 }
 279
 280
 281 static int
 282 tool_view_save_log (VgToolView *view, gchar* uri)
 283 {
 284         errno = ENOTSUP;
 285         return -1;
 286 }
 287
 288
 289 int
 290 vg_tool_view_save_log (VgToolView *view, gchar *uri)
 291 {
 292         g_return_val_if_fail (VG_IS_TOOL_VIEW (view), -1);
 293
 294         return VG_TOOL_VIEW_GET_CLASS (view)->save_log (view, uri);
 295 }
 296
 297
 298 static int
 299 tool_view_load_log (VgToolView *view, VgActions *actions, gchar* uri)
 300 {
 301         errno = ENOTSUP;
 302         return -1;
 303 }
 304
 305
 306 int
 307 vg_tool_view_load_log (VgToolView *view, VgActions *actions, gchar *uri)
 308 {
 309         g_return_val_if_fail (VG_IS_TOOL_VIEW (view), -1);
 310
 311         return VG_TOOL_VIEW_GET_CLASS (view)->load_log (view, actions, uri);
 312 }
 313
 314
 315 static void
 316 tool_view_cut (VgToolView *view)
 317 {
 318         ;
 319 }
 320
 321
 322 void
 323 vg_tool_view_cut (VgToolView *view)
 324 {
 325         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 326
 327         VG_TOOL_VIEW_GET_CLASS (view)->cut (view);
 328 }
 329
 330
 331 static void
 332 tool_view_copy (VgToolView *view)
 333 {
 334         ;
 335 }
 336
 337
 338 void
 339 vg_tool_view_copy (VgToolView *view)
 340 {
 341         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 342
 343         VG_TOOL_VIEW_GET_CLASS (view)->copy (view);
 344 }
 345
 346
 347 static void
 348 tool_view_paste (VgToolView *view)
 349 {
 350         ;
 351 }
 352
 353
 354 void
 355 vg_tool_view_paste (VgToolView *view)
 356 {
 357         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 358
 359         VG_TOOL_VIEW_GET_CLASS (view)->paste (view);
 360 }
 361
 362
 363 static void
 364 tool_view_show_rules (VgToolView *view)
 365 {
 366         if (view->rules == NULL)
 367                 return;
 368
 369         if (GTK_WIDGET_MAPPED (view->rules))
 370                 gdk_window_raise (view->rules->window);
 371         else
 372                 gtk_widget_show (view->rules);
 373 }
 374
 375
 376 void
 377 vg_tool_view_show_rules (VgToolView *view)
 378 {
 379         g_return_if_fail (VG_IS_TOOL_VIEW (view));
 380
 381         VG_TOOL_VIEW_GET_CLASS (view)->show_rules (view);
 382 }
 383
 384
 385
 386 static char *
 387 path_concat (const char *dirname, int dirlen, const char *basename, int baselen)
 388 {
 389         char *path, *p;
 390
 391         p = path = g_malloc (dirlen + baselen + 2);
 392         memcpy (path, dirname, dirlen);
 393         p += dirlen;
 394         *p++ = '/';
 395         memcpy (p, basename, baselen);
 396         p[baselen] = '\0';
 397
 398         return path;
 399 }
 400
 401 static gboolean
 402 path_is_rx (const char *path)
 403 {
 404         struct stat st;
 405
 406         if (stat (path, &st) != -1 && S_ISREG (st.st_mode)) {
 407                 if (access (path, R_OK | X_OK) != -1)
 408                         return TRUE;
 409         }
 410
 411         return FALSE;
 412 }
 413
 414
 415 char *
 416 vg_tool_view_scan_path (const char *program)
 417 {
 418         const char *pathenv, *path, *p;
 419         char *filename;
 420         int len;
 421
 422         if (program[0] == '/') {
 423                 if (path_is_rx (program))
 424                         return g_strdup (program);
 425
 426                 return NULL;
 427         }
 428
 429         if (!(pathenv = getenv ("PATH")))
 430                 return NULL;
 431
 432         path = pathenv;
 433         len = strlen (program);
 434         while ((p = strchr (path, ':'))) {
 435                 if (p > path) {
 436                         filename = path_concat (path, (p - path), program, len);
 437                         if (path_is_rx (filename))
 438                                 return filename;
 439
 440                         g_free (filename);
 441                 }
 442
 443                 path = p + 1;
 444         }
 445
 446         if (path[0] != '\0') {
 447                 filename = g_strdup_printf ("%s/%s", path, program);
 448                 if (path_is_rx (filename))
 449                         return filename;
 450
 451                 g_free (filename);
 452         }
 453
 454         return NULL;
 455 }