lttv/lttv/option.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Michel Dagenais
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <popt.h>
  24 #include <glib.h>
  25 #include <lttv/module.h>
  26 #include <lttv/option.h>
  27
  28 typedef struct _LttvOption {
  29         char *long_name;
  30         char char_name;
  31         char *description;
  32         char *arg_description;
  33         LttvOptionType t;
  34         gpointer p;
  35         LttvOptionHook hook;
  36         gpointer hook_data;
  37
  38         /* Keep the order of addition */
  39         guint val;
  40 } LttvOption;
  41
  42 GHashTable *options;
  43
  44
  45 static void list_options(gpointer key, gpointer value, gpointer user_data)
  46 {
  47         GPtrArray *list = (GPtrArray *)user_data;
  48         LttvOption *option = (LttvOption *)value;
  49
  50         if(list->len < option->val)
  51                 g_ptr_array_set_size(list, option->val);
  52         list->pdata[option->val-1] = option;
  53 }
  54
  55
  56 static void free_option(LttvOption *option)
  57 {
  58         g_free(option->long_name);
  59         g_free(option->description);
  60         g_free(option->arg_description);
  61         g_free(option);
  62 }
  63
  64 static gboolean compare_short_option(gpointer key,
  65                                      gpointer value,
  66                                      gpointer user_data)
  67 {
  68         LttvOption *option = value;
  69         const char short_option = *(const char *)user_data;
  70
  71
  72         if(option->char_name == short_option) {
  73                 return TRUE;
  74         } else {
  75                 return FALSE;
  76         }
  77 }
  78
  79 void lttv_option_add(const char *long_name, const char char_name,
  80                 const char *description, const char *arg_description,
  81                 const LttvOptionType t, void *p,
  82                 const LttvOptionHook h, void *hook_data)
  83 {
  84         LttvOption *option;
  85
  86         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Add option %s", long_name);
  87         if(g_hash_table_lookup(options, long_name) != NULL) {
  88                 g_warning("duplicate long-option: %s", long_name);
  89                 return;
  90         }
  91         if(char_name && g_hash_table_find(options, compare_short_option, (gpointer)&char_name) != NULL) {
  92                 g_warning("duplicate short-option: %c for option %s",
  93                           char_name,
  94                           long_name);
  95                 return;
  96         }
  97
  98
  99         option = g_new(LttvOption, 1);
 100         option->long_name = g_strdup(long_name);
 101         option->char_name = char_name;
 102         option->description = g_strdup(description);
 103         option->arg_description = g_strdup(arg_description);
 104         option->t = t;
 105         option->p = p;
 106         option->hook = h;
 107         option->hook_data = hook_data;
 108         option->val = g_hash_table_size(options) + 1;
 109         g_hash_table_insert(options, option->long_name, option);
 110 }
 111
 112
 113 void lttv_option_remove(const char *long_name)
 114 {
 115         LttvOption *option = g_hash_table_lookup(options, long_name);
 116
 117         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Remove option %s", long_name);
 118         if(option == NULL) {
 119                 g_warning("trying to remove unknown option %s", long_name);
 120                 return;
 121         }
 122         g_hash_table_remove(options, long_name);
 123         free_option(option);
 124 }
 125
 126
 127 static int poptToLTT[] = {
 128         POPT_ARG_NONE, POPT_ARG_STRING, POPT_ARG_INT, POPT_ARG_LONG
 129 };
 130
 131 static struct poptOption endOption = { NULL, '\0', 0, NULL, 0, NULL, NULL };
 132
 133
 134 static void build_popts(GPtrArray **plist, struct poptOption **ppopts,
 135                 poptContext *pc, int argc, char **argv)
 136 {
 137         LttvOption *option;
 138
 139         GPtrArray *list;
 140
 141         struct poptOption *popts;
 142
 143         poptContext c;
 144
 145         guint i;
 146
 147         list = g_ptr_array_sized_new(g_hash_table_size(options));
 148
 149         g_hash_table_foreach(options, list_options, list);
 150
 151         /* Build a popt options array from our list */
 152
 153         popts = g_new(struct poptOption, list->len + 1);
 154
 155         /* add the options in the reverse order, so last additions are parsed first */
 156         for(i = 0 ; i < list->len ; i++) {
 157                 guint reverse_i = list->len-1-i;
 158                 option = (LttvOption *)list->pdata[i];
 159                 popts[reverse_i].longName = option->long_name;
 160                 popts[reverse_i].shortName = option->char_name;
 161                 popts[reverse_i].descrip = option->description;
 162                 popts[reverse_i].argDescrip = option->arg_description;
 163                 popts[reverse_i].argInfo = poptToLTT[option->t];
 164                 popts[reverse_i].arg = option->p;
 165                 popts[reverse_i].val = option->val;
 166         }
 167
 168         /* Terminate the array for popt and create the context */
 169
 170         popts[list->len] = endOption;
 171         c = poptGetContext(argv[0], argc, (const char**)argv, popts, 0);
 172
 173         *plist = list;
 174         *ppopts = popts;
 175         *pc = c;
 176 }
 177
 178
 179 static void destroy_popts(GPtrArray **plist, struct poptOption **ppopts,
 180                 poptContext *pc)
 181 {
 182         g_ptr_array_free(*plist, TRUE); *plist = NULL;
 183         g_free(*ppopts); *ppopts = NULL;
 184         poptFreeContext(*pc);
 185 }
 186
 187
 188 void lttv_option_parse(int argc, char **argv)
 189 {
 190         GPtrArray *list;
 191
 192         LttvOption *option;
 193
 194         int i, rc, first_arg;
 195
 196         struct poptOption *popts;
 197
 198         poptContext c;
 199
 200         i = 0;
 201
 202         first_arg = 0;
 203
 204         guint hash_size = 0;
 205
 206         build_popts(&list, &popts, &c, argc, argv);
 207
 208         /* Parse options while not end of options event */
 209
 210         while((rc = poptGetNextOpt(c)) != -1) {
 211
 212                 /* The option was recognized and the rc value returned is the argument
 213                    position in the array. Call the associated hook if present. */
 214
 215                 if(rc > 0) {
 216                         option = (LttvOption *)(list->pdata[rc - 1]);
 217                         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Option %s encountered",
 218                                         option->long_name);
 219                         hash_size = g_hash_table_size(options);
 220                         if(option->hook != NULL) {
 221                                 g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s hook called",
 222                                                 option->long_name);
 223                                 option->hook(option->hook_data);
 224                         }
 225                         i++;
 226
 227                         /* If the size of the option hash changed, add new options
 228                          * right now. It resolves the conflict of multiple same short
 229                          * option use.
 230                          */
 231                         if(hash_size != g_hash_table_size(options)) {
 232                                 destroy_popts(&list, &popts, &c);
 233                                 build_popts(&list, &popts, &c, argc, argv);
 234
 235                                 /* Get back to the same argument */
 236
 237                                 first_arg = i;
 238                                 for(i = 0; i < first_arg; i++) {
 239                                         rc = poptGetNextOpt(c);
 240                                         option = (LttvOption *)(list->pdata[rc - 1]);
 241                                         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s rescanned, skipped",
 242                                                         option->long_name);
 243                                 }
 244                         }
 245                 }
 246
 247                 else if(rc == POPT_ERROR_BADOPT && i != first_arg) {
 248                         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
 249                                         "Option %s not recognized, rescan options with new additions",
 250                 poptBadOption(c,0));
 251
 252                         /* Perhaps this option is newly added, restart parsing */
 253
 254                         destroy_popts(&list, &popts, &c);
 255                         build_popts(&list, &popts, &c, argc, argv);
 256
 257                         /* Get back to the same argument */
 258
 259                         first_arg = i;
 260                         for(i = 0; i < first_arg; i++) {
 261                                 rc = poptGetNextOpt(c);
 262                                 option = (LttvOption *)(list->pdata[rc - 1]);
 263                                 g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s rescanned, skipped",
 264                                                 option->long_name);
 265                         }
 266                 }
 267
 268                 else {
 269
 270                         /* The option has some error and it is not because this is a newly
 271                            added option not recognized. */
 272
 273                         g_error("option %s: %s", poptBadOption(c,0), poptStrerror(rc));
 274                         break;
 275                 }
 276
 277         }
 278
 279         destroy_popts(&list, &popts, &c);
 280 }
 281
 282 /* CHECK */
 283 static void show_help(LttvOption *option)
 284 {
 285         printf("--%s  -%c  argument: %s\n" , option->long_name,
 286                         option->char_name, option->arg_description);
 287         printf("                     %s\n" , option->description);
 288
 289 }
 290
 291 void lttv_option_show_help(void)
 292 {
 293         GPtrArray *list = g_ptr_array_new();
 294
 295         guint i;
 296
 297         g_hash_table_foreach(options, list_options, list);
 298
 299         printf("Built-in commands available:\n");
 300         printf("\n");
 301
 302         for(i = 0 ; i < list->len ; i++) {
 303                 show_help((LttvOption *)list->pdata[i]);
 304         }
 305         g_ptr_array_free(list, TRUE);
 306 }
 307
 308 static void init()
 309 {
 310         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Init option.c");
 311         options = g_hash_table_new(g_str_hash, g_str_equal);
 312 }
 313
 314
 315 static void destroy()
 316 {
 317         GPtrArray *list = g_ptr_array_new();
 318
 319         guint i;
 320
 321         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Destroy option.c");
 322         g_hash_table_foreach(options, list_options, list);
 323         g_hash_table_destroy(options);
 324
 325         for(i = 0 ; i < list->len ; i++) {
 326                 free_option((LttvOption *)list->pdata[i]);
 327         }
 328         g_ptr_array_free(list, TRUE);
 329 }
 330
 331 LTTV_MODULE("option", "Command line options processing", \
 332                 "Functions to add, remove and parse command line options", \
 333                 init, destroy)