plugins/class-gen/generator.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*  generator.c
   3  *      Copyright (C) 2006 Armin Burgmeier
   4  *
   5  *      This program is free software; you can redistribute it and/or modify
   6  *      it under the terms of the GNU General Public License as published by
   7  *      the Free Software Foundation; either version 2 of the License, or
   8  *      (at your option) any later version.
   9  *
  10  *      This program is distributed in the hope that it will be useful,
  11  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
  13  *      GNU Library General Public License for more details.
  14  *
  15  *      You should have received a copy of the GNU General Public License
  16  *      along with this program; if not, write to the Free Software
  17  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include "generator.h"
  21
  22 #include <plugins/project-wizard/autogen.h>
  23
  24 #include <libanjuta/anjuta-marshal.h>
  25
  26 #include <glib/gstdio.h>
  27
  28 typedef struct _CgGeneratorPrivate CgGeneratorPrivate;
  29 struct _CgGeneratorPrivate
  30 {
  31         NPWAutogen *autogen;
  32
  33         gchar *header_template;
  34         gchar *source_template;
  35         gchar *header_destination;
  36         gchar *source_destination;
  37 };
  38
  39 #define CG_GENERATOR_PRIVATE(o) \
  40         (G_TYPE_INSTANCE_GET_PRIVATE( \
  41                 (o), \
  42                 CG_TYPE_GENERATOR, \
  43                 CgGeneratorPrivate \
  44         ))
  45
  46 enum {
  47         PROP_0,
  48
  49         /* Construct only */
  50         PROP_HEADER_TEMPLATE,
  51         PROP_SOURCE_TEMPLATE,
  52         PROP_HEADER_DESTINATION,
  53         PROP_SOURCE_DESTINATION
  54 };
  55
  56 enum
  57 {
  58         CREATED,
  59         ERROR,
  60
  61         LAST_SIGNAL
  62 };
  63
  64 static GObjectClass *parent_class = NULL;
  65 static guint generator_signals[LAST_SIGNAL] = { 0 };
  66
  67 static gchar *
  68 cg_generator_make_absolute (const gchar *path)
  69 {
  70         gchar *current_dir;
  71         gchar *abs_path;
  72
  73         /* TODO: Use gnome-vfs stuff here? */
  74         if (g_path_is_absolute (path))
  75         {
  76                 abs_path = g_strdup (path);
  77         }
  78         else
  79         {
  80                 current_dir = g_get_current_dir ();
  81                 abs_path = g_build_filename (current_dir, path, NULL);
  82                 g_free (current_dir);
  83         }
  84
  85         return abs_path;
  86 }
  87
  88 static void
  89 cg_generator_autogen_source_func (NPWAutogen *autogen,
  90                                   gpointer user_data)
  91 {
  92         CgGenerator *generator;
  93         CgGeneratorPrivate *priv;
  94         GError *error;
  95         gboolean success;
  96
  97         generator = CG_GENERATOR (user_data);
  98         priv = CG_GENERATOR_PRIVATE (generator);
  99
 100         success = TRUE;
 101         if (g_file_test (priv->header_destination,
 102                          G_FILE_TEST_IS_REGULAR) == FALSE)
 103         {
 104                 if (g_file_test (priv->source_destination,
 105                                  G_FILE_TEST_IS_REGULAR) == TRUE)
 106                 {
 107                         g_unlink (priv->source_destination);
 108                 }
 109
 110                 success = FALSE;
 111         }
 112         else if (g_file_test (priv->source_destination,
 113                               G_FILE_TEST_IS_REGULAR) == FALSE)
 114         {
 115                 /* It is guaranteed that header file is a regular file, otherwise
 116                  * the else branch would not have been executed */
 117                 g_unlink (priv->source_destination);
 118                 success = FALSE;
 119         }
 120
 121         if (success == TRUE)
 122         {
 123                 /* TODO: Check contents of destination file for autogen error */
 124                 g_signal_emit(G_OBJECT(generator), generator_signals[CREATED], 0);
 125         }
 126         else
 127         {
 128                 error = NULL;
 129
 130                 g_set_error(&error, g_quark_from_static_string("CG_GENERATOR_ERROR"),
 131                             CG_GENERATOR_ERROR_NOT_GENERATED,
 132                             _("Header or source file has not been created"));
 133
 134                 g_signal_emit (G_OBJECT (generator), generator_signals[ERROR],
 135                                0, error);
 136                 g_error_free (error);
 137         }
 138 }
 139
 140 static void
 141 cg_generator_autogen_header_func (NPWAutogen *autogen,
 142                                   gpointer user_data)
 143 {
 144         CgGenerator *generator;
 145         CgGeneratorPrivate *priv;
 146         gboolean result;
 147         GError *error;
 148
 149         generator = CG_GENERATOR (user_data);
 150         priv = CG_GENERATOR_PRIVATE (generator);
 151
 152         error = NULL;
 153
 154         npw_autogen_set_input_file (priv->autogen, priv->source_template, NULL, NULL); /*"[+", "+]");*/
 155         npw_autogen_set_output_file (priv->autogen, priv->source_destination);
 156
 157         result = npw_autogen_execute (priv->autogen,
 158                                       cg_generator_autogen_source_func,
 159                                       generator, &error);
 160
 161         if (result == FALSE)
 162         {
 163                 g_signal_emit (G_OBJECT(generator), generator_signals[ERROR],
 164                                0, error);
 165                 g_error_free (error);
 166         }
 167 }
 168
 169 static void
 170 cg_generator_init (CgGenerator *generator)
 171 {
 172         CgGeneratorPrivate *priv;
 173         priv = CG_GENERATOR_PRIVATE (generator);
 174
 175         priv->autogen = npw_autogen_new ();
 176
 177         priv->header_template = NULL;
 178         priv->source_template = NULL;
 179         priv->header_destination = NULL;
 180         priv->source_destination = NULL;
 181 }
 182
 183 static void
 184 cg_generator_finalize (GObject *object)
 185 {
 186         CgGenerator *generator;
 187         CgGeneratorPrivate *priv;
 188
 189         generator = CG_GENERATOR (object);
 190         priv = CG_GENERATOR_PRIVATE (generator);
 191
 192         npw_autogen_free (priv->autogen);
 193
 194         g_free (priv->header_template);
 195         g_free (priv->source_template);
 196         g_free (priv->header_destination);
 197         g_free (priv->source_destination);
 198
 199         G_OBJECT_CLASS (parent_class)->finalize (object);
 200 }
 201
 202 static void
 203 cg_generator_set_property (GObject *object,
 204                            guint prop_id,
 205                            const GValue *value,
 206                            GParamSpec *pspec)
 207 {
 208         CgGenerator *generator;
 209         CgGeneratorPrivate *priv;
 210
 211         g_return_if_fail (CG_IS_GENERATOR (object));
 212
 213         generator = CG_GENERATOR (object);
 214         priv = CG_GENERATOR_PRIVATE (generator);
 215
 216         switch (prop_id)
 217         {
 218         case PROP_HEADER_TEMPLATE:
 219                 g_free (priv->header_template);
 220                 priv->header_template =
 221                         cg_generator_make_absolute (g_value_get_string (value));
 222                 break;
 223         case PROP_SOURCE_TEMPLATE:
 224                 g_free (priv->source_template);
 225                 priv->source_template =
 226                         cg_generator_make_absolute (g_value_get_string (value));
 227                 break;
 228         case PROP_HEADER_DESTINATION:
 229                 g_free (priv->header_destination);
 230                 priv->header_destination =
 231                         cg_generator_make_absolute (g_value_get_string (value));
 232                 break;
 233         case PROP_SOURCE_DESTINATION:
 234                 g_free (priv->source_destination);
 235                 priv->source_destination =
 236                         cg_generator_make_absolute (g_value_get_string (value));
 237                 break;
 238         default:
 239                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 240                 break;
 241         }
 242 }
 243
 244 static void
 245 cg_generator_get_property (GObject *object,
 246                            guint prop_id,
 247                            GValue *value,
 248                            GParamSpec *pspec)
 249 {
 250         CgGenerator *generator;
 251         CgGeneratorPrivate *priv;
 252
 253         g_return_if_fail (CG_IS_GENERATOR (object));
 254
 255         generator = CG_GENERATOR (object);
 256         priv = CG_GENERATOR_PRIVATE (generator);
 257
 258         switch (prop_id)
 259         {
 260         case PROP_HEADER_TEMPLATE:
 261                 g_value_set_string (value, priv->header_template);
 262                 break;
 263         case PROP_SOURCE_TEMPLATE:
 264                 g_value_set_string (value, priv->source_template);
 265                 break;
 266         case PROP_HEADER_DESTINATION:
 267                 g_value_set_string (value, priv->header_destination);
 268                 break;
 269         case PROP_SOURCE_DESTINATION:
 270                 g_value_set_string (value, priv->source_destination);
 271                 break;
 272         default:
 273                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 274                 break;
 275         }
 276 }
 277
 278 static void
 279 cg_generator_class_init (CgGeneratorClass *klass)
 280 {
 281         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 282         parent_class = g_type_class_peek_parent (klass);
 283
 284         g_type_class_add_private(klass, sizeof(CgGeneratorPrivate));
 285
 286         object_class->finalize = cg_generator_finalize;
 287         object_class->set_property = cg_generator_set_property;
 288         object_class->get_property = cg_generator_get_property;
 289
 290         g_object_class_install_property (object_class,
 291                                          PROP_HEADER_TEMPLATE,
 292                                          g_param_spec_string ("header-template",
 293                                                               "Header Template File",
 294                                                               _("Autogen template used for the header file"),
 295                                                               NULL,
 296                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 297
 298         g_object_class_install_property (object_class,
 299                                          PROP_SOURCE_TEMPLATE,
 300                                          g_param_spec_string ("source-template",
 301                                                               "Source Template File",
 302                                                               _("Autogen template used for the implementation file"),
 303                                                               NULL,
 304                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 305
 306         g_object_class_install_property (object_class,
 307                                          PROP_HEADER_DESTINATION,
 308                                          g_param_spec_string ("header-destination",
 309                                                               "Header Target File",
 310                                                               _("File to which the processed template will be written"),
 311                                                               NULL,
 312                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 313
 314         g_object_class_install_property (object_class,
 315                                          PROP_SOURCE_DESTINATION,
 316                                          g_param_spec_string ("source-destination",
 317                                                               "Source Target File",
 318                                                               _("File to which the processed template will be written"),
 319                                                               NULL,
 320                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 321
 322         generator_signals[CREATED] =
 323                 g_signal_new ("created",
 324                               G_OBJECT_CLASS_TYPE(object_class),
 325                               G_SIGNAL_RUN_LAST,
 326                               0, /* no default handler */
 327                               NULL, NULL,
 328                               anjuta_cclosure_marshal_VOID__VOID,
 329                               G_TYPE_NONE,
 330                               0);
 331
 332         generator_signals[ERROR] =
 333                 g_signal_new ("error",
 334                               G_OBJECT_CLASS_TYPE(object_class),
 335                               G_SIGNAL_RUN_LAST,
 336                               0, /* no default handler */
 337                               NULL, NULL,
 338                               anjuta_cclosure_marshal_VOID__POINTER,
 339                               G_TYPE_NONE,
 340                               1,
 341                               G_TYPE_POINTER); /* GError seems not to have its own GType */
 342 }
 343
 344 GType
 345 cg_generator_get_type (void)
 346 {
 347         static GType our_type = 0;
 348
 349         if (our_type == 0)
 350         {
 351                 static const GTypeInfo our_info =
 352                 {
 353                         sizeof (CgGeneratorClass),
 354                         (GBaseInitFunc) NULL,
 355                         (GBaseFinalizeFunc) NULL,
 356                         (GClassInitFunc) cg_generator_class_init,
 357                         NULL,
 358                         NULL,
 359                         sizeof (CgGenerator),
 360                         0,
 361                         (GInstanceInitFunc) cg_generator_init,
 362                         NULL
 363                 };
 364
 365                 our_type = g_type_register_static (G_TYPE_OBJECT, "CgGenerator",
 366                                                    &our_info, 0);
 367         }
 368
 369         return our_type;
 370 }
 371
 372 CgGenerator *
 373 cg_generator_new (const gchar *header_template,
 374                   const gchar *source_template,
 375                   const gchar *header_destination,
 376                   const gchar *source_destination)
 377 {
 378         GObject *object;
 379
 380         object = g_object_new (CG_TYPE_GENERATOR,
 381                                "header-template", header_template,
 382                                "source-template", source_template,
 383                                "header-destination", header_destination,
 384                                "source-destination", source_destination, NULL);
 385
 386         return CG_GENERATOR (object);
 387 }
 388
 389 gboolean
 390 cg_generator_run (CgGenerator *generator,
 391                   NPWValueHeap *values,
 392                   GError **error)
 393 {
 394         CgGeneratorPrivate *priv;
 395         priv = CG_GENERATOR_PRIVATE (generator);
 396
 397         /* TODO: npw_autogen_write_definiton_file should take a GError... */
 398         if (npw_autogen_write_definition_file (priv->autogen, values) == FALSE)
 399         {
 400                 g_set_error (error, g_quark_from_static_string("CG_GENERATOR_ERROR"),
 401                              CG_GENERATOR_ERROR_DEFFILE,
 402                              _("Failed to write autogen definition file"));
 403
 404                 return FALSE;
 405         }
 406         else
 407         {
 408                 npw_autogen_set_input_file (priv->autogen, priv->header_template,
 409                                             NULL, NULL); /*"[+", "+]");*/
 410                 npw_autogen_set_output_file (priv->autogen, priv->header_destination);
 411
 412                 return npw_autogen_execute (priv->autogen,
 413                                             cg_generator_autogen_header_func,
 414                                             generator, error);
 415         }
 416 }
 417
 418 const gchar *
 419 cg_generator_get_header_template (CgGenerator *generator)
 420 {
 421         return CG_GENERATOR_PRIVATE (generator)->header_template;
 422 }
 423
 424 const gchar *
 425 cg_generator_get_source_template (CgGenerator *generator)
 426 {
 427         return CG_GENERATOR_PRIVATE (generator)->source_template;
 428 }
 429
 430 const gchar *
 431 cg_generator_get_header_destination (CgGenerator *generator)
 432 {
 433         return CG_GENERATOR_PRIVATE (generator)->header_destination;
 434 }
 435
 436 const gchar *
 437 cg_generator_get_source_destination(CgGenerator *generator)
 438 {
 439         return CG_GENERATOR_PRIVATE (generator)->source_destination;
 440 }