Symaptic: os/ossrv/ofdbus/dbus-glib/dbus/dbus-glib-tool.c@260cb5ec6c19

     1 /* -*- mode: C; c-file-style: "gnu" -*- */

     2 /* dbus-glib-tool.c Tool used by apps using glib bindings

     3  *

     4  * Copyright (C) 2003, 2004 Red Hat, Inc.

     5  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     6  * Licensed under the Academic Free License version 2.1

     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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    21  *

    22  */

    24  #ifdef __SYMBIAN32__

    25  #define VERSION "1.0.2"

    26  #endif

    28 #ifndef __SYMBIAN32__

    29 #include <config.h>

    30 #else

    31 #include "config.h"

    32 #endif //__SYMBIAN32__

    33 #include "dbus-gidl.h"

    34 #include "dbus-gparser.h"

    35 #include "dbus-gutils.h"

    36 #include "dbus-glib-tool.h"

    37 #include "dbus-binding-tool-glib.h"

    38 #include <locale.h>

    39 #ifndef __SYMBIAN32__

    40 #include <libintl.h>

    41 #define _(x) dgettext (GETTEXT_PACKAGE, x)

    42 #define N_(x) x

    43 #else

    44 #define _(x)  x

    45 #define N_(x) x

    46 #endif

    47 #include <stdio.h>

    48 #include <stdlib.h>

    49 #include <errno.h>

    50 #include <sys/stat.h>

    51 #include <string.h>

    52 #include <time.h>

    54 #ifdef DBUS_BUILD_TESTS

    55 static void run_all_tests (const char *test_data_dir);

    56 #endif

    58 typedef enum {

    59   DBUS_BINDING_OUTPUT_NONE,

    60   DBUS_BINDING_OUTPUT_PRETTY,

    61   DBUS_BINDING_OUTPUT_GLIB_SERVER,

    62   DBUS_BINDING_OUTPUT_GLIB_CLIENT

    63 } DBusBindingOutputMode;

    65 static void

    66 indent (int depth)

    67 {

    68   depth *= 2; /* 2-space indent */

    70   while (depth > 0)

    71     {

    72       putc (' ', stdout);

    73       --depth;

    74     }

    75 }

    77 static void pretty_print (BaseInfo *base,

    78                           int       depth);

    80 static void

    81 pretty_print_list (GSList *list,

    82                    int     depth)

    83 {

    84   GSList *tmp;

    86   tmp = list;

    87   while (tmp != NULL)

    88     {

    89       pretty_print (tmp->data, depth);

    90       tmp = tmp->next;

    91     }

    92 }

    94 static void

    95 pretty_print (BaseInfo *base,

    96               int       depth)

    97 {

    98   InfoType t;

    99   const char *name;

   101   t = base_info_get_type (base);

   102   name = base_info_get_name (base);

   104   indent (depth);

   106   switch (t)

   107     {

   108     case INFO_TYPE_NODE:

   109       {

   110         NodeInfo *n = (NodeInfo*) base;

   112         if (name == NULL)

   113           printf (_("<anonymous node> {\n"));

   114         else

   115           printf (_("node \"%s\" {\n"), name);

   117         pretty_print_list (node_info_get_interfaces (n), depth + 1);

   118         pretty_print_list (node_info_get_nodes (n), depth + 1);

   120         indent (depth);

   121         printf ("}\n");

   122       }

   123       break;

   124     case INFO_TYPE_INTERFACE:

   125       {

   126         InterfaceInfo *i = (InterfaceInfo*) base;

   127 	GSList *annotations, *elt;

   129         g_assert (name != NULL);

   131         printf (_("interface \"%s\" {\n"), name);

   133 	annotations = interface_info_get_annotations (i);

   134 	for (elt = annotations; elt; elt = elt->next)

   135 	  {

   136 	    const char *name = elt->data;

   137 	    const char *value = interface_info_get_annotation (i, name);

   139 	    printf (_(" (binding \"%s\": \"%s\") "),

   140 		    name, value);

   141 	  }

   142 	g_slist_free (annotations);

   144         pretty_print_list (interface_info_get_methods (i), depth + 1);

   145         pretty_print_list (interface_info_get_signals (i), depth + 1);

   146         pretty_print_list (interface_info_get_properties (i), depth + 1);

   148         indent (depth);

   149         printf ("}\n");

   150       }

   151       break;

   152     case INFO_TYPE_METHOD:

   153       {

   154         MethodInfo *m = (MethodInfo*) base;

   155 	GSList *annotations, *elt;

   157         g_assert (name != NULL);

   159 	annotations = method_info_get_annotations (m);

   160         printf (_("method \"%s\""), name);

   161 	for (elt = annotations; elt; elt = elt->next)

   162 	  {

   163 	    const char *name = elt->data;

   164 	    const char *value = method_info_get_annotation (m, name);

   166 	    printf (_(" (annotation \"%s\": \"%s\") "),

   167 		    name, value);

   168 	  }

   169 	g_slist_free (annotations);

   171         pretty_print_list (method_info_get_args (m), depth + 1);

   173         indent (depth);

   174         printf (")\n");

   175       }

   176       break;

   177     case INFO_TYPE_SIGNAL:

   178       {

   179         SignalInfo *s = (SignalInfo*) base;

   181         g_assert (name != NULL);

   183         printf (_("signal \"%s\" (\n"), name);

   185         pretty_print_list (signal_info_get_args (s), depth + 1);

   187         indent (depth);

   188         printf (")\n");

   189       }

   190       break;

   191     case INFO_TYPE_PROPERTY:

   192       {

   193         PropertyInfo *a = (PropertyInfo*) base;

   194         const char *pt = property_info_get_type (a);

   195         PropertyAccessFlags acc = property_info_get_access (a);

   197         printf ("%s%s %s",

   198                 acc & PROPERTY_READ ? "read" : "",

   199                 acc & PROPERTY_WRITE ? "write" : "",

   200                 pt);

   201         if (name)

   202           printf (" %s\n", name);

   203         else

   204           printf ("\n");

   205       }

   206       break;

   207     case INFO_TYPE_ARG:

   208       {

   209         ArgInfo *a = (ArgInfo*) base;

   210         const char *at = arg_info_get_type (a);

   211         ArgDirection d = arg_info_get_direction (a);

   213         printf ("%s %s",

   214                 d == ARG_IN ? "in" : "out",

   215                 at);

   216         if (name)

   217           printf (" %s\n", name);

   218         else

   219           printf ("\n");

   220       }

   221       break;

   222     }

   223 }

   225 GQuark

   226 dbus_binding_tool_error_quark (void)

   227 {

   228   static GQuark quark = 0;

   229   if (!quark)

   230     quark = g_quark_from_static_string ("dbus_binding_tool_error");

   232   return quark;

   233 }

   235 static void lose (const char *fmt, ...) G_GNUC_NORETURN G_GNUC_PRINTF (1, 2);

   236 static void lose_gerror (const char *prefix, GError *error) G_GNUC_NORETURN;

   238 static void

   239 lose (const char *str, ...)

   240 {

   241   va_list args;

   243   va_start (args, str);

   245   vfprintf (stderr, str, args);

   246   fputc ('\n', stderr);

   248   va_end (args);

   250   exit (1);

   251 }

   253 static void

   254 lose_gerror (const char *prefix, GError *error)

   255 {

   256   lose ("%s: %s", prefix, error->message);

   257 }

   259 static void

   260 usage (int ecode)

   261 {

   262   fprintf (stderr, "dbus-binding-tool [--version] [--help]\n");

   263   fprintf (stderr, "dbus-binding-tool --mode=[pretty|glib-server|glib-client] [--prefix=SYMBOL_PREFIX] [--ignore-unsupported] [--force] [--output=FILE] [\n");

   264   fprintf (stderr, "dbus-binding-tool --mode=glib-server --prefix=SYMBOL_PREFIX [--ignore-unsupported] [--force] [--output=FILE] [\n");

   265   exit (ecode);

   266 }

   268 static void

   269 version (void)

   270 {

   271   printf ("D-BUS Binding Tool %s\n"

   272           "Copyright (C) 2003-2005 Red Hat, Inc.\n"

   273           "This is free software; see the source for copying conditions.\n"

   274           "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",

   275           VERSION

   276           );

   277   exit (0);

   278 }

   280 int

   281 main (int argc, char **argv)

   282 {

   283   const char *output_file;

   284   const char *prefix;

   285   char *output_file_tmp;

   286   int i;

   287   GSList *files;

   288   DBusBindingOutputMode outputmode;

   289   gboolean end_of_args;

   290   GSList *tmp;

   291   GIOChannel *channel;

   292   GError *error;

   293   time_t newest_src;

   294   struct stat srcbuf;

   295   struct stat targetbuf;

   296   gboolean force;

   297   gboolean ignore_unsupported;

   298   gboolean has_prefix = FALSE;

   300   #ifndef TODO

   301   setlocale (LC_ALL, "");

   302   bindtextdomain (GETTEXT_PACKAGE, DBUS_LOCALEDIR);

   303   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

   304   textdomain (GETTEXT_PACKAGE);

   305   #endif

   306   g_type_init ();

   308   outputmode = DBUS_BINDING_OUTPUT_NONE;

   309   end_of_args = FALSE;

   310   files = NULL;

   311   output_file = NULL;

   312   prefix = "";

   313   ignore_unsupported = FALSE;

   314   force = FALSE;

   315   i = 1;

   316   while (i < argc)

   317     {

   318       const char *arg = argv[i];

   320       if (!end_of_args)

   321         {

   322           if (strcmp (arg, "--help") == 0 ||

   323               strcmp (arg, "-h") == 0 ||

   324               strcmp (arg, "-?") == 0)

   325             usage (0);

   326           else if (strcmp (arg, "--version") == 0)

   327             version ();

   328           else if (strcmp (arg, "--force") == 0)

   329             force = TRUE;

   330 #ifdef DBUS_BUILD_TESTS

   331           else if (strcmp (arg, "--self-test") == 0)

   332             run_all_tests (NULL);

   333 #endif /* DBUS_BUILD_TESTS */

   334           else if (strncmp (arg, "--mode=", 7) == 0)

   335             {

   336 	      const char *mode = arg + 7;

   337 	      if (!strcmp (mode, "pretty"))

   338 		outputmode = DBUS_BINDING_OUTPUT_PRETTY;

   339 	      else if (!strcmp (mode, "glib-server"))

   340 		outputmode = DBUS_BINDING_OUTPUT_GLIB_SERVER;

   341 	      else if (!strcmp (mode, "glib-client"))

   342 		outputmode = DBUS_BINDING_OUTPUT_GLIB_CLIENT;

   343 	      else

   344 		usage (1);

   345 	    }

   346           else if (strcmp (arg, "--ignore-unsupported") == 0)

   347             ignore_unsupported = TRUE;

   348 	  else if (strncmp (arg, "--output=", 9) == 0)

   349 	    {

   350 	      output_file = arg + 9;

   351 	    }

   352           else if (strncmp (arg, "--prefix=", 9) == 0)

   353             {

   354               has_prefix = TRUE;

   355               prefix = arg + 9;

   356             }

   357           else if (arg[0] == '-' &&

   358                    arg[1] == '-' &&

   359                    arg[2] == '\0')

   360             end_of_args = TRUE;

   361           else if (arg[0] == '-')

   362             {

   363               usage (1);

   364             }

   365           else

   366             {

   367               files = g_slist_prepend (files, (char*) arg);

   368             }

   369         }

   370       else

   371         files = g_slist_prepend (files, (char*) arg);

   373       ++i;

   374     }

   376   if (outputmode == DBUS_BINDING_OUTPUT_GLIB_SERVER && !has_prefix)

   377     usage (1);

   379   error = NULL;

   381   files = g_slist_reverse (files);

   383   if (output_file && !force)

   384     {

   385       newest_src = 0;

   386       for (tmp = files; tmp != NULL; tmp = tmp->next)

   387 	{

   388 	  const char *filename;

   390 	  filename = tmp->data;

   391 	  if (stat (filename, &srcbuf) < 0)

   392 	    lose ("Couldn't stat %s: %s", filename, g_strerror (errno));

   394 	  if (srcbuf.st_mtime > newest_src)

   395 	    newest_src = srcbuf.st_mtime;

   396 	}

   398       if (stat (output_file, &targetbuf) > 0

   399 	  && targetbuf.st_mtime >= newest_src)

   400 	exit (0);

   401     }

   403   if (output_file)

   404     {

   405       output_file_tmp = g_strconcat (output_file, ".tmp", NULL);

   407       if (!(channel = g_io_channel_new_file (output_file_tmp, "w", &error)))

   408 	lose_gerror (_("Couldn't open temporary file"), error);

   409     }

   410   else

   411     {

   412       channel = g_io_channel_unix_new (fileno (stdout));

   413       output_file_tmp = NULL; /* silence gcc */

   414     }

   415   if (!g_io_channel_set_encoding (channel, NULL, &error))

   416     lose_gerror (_("Couldn't set channel encoding to NULL"), error);

   419   for (tmp = files; tmp != NULL; tmp = tmp->next)

   420     {

   421       NodeInfo *node;

   422       GError *error;

   423       const char *filename;

   425       filename = tmp->data;

   427       error = NULL;

   428       node = description_load_from_file (filename,

   429                                          &error);

   430       if (node == NULL)

   431         {

   432 	  lose_gerror (_("Unable to load \"%s\""), error);

   433         }

   434       else

   435 	{

   436 	  switch (outputmode)

   437 	    {

   438 	    case DBUS_BINDING_OUTPUT_PRETTY:

   439 	      pretty_print ((BaseInfo*) node, 0);

   440 	      break;

   441 	    case DBUS_BINDING_OUTPUT_GLIB_SERVER:

   442 	      if (!dbus_binding_tool_output_glib_server ((BaseInfo *) node, channel, prefix, &error))

   443 		lose_gerror (_("Compilation failed"), error);

   444 	      break;

   445 	    case DBUS_BINDING_OUTPUT_GLIB_CLIENT:

   446 	      if (!dbus_binding_tool_output_glib_client ((BaseInfo *) node, channel, ignore_unsupported, &error))

   447 		lose_gerror (_("Compilation failed"), error);

   448 	      break;

   449 	    case DBUS_BINDING_OUTPUT_NONE:

   450 	      break;

   451 	    }

   452 	}

   454       if (node)

   455         node_info_unref (node);

   456     }

   458   if (g_io_channel_shutdown (channel, TRUE, &error) != G_IO_STATUS_NORMAL)

   459     lose_gerror (_("Failed to shutdown IO channel"), error);

   460   g_io_channel_unref (channel);

   462   if (output_file)

   463     {

   464       if (rename (output_file_tmp, output_file) < 0)

   465 	lose ("Failed to rename %s to %s: %s", output_file_tmp, output_file,

   466 	      g_strerror (errno));

   467       g_free (output_file_tmp);

   468     }

   470   return 0;

   471 }

   474 #ifdef DBUS_BUILD_TESTS

   475 static void

   476 test_die (const char *failure)

   477 {

   478   lose ("Unit test failed: %s", failure);

   479 }

   481 /**

   482  * @ingroup DBusGTool

   483  * Unit test for GLib utility tool

   484  * Returns: #TRUE on success.

   485  */

   486 static gboolean

   487 _dbus_gtool_test (const char *test_data_dir)

   488 {

   490   return TRUE;

   491 }

   493 static void

   494 run_all_tests (const char *test_data_dir)

   495 {

   496   if (test_data_dir == NULL)

   497     test_data_dir = g_getenv ("DBUS_TEST_DATA");

   499   if (test_data_dir != NULL)

   500     printf ("Test data in %s\n", test_data_dir);

   501   else

   502     printf ("No test data!\n");

   504   printf ("%s: running binding tests\n", "dbus-binding-tool");

   505   if (!_dbus_gtool_test (test_data_dir))

   506     test_die ("gtool");

   508   printf ("%s: completed successfully\n", "dbus-binding-tool");

   509 }

   511 #endif /* DBUS_BUILD_TESTS */

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--