Newsgroup: it.comp.os.linux.development
Titolo: limiti di argv

ciao a tutti
sto scrivendo un programmino tipo dialog,
ma in gtk, e durante una sessione di test mi sono imbattuto
in un "segmentation fault" strano,
con argomenti brevi passati sulla linea di comando tutto fila liscio
con argomenti lunghi niente, seg fault.
esempio
questo va in segmentation fault
# gtdialog --title "pippo va in vacanza" --gtmenu "testo che appare 
sopra il menu" "prima voce del menu" "questa voce del menu serve da 
esempio lungo che causa il seg fault"
questo no
# gtdialog --title "pippo" --gtmenu "descrizione menu" "voce 1" 
"descrizione voce1"
ho setacciato il codice col gdb è ho scpoerto che l'errore avviene
nella funzione mallopt della libc il tutto in una routine del gtk
per creare la finestra principale del programma.
per caso ci sono dei limiti con argc e argv e io non ne so niente?
bye bye

 con argomenti lunghi niente, seg fault.
Se non fai vedere il codice, non è che noi ti si possa dare una mano.
Non è che stai facendo dei test che assumono il contenuto di argv come
non nullo, e non te ne sei accorto?
Ciao,
 Emmanuele.
-- 
Emmanuele Bassi (Zefram)       [ 
http://digilander.libero.it/ebassi/blog
 ]
GnuPG Key fingerprint = 4DD0 C90D 4070 F071 5738  08BD 8ECC DB8F A432 0FF4

 non nullo, e non te ne sei accorto?
no no, il contenuto dei puntatori e perfettamente lecito,
come ho detto ho controllato il codice linea per linea col
gdb verificando il contenuto delle variabili.
ecco il codice, le sezioni interessate sono incorniciate.
file gtdialog.c opprtunamente accorciato.
#include <gtk/gtk.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include "gtdialog.h"
struct gtdialog_context  *gtcontext;
int exit_status; /* 0 = normal output availlable on stdout, 1 = cancell, 
no output
		    128 = various program exception, check stderr, 255 = window has 
closed, no output
		 */
void print_help(){
   printf("this is the help\n");
}
/************  Generic event handler *************/
void
on_gt_generic_window_destroy              (GtkObject       *object,
                                         gpointer         user_data)
{
   gtk_main_quit();
   exit_status = 255;
}
void
on_gt_generic_cancel_button_clicked       (GtkButton       *button,
                                         gpointer         user_data)
{
   gtk_main_quit();
   exit_status = 1;
}
void
on_gt_generic_help_button_clicked         (GtkButton       *button,
                                         gpointer         user_data)
{
   gtk_widget_show(GTK_WIDGET(create_gt_help_window()));
}
/********************************************************************/
/* if malloc fail exit with exitcode 128 */
void  *mymalloc(unsigned int  nbytes)
{
   void  *ptr;
   ptr = malloc(nbytes);
   if (!ptr){
     fprintf(stderr, "Error: No availlable memory\n");
     exit(128);
   }
   return ptr;
}
int isopt(char  *str)
{
   char *gtargs[]={"--gtedit", "--gtfilechoser", "--gtinputbox", 
"--gtlist", "--gtmenu", "--gtmsgbox",
		   "--gtpasswordbox", "--gtyesno", "--file", "--help", "--size", 
"--tofd", "--title",
		   ""};
   int i=0;
   while(strlen(gtargs[i])){
     if (strcmp(gtargs[i], str) == 0)
       return 1;
     i++;
   }
   return 0;
}
/* command line parser, for each option on command line fill the right
field of gtdialog_context */
int handle_opts(struct gtdialog_context *ctx, int argc, char *argv[], int c)
{
   gchar  *tmp_ptr;
   int  count;
   if (strcmp("--file", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for --file.\nUse 
--help to list options.\n"));
       exit(128);
     }else{
       ctx -> filename = g_malloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> filename, argv[c+1]);
       return c+2;
     }
   }else if (strcmp("--title", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for --title.\nUse 
--help to list options.\n"));
       exit(128);
     }else{
       ctx -> title = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> title, argv[c+1]);
       return c+2;
     }
   }else if (strcmp("--tofd", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for --tofd.\nUse 
--help to list options.\n"));
       exit(128);
     }else{
       ctx -> outfd = strtol(argv[c+1], NULL, 10);
       if (errno==EINVAL || ctx -> outfd < 0){
	fprintf(stderr, _("Error: Expected 1 integer for --tofd.\nUse --help to 
list options.\n"));
	exit(128);
       }
       return c+2;
     }
   }else if (strcmp("--help", argv[c]) == 0){
     print_help();
     exit(0);
   }else if (strcmp("--size", argv[c]) == 0){
     if (c+2 >=  argc || isopt(argv[c+1]) || isopt(argv[c+2])){
       fprintf(stderr, _("Error: Expected 2 token for --size.\nUse 
--help to list options.\n"));
       exit(128);
     }else{
       ctx -> xsize = strtol(argv[c+1], NULL, 10);
       if (errno==EINVAL || ctx -> xsize < 0){
	fprintf(stderr, _("Error: Expected 2 integer for --size.\nUse --help to 
list options.\n"));
	exit(128);
       }
       ctx -> ysize = strtol(argv[c+2], NULL, 10);
       if (errno==EINVAL || ctx -> ysize < 0){
	fprintf(stderr, _("Error: Expected 2 integer for --size.\nUse --help to 
list options.\n"));
	exit(128);
       }
       return c+3;
     }
   }if (strcmp("--gtfilechoser", argv[c]) == 0){
     if (c+1 <  argc && !isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 0 token for 
--gtfilechoser.\nUse --help to list options.\n"));
       exit(128);
     }else{
       ctx -> mode = gtfilechoser;
       return c+1;
     }
   }else if (strcmp("--gtedit", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for --gtedit.\nUse 
--help to list options.\n"));
       exit(128);
     }else{
       ctx -> text = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> text, argv[c+1]);
       ctx -> mode = gtedit;
       return c+2;
     }
   }else if (strcmp("--gtinputbox", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 or 2 token for 
--gtinputbox.\nUse --help to list options.\n"));
       exit(128);
     }else{
       ctx -> text = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> text, argv[c+1]);
       ctx -> mode = gtinputbox;
       if (c+2 < argc && !isopt(argv[c+2])){
	if (ctx -> list != NULL){
	  g_slist_free(ctx -> list);
	}
	tmp_ptr = mymalloc(strlen(argv[c+2]) + 1);
	strcpy(tmp_ptr, argv[c+2]);
	ctx -> list = g_slist_append(ctx -> list, tmp_ptr);
	return c+3;
       }
       return c+2;
     }
   }else if (strcmp("--gtmsgbox", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for --gtmsgbox.\nUse 
--help to list options.\n"));
       exit(128);
     }else{
       ctx -> text = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> text, argv[c+1]);
       ctx -> mode = gtmsgbox;
       return c+2;
     }
   }else if (strcmp("--gtpasswordbox", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for 
--gtpasswordbox.\nUse --help to list options.\n"));
       exit(128);
     }else{
       ctx -> text = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> text, argv[c+1]);
       ctx -> mode = gtpasswordbox;
       return c+2;
     }
   }else if (strcmp("--gtyesno", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for --gtyesno.\nUse 
--help to list options.\n"));
       exit(128);
     }else{
       ctx -> text = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> text, argv[c+1]);
       ctx -> mode = gtyesno;
       return c+2;
     }
   }else if (strcmp("--gthelp", argv[c]) == 0){
     if (c+1 >=  argc || isopt(argv[c+1])){
       fprintf(stderr, _("Error: Expected 1 token for --gthelp.\nUse 
--help to list options."));
       exit(128);
     }else{
       ctx -> help = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> help, argv[c+1]);
       return c+2;
     }
   }else if (strcmp("--gtlist", argv[c]) == 0){
     if (c+2 >=  argc || isopt(argv[c+1]) || isopt(argv[c+2])){
       fprintf(stderr, _("Error: Expected at least 2 token for 
--gtlist.\nUse --help to list options.\n"));
       exit(128);
     }else{
       ctx -> text = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> text, argv[c+1]);
       if (ctx -> list != NULL){
	g_slist_free(ctx -> list);
       }
       count = c+2;
       while (count < argc && !isopt(argv[count])){
	tmp_ptr = mymalloc(strlen(argv[count] + 1));
	strcpy(tmp_ptr, argv[count]);
	ctx -> list = g_slist_append(ctx -> list, tmp_ptr);
	count++;
       }
       ctx -> mode = gtlist;
       return count;
     }
/***********************************************************
qui parserizza l'opzione --gtmenu sulla linea di comando,
la quale ha un numero variabile di argomenti.
--gtmenu [text] [voce1] [descrizione1] [voce2] [descrizione2] . . .
   }else if (strcmp("--gtmenu", argv[c]) == 0){
     if ( c+3 >=  argc || isopt(argv[c+1]) || isopt(argv[c+2]) || 
isopt(argv[c+3]) ){
       fprintf(stderr, _("Error: Expected at least 3 token for 
--gtmenu.\nUse --help to list options.\n"));
       exit(128);
     }else{
       ctx -> text = mymalloc(strlen(argv[c+1]) + 1);
       strcpy(ctx -> text, argv[c+1]);
       if (ctx -> list != NULL){
	g_slist_free(ctx -> list);
       }
       count = c+2;
       while (count < argc && !isopt(argv[count])){
	tmp_ptr = mymalloc(strlen(argv[count] + 1));
	strcpy(tmp_ptr, argv[count]);
	ctx -> list = g_slist_append(ctx -> list, tmp_ptr);
	count++;
       }
       if ((count - c + 2) % 2){
	fprintf(stderr, _("Error: Expected n*2 token for --gtmenu.\nUse --help 
to list options.\n"));
	exit(128);
       }
       ctx -> mode = gtmenu;
       return count;
     }
*************************************************************/
   }
}
struct gtdialog_context  *create_gtdialog_context(int argc, char *argv[])
{
   struct gtdialog_context  *ctx;
   int count = 1, ret;
   ctx = (struct gtdialog_context *)mymalloc(sizeof(struct 
gtdialog_context));
   memset(ctx, 0, sizeof(struct gtdialog_context));
   while (count < argc){
     ret = isopt(argv[count]);
     if (ret)
       count = handle_opts(ctx, argc, argv, count);
     else{
       fprintf(stderr, "Error: Unexpected token '%s' on command line", 
argv[count]);
       exit(128);
     }
   }
   gtcontext = ctx;
   switch(ctx -> mode){
   case gtedit:
     ctx -> window = create_gt_edit_window();
     break;
   case gtfilechoser:
     ctx -> window = create_gt_filechoser_window();
     break;
   case gtinputbox:
     ctx -> window = create_gt_inputbox_window();
     break;
   case gtlist:
     ctx -> window = create_gt_list_window();
     break;
   case gtmenu:
     ctx -> window = create_gt_menu_window();
     break;
   case gtmsgbox:
     ctx -> window = create_gt_msgbox_window();
     break;
   case gtpasswordbox:
     ctx -> window = create_gt_passwordbox_window();
     break;
   case gtyesno:
     ctx -> window = create_gt_yesno_window();
     break;
   default:
     fprintf(stderr, _("Error: Expected gtdialog mode\n"));
     exit(128);
     break;
   }
   if (ctx -> outfd = 0)
     ctx -> outfd = 1;
   return ctx;
}
int
main (int argc, char *argv[])
{
   gtk_set_locale ();
   gtk_init (&argc, &argv);
   gtcontext = create_gtdialog_context(argc, argv);
   gtk_widget_show(gtcontext -> window);
   gtk_main ();
   return exit_status;
}

Emmanuele Bassi wrote:
 > * lucriz [2003-10-09 23:42]:
 >
 >
 >> ma in gtk, e durante una sessione di test mi sono imbattuto
 >> in un "segmentation fault" strano,
 >> con argomenti brevi passati sulla linea di comando tutto fila liscio
 >> con argomenti lunghi niente, seg fault.
 >
 >
 >
 > Se non fai vedere il codice, non è che noi ti si possa dare una mano.
 >
 > Non è che stai facendo dei test che assumono il contenuto di argv come
 > non nullo, e non te ne sei accorto?
ho postato per sbaglio un reply incompleto.
ecco quello completo.
no no, il contenuto dei puntatori e perfettamente lecito,
come ho detto ho controllato il codice linea per linea col
gdb verificando il contenuto delle variabili.
ecco il codice, le sezioni interessate sono incorniciate.
file gtdialog.c opportunamente accorciato.
#include <gtk/gtk.h>





   gtk_main_quit();
   exit_status = 255;
}

   gtk_main_quit();
   exit_status = 1;
}

   gtk_widget_show(GTK_WIDGET(create_gt_help_window()));
}
/********************************************************************/

{
   void  *ptr;
   ptr = malloc(nbytes);

   return ptr;
}
int isopt(char  *str)
{


   return 0;
}


{
   gchar  *tmp_ptr;
   int  count;



   }
}

{








/**********************************************
qui in base al tipo di dialog scelto chiama il costruttore
per quel dialog (in un altro file allegato di seguito)
   case gtmenu:
     ctx -> window = create_gt_menu_window();
     break;
**************************************************/
   case gtmsgbox:
     ctx -> window = create_gt_msgbox_window();
     break;
   case gtpasswordbox:
     ctx -> window = create_gt_passwordbox_window();
     break;
   case gtyesno:
     ctx -> window = create_gt_yesno_window();
     break;
   default:
     fprintf(stderr, _("Error: Expected gtdialog mode\n"));
     exit(128);
     break;
   }
   if (ctx -> outfd = 0)
     ctx -> outfd = 1;
   return ctx;
}
int
main (int argc, char *argv[])
{
   gtk_set_locale ();
   gtk_init (&argc, &argv);
   gtcontext = create_gtdialog_context(argc, argv);
   gtk_widget_show(gtcontext -> window);
   gtk_main ();
   return exit_status;
}
#####################################################
####################################################
file gtmenu.c in cui si presenta l'errore
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include "gtdialog.h"
int  selected_row;
void
on_gt_menu_ok_button_clicked           (GtkButton       *button,
                                         gpointer         user_data)
{
   gchar  *text;
   text = g_malloc(256);
   if (selected_row >= 0){
     gtk_clist_get_text(GTK_CLIST(user_data), selected_row, 0, &text);
     write(gtcontext -> outfd, text, strlen(text));
     gtk_main_quit();
     exit_status = 0;
   }else{
     on_gt_generic_cancel_button_clicked(NULL, NULL);
   }
}
void
on_gt_menu_list_select_row             (GtkCList        *clist,
                                         gint             row,
                                         gint             column,
                                         GdkEvent        *event,
                                         gpointer         user_data)
{
   selected_row = row;
}
void
on_gt_menu_list_unselect_row           (GtkCList        *clist,
                                         gint             row,
                                         gint             column,
                                         GdkEvent        *event,
                                         gpointer         user_data)
{
   selected_row = -1;
}
GtkWidget*
create_gt_menu_window (void)
{
   GtkWidget *gt_menu_window;
   GtkWidget *vbox1;
   GtkWidget *hbox1;
   GtkWidget *gt_menu_ok_button;
   GtkWidget *gt_menu_cancel_button;
   GtkWidget *gt_menu_help_button;
   GtkWidget *gt_menu_text;
   GtkWidget *hseparator2;
   GtkWidget *scrolledwindow1;
   GtkWidget *gt_menu_list;
   GtkWidget *gt_menu_column1;
   GtkWidget *gt_menu_column2;
   GtkWidget *hseparator1;
   GSList  *ptr;
   gchar  *list[2];
   selected_row = -1;
/*********************************************************
l'errore avviene qui, apparentemente non c'è nessun riferimento
ad argc ed argv
   gt_menu_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
*********************************************************/
   gtk_object_set_data (GTK_OBJECT (gt_menu_window), "gt_menu_window", 
gt_menu_window);
   gtk_window_set_title (GTK_WINDOW (gt_menu_window), gtcontext -> title);
   if (gtcontext -> xsize > 32 && gtcontext -> ysize > 32)
     gtk_window_set_default_size (GTK_WINDOW (gt_menu_window), gtcontext 
-> xsize, gtcontext -> ysize);
   else
     gtk_window_set_default_size (GTK_WINDOW (gt_menu_window), 450, 300);
   vbox1 = gtk_vbox_new (FALSE, 0);
   gtk_widget_ref (vbox1);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), "vbox1", vbox1,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (vbox1);
   gtk_container_add (GTK_CONTAINER (gt_menu_window), vbox1);
   hbox1 = gtk_hbox_new (FALSE, 50);
   gtk_widget_ref (hbox1);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), "hbox1", hbox1,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (hbox1);
   gtk_box_pack_end (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
   gtk_container_set_border_width (GTK_CONTAINER (hbox1), 15);
   gt_menu_ok_button = gtk_button_new_with_label (_("Ok"));
   gtk_widget_ref (gt_menu_ok_button);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"gt_menu_ok_button", gt_menu_ok_button,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (gt_menu_ok_button);
   gtk_box_pack_start (GTK_BOX (hbox1), gt_menu_ok_button, TRUE, TRUE, 0);
   gt_menu_cancel_button = gtk_button_new_with_label (_("Cancel"));
   gtk_widget_ref (gt_menu_cancel_button);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"gt_menu_cancel_button", gt_menu_cancel_button,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (gt_menu_cancel_button);
   gtk_box_pack_start (GTK_BOX (hbox1), gt_menu_cancel_button, TRUE, 
TRUE, 0);
   gt_menu_help_button = gtk_button_new_with_label (_("Help"));
   gtk_widget_ref (gt_menu_help_button);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"gt_menu_help_button", gt_menu_help_button,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (gt_menu_help_button);
   gtk_box_pack_start (GTK_BOX (hbox1), gt_menu_help_button, TRUE, TRUE, 0);
   gt_menu_text = gtk_label_new (gtcontext -> text);
   gtk_widget_ref (gt_menu_text);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"gt_menu_text", gt_menu_text,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (gt_menu_text);
   gtk_box_pack_start (GTK_BOX (vbox1), gt_menu_text, FALSE, FALSE, 0);
   hseparator2 = gtk_hseparator_new ();
   gtk_widget_ref (hseparator2);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), "hseparator2", 
hseparator2,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (hseparator2);
   gtk_box_pack_start (GTK_BOX (vbox1), hseparator2, FALSE, FALSE, 6);
   scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
   gtk_widget_ref (scrolledwindow1);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"scrolledwindow1", scrolledwindow1,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (scrolledwindow1);
   gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0);
   gt_menu_list = gtk_clist_new (2);
   gtk_widget_ref (gt_menu_list);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"gt_menu_list", gt_menu_list,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (gt_menu_list);
   for (ptr = gtcontext -> list ; ptr != NULL ; ptr = ptr -> next){
     list[0] = (gchar *)ptr -> data;
     ptr = ptr -> next;
     list[1] = (gchar *)ptr -> data;
     gtk_clist_append(GTK_CLIST(gt_menu_list), list);
   }
   gtk_container_add (GTK_CONTAINER (scrolledwindow1), gt_menu_list);
   gtk_clist_set_column_width (GTK_CLIST (gt_menu_list), 0, 136);
   gtk_clist_set_column_width (GTK_CLIST (gt_menu_list), 1, 80);
   gtk_clist_set_selection_mode(GTK_CLIST (gt_menu_list), 
GTK_SELECTION_SINGLE);
   gtk_clist_column_titles_show (GTK_CLIST (gt_menu_list));
   gt_menu_column1 = gtk_label_new (_("Action"));
   gtk_widget_ref (gt_menu_column1);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"gt_menu_column1", gt_menu_column1,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (gt_menu_column1);
   gtk_clist_set_column_widget (GTK_CLIST (gt_menu_list), 0, 
gt_menu_column1);
   gt_menu_column2 = gtk_label_new (_("Description"));
   gtk_widget_ref (gt_menu_column2);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), 
"gt_menu_column2", gt_menu_column2,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (gt_menu_column2);
   gtk_clist_set_column_widget (GTK_CLIST (gt_menu_list), 1, 
gt_menu_column2);
   hseparator1 = gtk_hseparator_new ();
   gtk_widget_ref (hseparator1);
   gtk_object_set_data_full (GTK_OBJECT (gt_menu_window), "hseparator1", 
hseparator1,
                             (GtkDestroyNotify) gtk_widget_unref);
   gtk_widget_show (hseparator1);
   gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, FALSE, FALSE, 5);
   gtk_signal_connect (GTK_OBJECT (gt_menu_window), "destroy",
                       GTK_SIGNAL_FUNC (on_gt_generic_window_destroy),
                       NULL);
   gtk_signal_connect (GTK_OBJECT (gt_menu_ok_button), "clicked",
                       GTK_SIGNAL_FUNC (on_gt_menu_ok_button_clicked),
                       gt_menu_list);
   gtk_signal_connect (GTK_OBJECT (gt_menu_cancel_button), "clicked",
                       GTK_SIGNAL_FUNC 
(on_gt_generic_cancel_button_clicked),
                       NULL);
   gtk_signal_connect (GTK_OBJECT (gt_menu_help_button), "clicked",
                       GTK_SIGNAL_FUNC (on_gt_generic_help_button_clicked),
                       NULL);
   gtk_signal_connect (GTK_OBJECT (gt_menu_list), "select_row",
                       GTK_SIGNAL_FUNC (on_gt_menu_list_select_row),
                       NULL);
   gtk_signal_connect (GTK_OBJECT (gt_menu_list), "unselect_row",
                       GTK_SIGNAL_FUNC (on_gt_menu_list_unselect_row),
                       NULL);
   return gt_menu_window;
}

 ecco quello completo.
1. Io non ho mai chiesto l'intero codice.
2. Tu mandi 1000+ linee di testo sul gruppo?
3. Taglia, riadatta e *forse* ci si può pensare a darti una mano.


 3. Taglia, riadatta e *forse* ci si può pensare a darti una mano.
forse ho esagerato un tantino, perdonatemi
cmunque il codice intero e per ora 1800 linee
in 22 file, quello che ho postato erano solo i 2
file interessati.
credo che quanto prima sposto tutto su sourceforge
cosi magari qualcuno mi da una mano e magari ne esce fuori qualcosa di 
utile.
ecco il riassunto
int isopt(char  *str)
{
   char *gtargs[]={"--gtedit", "--gtfilechoser", "--gtinputbox", 
"--gtlist", "--gtmenu", "--gtmsgbox",
            "--gtpasswordbox", "--gtyesno", "--file", "--help", 
"--size", "--tofd", "--title",
            ""};
   int i=0;
   while(strlen(gtargs[i])){
     if (strcmp(gtargs[i], str) == 0)
       return 1;
     i++;
   }
   return 0;
}
/* command line parser, for each option on command line fill the right
field of gtdialog_context */
int handle_opts(struct gtdialog_context *ctx, int argc, char *argv[], int c)
{
   gchar  *tmp_ptr;
   int  count;
/***********************************************************
qui parserizza l'opzione --gtmenu sulla linea di comando,
la quale ha un numero variabile di argomenti (almeno 3).


   }
}

{




/**********************************************
qui in base al tipo di dialog scelto chiama il costruttore
per quel dialog (in un altro file allegato di seguito)
   case gtmenu:
     ctx -> window = create_gt_menu_window();
     break;
**************************************************/
   return ctx;
}
int
main (int argc, char *argv[])
{
   gtk_set_locale ();
   gtk_init (&argc, &argv);
   gtcontext = create_gtdialog_context(argc, argv);
   gtk_widget_show(gtcontext -> window);
   gtk_main ();
   return exit_status;
}
#####################################################
####################################################
file gtmenu.c in cui si presenta l'errore
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include "gtdialog.h"
int  selected_row;
GtkWidget*
create_gt_menu_window (void)
{
   GtkWidget *gt_menu_window;
/*********************************************************
l'errore avviene qui, apparentemente non c'è nessun riferimento
ad argc ed argv
   gt_menu_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
*********************************************************/
.
.
.
   return gt_menu_window;
}

 isopt(argv[c+3]) ){
Ti do circa cinque secondi per pensare a cosa succede se "c + N" eccede
il segmento di memoria in cui si trova argv[].
Hint:
	char *c;
	int i;
 
	for (i = 1; (c = argv[i]) != NULL; i++)
	{
		[...]


 3. Taglia, riadatta e *forse* ci si può pensare a darti una mano.
forse ho esagerato un tantino, perdonatemi
cmunque il codice intero e per ora 1800 linee
in 22 file, quello che ho postato erano solo i 2
file interessati.
credo che quanto prima sposto tutto su sourceforge
cosi magari qualcuno mi da una mano e magari ne esce fuori qualcosa di
utile.
ecco il riassunto
int isopt(char  *str)
{
   char *gtargs[]={"--gtedit", "--gtfilechoser", "--gtinputbox",
"--gtlist", "--gtmenu", "--gtmsgbox",
            "--gtpasswordbox", "--gtyesno", "--file", "--help",
"--size", "--tofd", "--title",
            ""};
   int i=0;
   while(strlen(gtargs[i])){
     if (strcmp(gtargs[i], str) == 0)
       return 1;
     i++;
   }
   return 0;
}
/* command line parser, for each option on command line fill the right
field of gtdialog_context */
int handle_opts(struct gtdialog_context *ctx, int argc, char *argv[], int c)
{
   gchar  *tmp_ptr;
   int  count;
/***********************************************************
qui parserizza l'opzione --gtmenu sulla linea di comando,
la quale ha un numero variabile di argomenti (almeno 3).


   }
}

{




/**********************************************
qui in base al tipo di dialog scelto chiama il costruttore
per quel dialog (in un altro file allegato di seguito)
   case gtmenu:
     ctx -> window = create_gt_menu_window();
     break;
**************************************************/
   return ctx;
}
int
main (int argc, char *argv[])
{
   gtk_set_locale ();
   gtk_init (&argc, &argv);
   gtcontext = create_gtdialog_context(argc, argv);
   gtk_widget_show(gtcontext -> window);
   gtk_main ();
   return exit_status;
}
#####################################################
####################################################
file gtmenu.c in cui si presenta l'errore
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include "gtdialog.h"
int  selected_row;
GtkWidget*
create_gt_menu_window (void)
{
   GtkWidget *gt_menu_window;
/*********************************************************
l'errore avviene qui, apparentemente non c'è nessun riferimento
ad argc ed argv
   gt_menu_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
*********************************************************/


 3. Taglia, riadatta e *forse* ci si può pensare a darti una mano.
forse ho esagerato un tantino, perdonatemi
cmunque il codice intero e per ora 1800 linee
in 22 file, quello che ho postato erano solo i 2
file interessati.
credo che quanto prima sposto tutto su sourceforge
cosi magari qualcuno mi da una mano e magari ne esce fuori qualcosa di
utile.
ecco il riassunto
int isopt(char  *str)
{
   char *gtargs[]={"--gtedit", "--gtfilechoser", "--gtinputbox",
"--gtlist", "--gtmenu", "--gtmsgbox",
            "--gtpasswordbox", "--gtyesno", "--file", "--help",
"--size", "--tofd", "--title",
            ""};
   int i=0;
   while(strlen(gtargs[i])){
     if (strcmp(gtargs[i], str) == 0)
       return 1;
     i++;
   }
   return 0;
}
/* command line parser, for each option on command line fill the right
field of gtdialog_context */
int handle_opts(struct gtdialog_context *ctx, int argc, char *argv[], int c)
{
   gchar  *tmp_ptr;
   int  count;
/***********************************************************
qui parserizza l'opzione --gtmenu sulla linea di comando,
la quale ha un numero variabile di argomenti (almeno 3).


   }
}

{




/**********************************************
qui in base al tipo di dialog scelto chiama il costruttore
per quel dialog (in un altro file allegato di seguito)
   case gtmenu:
     ctx -> window = create_gt_menu_window();
     break;
**************************************************/
   return ctx;
}
int
main (int argc, char *argv[])
{
   gtk_set_locale ();
   gtk_init (&argc, &argv);
   gtcontext = create_gtdialog_context(argc, argv);
   gtk_widget_show(gtcontext -> window);
   gtk_main ();
   return exit_status;
}
#####################################################
####################################################
file gtmenu.c in cui si presenta l'errore
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include "gtdialog.h"
int  selected_row;
GtkWidget*
create_gt_menu_window (void)
{
   GtkWidget *gt_menu_window;
/*********************************************************
l'errore avviene qui, apparentemente non c'è nessun riferimento
ad argc ed argv
   gt_menu_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
*********************************************************/


 Hint:
...
A parte tutto questo:
man 3 getopt
NP: Kiss - God Of Thunder
-- 
  Giuseppe "Cowo" Corbelli \/\ My software: 
http://cowo.yoda2000.net
    **ANTI-SPAM** -- **Substitute IHATESPAM with cowo to reply by mail**
  -<! Drink To Your Brothers Who Are Never To Fall, We Are Brothers Of Metal
  		Here In The Hall! !>- Manowar - Brothers Of Metal PT1

 man 3 getopt
Purtroppo non è del tutto portabile, e aggiunge una dipendenza. Ad ogni
modo, si: c'è anche getopt(3).


 modo, si: c'è anche getopt(3).
e usare libpopt ? dovrebbe andare un po' meglio per la portabilità

 e usare libpopt ? dovrebbe andare un po' meglio per la portabilità
Non saprei.
Esempio: SLRN non usa né getopt né libpopt perché supporta una pacca di
architetture. Dipende dai prerequisiti del programma.


 architetture. Dipende dai prerequisiti del programma.
bah, considerando che libpopt viene usata da gnome mi sembra che sia più
che sufficiente per quanto riguarda la portabilità.
Oddio, non so se vada sotto win, ma per il resto non dovrebbero esserci
problemi.

 che sufficiente per quanto riguarda la portabilità.
Infatti GNOME non è portabile proprio ovunque. ;-)


 modo, si: c'è anche getopt(3).
Per la portabilita' non saprei ma sono convinto che ci si possa lavorare.
Fra aggiungere una dipendenza (se non getopt ci sara' qualche mini libreria
che fa il suo stesso mestiere) e diventare scemo con il parsing delle
opzioni la seconda possibilita' non ha un gran senso per me.
-- 
  Giuseppe "Cowo" Corbelli \/\ My software: 
http://cowo.yoda2000.net
    **ANTI-SPAM** -- **Substitute IHATESPAM with cowo to reply by mail**
           -<! Failure is not an option...it's bundled with Microsoft !>-

 delle opzioni la seconda possibilita' non ha un gran senso per me.
(piccolo spazio pubblicità)
Io me la sono scritta (usa il compilatore C++ ma è scritta usando lo
standard C (è usata nel programma GesConf)), perchè avevo l'esigenza di
qualcosa di facile da configurare e sofisticato come possibilità (gestione
delle priorità delle opzioni, rispetto della sequenza delle opzioni,
possibilità di opzioni ripetute, possibilità di modificare l'elaborazione
delle opzioni a run-time, controllo dell sintassi di tutte le opzioni prima
di eseguirle, blindatura contro gli errori di buffer overflow.
Ho visto vari parsing, o sono molto incasinati come struttura del codice o
sono molto limitati, in sintesi, se vuoi fare un buon lavoro come gestione
delle opzioni, scriversi il gestore ha senso.