[lttv.git] / tags / lttv-0.10.0-pre15-12082008 / lttv / lttv / option.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Michel Dagenais
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
 * MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <popt.h>
#include <glib.h>
#include <lttv/module.h>
#include <lttv/option.h>

typedef struct _LttvOption {
  char *long_name;
  char char_name;
  char *description;
  char *arg_description;
  LttvOptionType t;
  gpointer p;
  LttvOptionHook hook;
  gpointer hook_data;

  /* Keep the order of addition */
  guint val;
} LttvOption;

GHashTable *options;


static void
list_options(gpointer key, gpointer value, gpointer user_data)
{
  GPtrArray *list = (GPtrArray *)user_data;
  LttvOption *option = (LttvOption *)value;

  if(list->len < option->val)
    g_ptr_array_set_size(list, option->val);
  list->pdata[option->val-1] = option;
}


static void
free_option(LttvOption *option)
{
  g_free(option->long_name);
  g_free(option->description);
  g_free(option->arg_description);
  g_free(option);
}


void lttv_option_add(const char *long_name, const char char_name,
    const char *description, const char *arg_description,
    const LttvOptionType t, void *p,
    const LttvOptionHook h, void *hook_data)
{
  LttvOption *option;

  g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Add option %s", long_name);
  if(g_hash_table_lookup(options, long_name) != NULL) {
    g_warning("duplicate option");
    return;
  }

  option = g_new(LttvOption, 1);
  option->long_name = g_strdup(long_name);
  option->char_name = char_name;
  option->description = g_strdup(description);
  option->arg_description = g_strdup(arg_description);
  option->t = t;
  option->p = p;
  option->hook = h;
  option->hook_data = hook_data;
  option->val = g_hash_table_size(options) + 1;
  g_hash_table_insert(options, option->long_name, option);
}


void 
lttv_option_remove(const char *long_name) 
{
  LttvOption *option = g_hash_table_lookup(options, long_name);

  g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Remove option %s", long_name);
  if(option == NULL) {
    g_warning("trying to remove unknown option %s", long_name);
    return;
  }
  g_hash_table_remove(options, long_name);
  free_option(option);
}


static int poptToLTT[] = { 
  POPT_ARG_NONE, POPT_ARG_STRING, POPT_ARG_INT, POPT_ARG_LONG
};

static struct poptOption endOption = { NULL, '\0', 0, NULL, 0, NULL, NULL };


static void 
build_popts(GPtrArray **plist, struct poptOption **ppopts, poptContext *pc,
    int argc, char **argv)
{
  LttvOption *option;

  GPtrArray *list;

  struct poptOption *popts;

  poptContext c;

  guint i;

  list = g_ptr_array_sized_new(g_hash_table_size(options));

  g_hash_table_foreach(options, list_options, list);

  /* Build a popt options array from our list */

  popts = g_new(struct poptOption, list->len + 1);

  /* add the options in the reverse order, so last additions are parsed first */
  for(i = 0 ; i < list->len ; i++) {
    guint reverse_i = list->len-1-i;
    option = (LttvOption *)list->pdata[i];
    popts[reverse_i].longName = option->long_name;
    popts[reverse_i].shortName = option->char_name;
    popts[reverse_i].descrip = option->description;
    popts[reverse_i].argDescrip = option->arg_description;
    popts[reverse_i].argInfo = poptToLTT[option->t];
    popts[reverse_i].arg = option->p;
    popts[reverse_i].val = option->val;
  }

  /* Terminate the array for popt and create the context */

  popts[list->len] = endOption;
  c = poptGetContext(argv[0], argc, (const char**)argv, popts, 0);

  *plist = list;
  *ppopts = popts;
  *pc = c;
}


static void 
destroy_popts(GPtrArray **plist, struct poptOption **ppopts, poptContext *pc)
{
  g_ptr_array_free(*plist, TRUE); *plist = NULL;
  g_free(*ppopts); *ppopts = NULL;
  poptFreeContext(*pc);  
}


void lttv_option_parse(int argc, char **argv)
{
  GPtrArray *list;

  LttvOption *option;

  int i, rc, first_arg;

  struct poptOption *popts;

  poptContext c;

  i = 0;

  first_arg = 0;

  guint hash_size = 0;

  build_popts(&list, &popts, &c, argc, argv);

  /* Parse options while not end of options event */

  while((rc = poptGetNextOpt(c)) != -1) {

    /* The option was recognized and the rc value returned is the argument
       position in the array. Call the associated hook if present. */
  
    if(rc > 0) {
      option = (LttvOption *)(list->pdata[rc - 1]);
      g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Option %s encountered", 
          option->long_name);
      hash_size = g_hash_table_size(options);
      if(option->hook != NULL) { 
        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s hook called", 
            option->long_name);
        option->hook(option->hook_data);
      }
      i++;

      /* If the size of the option hash changed, add new options
       * right now. It resolves the conflict of multiple same short
       * option use.
       */
      if(hash_size != g_hash_table_size(options)) {
        destroy_popts(&list, &popts, &c);
        build_popts(&list, &popts, &c, argc, argv);

        /* Get back to the same argument */

        first_arg = i;
        for(i = 0; i < first_arg; i++) {
          rc = poptGetNextOpt(c);
          option = (LttvOption *)(list->pdata[rc - 1]);
          g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s rescanned, skipped",
              option->long_name);
        }
      }
    } 

    else if(rc == POPT_ERROR_BADOPT && i != first_arg) {
      g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, 
          "Option %s not recognized, rescan options with new additions",
	  poptBadOption(c,0));

      /* Perhaps this option is newly added, restart parsing */

      destroy_popts(&list, &popts, &c);
      build_popts(&list, &popts, &c, argc, argv);

      /* Get back to the same argument */

      first_arg = i;
      for(i = 0; i < first_arg; i++) {
        rc = poptGetNextOpt(c);
        option = (LttvOption *)(list->pdata[rc - 1]);
        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s rescanned, skipped",
            option->long_name);
      }
    }

    else {

      /* The option has some error and it is not because this is a newly
         added option not recognized. */

      g_error("option %s: %s", poptBadOption(c,0), poptStrerror(rc));
      break;
    }
    
  }

  destroy_popts(&list, &popts, &c);
}

/* CHECK */
static void show_help(LttvOption *option)
{
  printf("--%s  -%c  argument: %s\n" , option->long_name,
																			option->char_name,
																			option->arg_description);
  printf("                     %s\n" , option->description);

}

void lttv_option_show_help(void)
{
  GPtrArray *list = g_ptr_array_new();

  guint i;

  g_hash_table_foreach(options, list_options, list);

	printf("Built-in commands available:\n");
	printf("\n");

  for(i = 0 ; i < list->len ; i++) {
    show_help((LttvOption *)list->pdata[i]);
  }
  g_ptr_array_free(list, TRUE);
}

static void init()
{
  g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Init option.c");
  options = g_hash_table_new(g_str_hash, g_str_equal);
}


static void destroy()
{
  GPtrArray *list = g_ptr_array_new();

  guint i;

  g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Destroy option.c");
  g_hash_table_foreach(options, list_options, list);
  g_hash_table_destroy(options);

  for(i = 0 ; i < list->len ; i++) {
    free_option((LttvOption *)list->pdata[i]);
  }
  g_ptr_array_free(list, TRUE);
}

LTTV_MODULE("option", "Command line options processing", \
    "Functions to add, remove and parse command line options", \
    init, destroy)
Commit	Line	Data
5750899b	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
	46	list_options(gpointer key, gpointer value, gpointer user_data)
	47	{
	48	GPtrArray list = (GPtrArray )user_data;
	49	LttvOption option = (LttvOption )value;
	50
	51	if(list->len < option->val)
	52	g_ptr_array_set_size(list, option->val);
	53	list->pdata[option->val-1] = option;
	54	}
	55
	56
	57	static void
	58	free_option(LttvOption *option)
	59	{
	60	g_free(option->long_name);
	61	g_free(option->description);
	62	g_free(option->arg_description);
	63	g_free(option);
	64	}
65
66
67	void lttv_option_add(const char *long_name, const char char_name,
68	const char description, const char arg_description,
69	const LttvOptionType t, void *p,
70	const LttvOptionHook h, void *hook_data)
71	{
72	LttvOption *option;
73
74	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Add option %s", long_name);
75	if(g_hash_table_lookup(options, long_name) != NULL) {
76	g_warning("duplicate option");
77	return;
78	}
79
80	option = g_new(LttvOption, 1);
81	option->long_name = g_strdup(long_name);
82	option->char_name = char_name;
83	option->description = g_strdup(description);
84	option->arg_description = g_strdup(arg_description);
85	option->t = t;
86	option->p = p;
87	option->hook = h;
88	option->hook_data = hook_data;
89	option->val = g_hash_table_size(options) + 1;
90	g_hash_table_insert(options, option->long_name, option);
91	}
92
93
94	void
95	lttv_option_remove(const char *long_name)
96	{
97	LttvOption *option = g_hash_table_lookup(options, long_name);
98
99	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Remove option %s", long_name);
100	if(option == NULL) {
101	g_warning("trying to remove unknown option %s", long_name);
102	return;
103	}
104	g_hash_table_remove(options, long_name);
105	free_option(option);
106	}
107
108
109	static int poptToLTT[] = {
110	POPT_ARG_NONE, POPT_ARG_STRING, POPT_ARG_INT, POPT_ARG_LONG
111	};
112
113	static struct poptOption endOption = { NULL, '\0', 0, NULL, 0, NULL, NULL };
114
115
116	static void
117	build_popts(GPtrArray plist, struct poptOption ppopts, poptContext *pc,
118	int argc, char **argv)
119	{
120	LttvOption *option;
121
122	GPtrArray *list;
123
124	struct poptOption *popts;
125
126	poptContext c;
127
128	guint i;
129
130	list = g_ptr_array_sized_new(g_hash_table_size(options));
131
132	g_hash_table_foreach(options, list_options, list);
133
134	/* Build a popt options array from our list */
135
136	popts = g_new(struct poptOption, list->len + 1);
137
138	/* add the options in the reverse order, so last additions are parsed first */
139	for(i = 0 ; i < list->len ; i++) {
140	guint reverse_i = list->len-1-i;
141	option = (LttvOption *)list->pdata[i];
142	popts[reverse_i].longName = option->long_name;
143	popts[reverse_i].shortName = option->char_name;
144	popts[reverse_i].descrip = option->description;
145	popts[reverse_i].argDescrip = option->arg_description;
146	popts[reverse_i].argInfo = poptToLTT[option->t];
147	popts[reverse_i].arg = option->p;
148	popts[reverse_i].val = option->val;
149	}
150
151	/* Terminate the array for popt and create the context */
152
153	popts[list->len] = endOption;
154	c = poptGetContext(argv[0], argc, (const char**)argv, popts, 0);
155
156	*plist = list;
157	*ppopts = popts;
158	*pc = c;
159	}
160
161
162	static void
163	destroy_popts(GPtrArray plist, struct poptOption ppopts, poptContext *pc)
164	{
165	g_ptr_array_free(plist, TRUE); plist = NULL;
166	g_free(ppopts); ppopts = NULL;
167	poptFreeContext(*pc);
168	}
169
170
171	void lttv_option_parse(int argc, char **argv)
172	{
173	GPtrArray *list;
174
175	LttvOption *option;
176
177	int i, rc, first_arg;
178
179	struct poptOption *popts;
180
181	poptContext c;
182
183	i = 0;
184
185	first_arg = 0;
186
187	guint hash_size = 0;
188
189	build_popts(&list, &popts, &c, argc, argv);
190
191	/* Parse options while not end of options event */
192
193	while((rc = poptGetNextOpt(c)) != -1) {
194
195	/* The option was recognized and the rc value returned is the argument
196	position in the array. Call the associated hook if present. */
197
198	if(rc > 0) {
199	option = (LttvOption *)(list->pdata[rc - 1]);
200	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Option %s encountered",
201	option->long_name);
202	hash_size = g_hash_table_size(options);
203	if(option->hook != NULL) {
204	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s hook called",
205	option->long_name);
206	option->hook(option->hook_data);
207	}
208	i++;
209
210	/* If the size of the option hash changed, add new options
211	* right now. It resolves the conflict of multiple same short
212	* option use.
213	*/
214	if(hash_size != g_hash_table_size(options)) {
215	destroy_popts(&list, &popts, &c);
216	build_popts(&list, &popts, &c, argc, argv);
217
218	/* Get back to the same argument */
219
220	first_arg = i;
221	for(i = 0; i < first_arg; i++) {
222	rc = poptGetNextOpt(c);
223	option = (LttvOption *)(list->pdata[rc - 1]);
224	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s rescanned, skipped",
225	option->long_name);
226	}
227	}
228	}
229
230	else if(rc == POPT_ERROR_BADOPT && i != first_arg) {
231	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
232	"Option %s not recognized, rescan options with new additions",
233	poptBadOption(c,0));
234
235	/* Perhaps this option is newly added, restart parsing */
236
237	destroy_popts(&list, &popts, &c);
238	build_popts(&list, &popts, &c, argc, argv);
239
240	/* Get back to the same argument */
241
242	first_arg = i;
243	for(i = 0; i < first_arg; i++) {
244	rc = poptGetNextOpt(c);
245	option = (LttvOption *)(list->pdata[rc - 1]);
246	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Option %s rescanned, skipped",
247	option->long_name);
248	}
249	}
250
251	else {
252
253	/* The option has some error and it is not because this is a newly
254	added option not recognized. */
255
256	g_error("option %s: %s", poptBadOption(c,0), poptStrerror(rc));
257	break;
258	}
259
260	}
261
262	destroy_popts(&list, &popts, &c);
263	}
264
265	/* CHECK */
266	static void show_help(LttvOption *option)
267	{
268	printf("--%s -%c argument: %s\n" , option->long_name,
269	option->char_name,
270	option->arg_description);
271	printf(" %s\n" , option->description);
272
273	}
274
275	void lttv_option_show_help(void)
276	{
277	GPtrArray *list = g_ptr_array_new();
278
279	guint i;
280
281	g_hash_table_foreach(options, list_options, list);
282
283	printf("Built-in commands available:\n");
284	printf("\n");
285
286	for(i = 0 ; i < list->len ; i++) {
287	show_help((LttvOption *)list->pdata[i]);
288	}
289	g_ptr_array_free(list, TRUE);
290	}
291
292	static void init()
293	{
294	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Init option.c");
295	options = g_hash_table_new(g_str_hash, g_str_equal);
296	}
297
298
299	static void destroy()
300	{
301	GPtrArray *list = g_ptr_array_new();
302
303	guint i;
304
305	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "Destroy option.c");
306	g_hash_table_foreach(options, list_options, list);
307	g_hash_table_destroy(options);
308
309	for(i = 0 ; i < list->len ; i++) {
310	free_option((LttvOption *)list->pdata[i]);
311	}
312	g_ptr_array_free(list, TRUE);
313	}
314
315	LTTV_MODULE("option", "Command line options processing", \
316	"Functions to add, remove and parse command line options", \
317	init, destroy)