Some changes to migrate towards C++ and a multithreaded model

1 files changed, 106 insertions, 106 deletions

diff --git a/event.cpp b/event.cpp
index 6a53254f..a3dffa15 100644
--- a/event.cpp
+++ b/event.cpp
@@ -44,11 +44,11 @@ typedef struct
 	/**
 	   Whether signals have been skipped
 	*/
-	int overflow;
+	int overflow;	
 	/**
 	   Array of signal events
 	*/
-	int signal[SIG_UNHANDLED_MAX];
+	int signal[SIG_UNHANDLED_MAX];	
 }
 	signal_list_t;
 
@@ -84,52 +84,52 @@ static array_list_t *blocked;
    they must name the same function.
 
 */
-static int event_match( event_t *class, event_t *instance )
+static int event_match( event_t *classv, event_t *instance )
 {
 
-	if( class->function_name && instance->function_name )
+	if( classv->function_name && instance->function_name )
 	{
-		if( wcscmp( class->function_name, instance->function_name ) != 0 )
+		if( wcscmp( classv->function_name, instance->function_name ) != 0 )
 			return 0;
 	}
 
-	if( class->type == EVENT_ANY )
+	if( classv->type == EVENT_ANY )
 		return 1;
-
-	if( class->type != instance->type )
+	
+	if( classv->type != instance->type )
 		return 0;
+	
 
-
-	switch( class->type )
+	switch( classv->type )
 	{
-
+		
 		case EVENT_SIGNAL:
-			if( class->param1.signal == EVENT_ANY_SIGNAL )
+			if( classv->param1.signal == EVENT_ANY_SIGNAL )
 				return 1;
-			return class->param1.signal == instance->param1.signal;
-
+			return classv->param1.signal == instance->param1.signal;
+			
 		case EVENT_VARIABLE:
 			return wcscmp( instance->param1.variable,
-				       class->param1.variable )==0;
-
+				       classv->param1.variable )==0;
+			
 		case EVENT_EXIT:
-			if( class->param1.pid == EVENT_ANY_PID )
+			if( classv->param1.pid == EVENT_ANY_PID )
 				return 1;
-			return class->param1.pid == instance->param1.pid;
+			return classv->param1.pid == instance->param1.pid;
 
 		case EVENT_JOB_ID:
-			return class->param1.job_id == instance->param1.job_id;
+			return classv->param1.job_id == instance->param1.job_id;
 
 		case EVENT_GENERIC:
 			return wcscmp( instance->param1.param,
-				       class->param1.param )==0;
+				       classv->param1.param )==0;
 
 	}
-
+	
 	/**
 	   This should never be reached
 	*/
-	return 0;
+	return 0;	
 }
 
 
@@ -139,11 +139,11 @@ static int event_match( event_t *class, event_t *instance )
 */
 static event_t *event_copy( event_t *event, int copy_arguments )
 {
-	event_t *e = malloc( sizeof( event_t ) );
-
+	event_t *e = (event_t *)malloc( sizeof( event_t ) );
+	
 	if( !e )
 		DIE_MEM();
-
+	
 	memcpy( e, event, sizeof(event_t));
 
 	if( e->function_name )
@@ -153,7 +153,7 @@ static event_t *event_copy( event_t *event, int copy_arguments )
 		e->param1.variable = wcsdup( e->param1.variable );
 	else if( e->type == EVENT_GENERIC )
 		e->param1.param = wcsdup( e->param1.param );
-
+		
 	al_init( &e->arguments );
 	if( copy_arguments )
 	{
@@ -162,9 +162,9 @@ static event_t *event_copy( event_t *event, int copy_arguments )
 		{
 			al_push( &e->arguments, wcsdup( (wchar_t *)al_get( &event->arguments, i ) ) );
 		}
-
+				
 	}
-
+	
 	return e;
 }
 
@@ -175,7 +175,7 @@ static int event_is_blocked( event_t *e )
 {
 	block_t *block;
 	event_block_t *eb;
-
+	
 	for( block = current_block; block; block = block->outer )
 	{
 		for( eb = block->first_event_block; eb; eb=eb->next )
@@ -193,9 +193,9 @@ static int event_is_blocked( event_t *e )
 		if( eb->type & (1<<e->type) )
 			return 1;
 		return 1;
-
+		
 	}
-
+	
 	return 0;
 }
 
@@ -217,18 +217,18 @@ const wchar_t *event_get_desc( event_t *e )
 	{
 		sb_clear( get_desc_buff );
 	}
-
+	
 	switch( e->type )
 	{
-
+		
 		case EVENT_SIGNAL:
 			sb_printf( get_desc_buff, _(L"signal handler for %ls (%ls)"), sig2wcs(e->param1.signal ), signal_get_desc( e->param1.signal ) );
 			break;
-
+		
 		case EVENT_VARIABLE:
 			sb_printf( get_desc_buff, _(L"handler for variable '%ls'"), e->param1.variable );
 			break;
-
+		
 		case EVENT_EXIT:
 			if( e->param1.pid > 0 )
 			{
@@ -242,9 +242,9 @@ const wchar_t *event_get_desc( event_t *e )
 				else
 					sb_printf( get_desc_buff, _(L"exit handler for job with process group %d"), -e->param1.pid );
 			}
-
+			
 			break;
-
+		
 		case EVENT_JOB_ID:
 		{
 			job_t *j = job_get( e->param1.job_id );
@@ -255,17 +255,17 @@ const wchar_t *event_get_desc( event_t *e )
 
 			break;
 		}
-
+		
 		case EVENT_GENERIC:
 			sb_printf( get_desc_buff, _(L"handler for generic event '%ls'"), e->param1.param );
 			break;
-
+			
 		default:
 			sb_printf( get_desc_buff, _(L"Unknown event type") );
 			break;
-
+			
 	}
-
+	
 	return (const wchar_t *)get_desc_buff->buff;
 }
 
@@ -275,7 +275,7 @@ void event_add_handler( event_t *event )
 	event_t *e;
 
 	CHECK( event, );
-
+	
 	e = event_copy( event, 0 );
 
 	if( !events )
@@ -285,8 +285,8 @@ void event_add_handler( event_t *event )
 	{
 		signal_handle( e->param1.signal, 1 );
 	}
-
-	al_push( events, e );
+	
+	al_push( events, e );	
 }
 
 void event_remove( event_t *criterion )
@@ -294,7 +294,7 @@ void event_remove( event_t *criterion )
 	int i;
 	array_list_t *new_list=0;
 	event_t e;
-
+	
 	CHECK( criterion, );
 
 	/*
@@ -305,19 +305,19 @@ void event_remove( event_t *criterion )
 	  that shouldn't be killed to new_list, and then drops the empty
 	  events-list.
 	*/
-
+	
 	if( !events )
 		return;
 
 	for( i=0; i<al_get_count( events); i++ )
 	{
-		event_t *n = (event_t *)al_get( events, i );
+		event_t *n = (event_t *)al_get( events, i );		
 		if( event_match( criterion, n ) )
 		{
 			if( !killme )
 				killme = al_new();
-
-			al_push( killme, n );
+			
+			al_push( killme, n );			
 
 			/*
 			  If this event was a signal handler and no other handler handles
@@ -329,11 +329,11 @@ void event_remove( event_t *criterion )
 				e.type = EVENT_SIGNAL;
 				e.param1.signal = n->param1.signal;
 				e.function_name = 0;
-
+				
 				if( event_get( &e, 0 ) == 1 )
 				{
 					signal_handle( e.param1.signal, 0 );
-				}
+				}		
 			}
 		}
 		else
@@ -344,7 +344,7 @@ void event_remove( event_t *criterion )
 		}
 	}
 	al_destroy( events );
-	free( events );
+	free( events );	
 	events = new_list;
 }
 
@@ -352,21 +352,21 @@ int event_get( event_t *criterion, array_list_t *out )
 {
 	int i;
 	int found = 0;
-
+	
 	if( !events )
-		return 0;
+		return 0;	
 
 	CHECK( criterion, 0 );
-
+	
 	for( i=0; i<al_get_count( events); i++ )
 	{
-		event_t *n = (event_t *)al_get( events, i );
+		event_t *n = (event_t *)al_get( events, i );		
 		if( event_match(criterion, n ) )
 		{
 			found++;
 			if( out )
 				al_push( out, n );
-		}
+		}		
 	}
 	return found;
 }
@@ -379,7 +379,7 @@ static void event_free_kills()
 	int i;
 	if( !killme )
 		return;
-
+	
 	for( i=0; i<al_get_count( killme ); i++ )
 	{
 		event_t *roadkill = (event_t *)al_get( killme, i );
@@ -396,16 +396,16 @@ static int event_is_killed( event_t *e )
 	int i;
 	if( !killme )
 		return 0;
-
+	
 	for( i=0; i<al_get_count( killme ); i++ )
 	{
 		event_t *roadkill = (event_t *)al_get( events, i );
 		if( roadkill ==e )
 			return 1;
-
+		
 	}
 	return 0;
-}
+}	
 
 /**
    Perform the specified event. Since almost all event firings will
@@ -418,11 +418,11 @@ static void event_fire_internal( event_t *event )
 	int i, j;
 	string_buffer_t *b=0;
 	array_list_t *fire=0;
-
+	
 	/*
 	  First we free all events that have been removed
 	*/
-	event_free_kills();
+	event_free_kills();	
 
 	if( !events )
 		return;
@@ -437,7 +437,7 @@ static void event_fire_internal( event_t *event )
 	for( i=0; i<al_get_count( events ); i++ )
 	{
 		event_t *criterion = (event_t *)al_get( events, i );
-
+		
 		/*
 		  Check if this event is a match
 		*/
@@ -448,17 +448,17 @@ static void event_fire_internal( event_t *event )
 			al_push( fire, criterion );
 		}
 	}
-
+	
 	/*
 	  No matches. Time to return.
 	*/
 	if( !fire )
 		return;
-
+		
 	/*
 	  Iterate over our list of matching events
 	*/
-
+	
 	for( i=0; i<al_get_count( fire ); i++ )
 	{
 		event_t *criterion = (event_t *)al_get( fire, i );
@@ -477,19 +477,19 @@ static void event_fire_internal( event_t *event )
 			b = sb_new();
 		else
 			sb_clear( b );
-
+		
 		sb_append( b, criterion->function_name );
-
+		
 		for( j=0; j<al_get_count(&event->arguments); j++ )
 		{
-			wchar_t *arg_esc = escape( (wchar_t *)al_get( &event->arguments, j), 1 );
+			wchar_t *arg_esc = escape( (wchar_t *)al_get( &event->arguments, j), 1 );		
 			sb_append( b, L" " );
 			sb_append( b, arg_esc );
-			free( arg_esc );
+			free( arg_esc );				
 		}
 
 //		debug( 1, L"Event handler fires command '%ls'", (wchar_t *)b->buff );
-
+		
 		/*
 		  Event handlers are not part of the main flow of code, so
 		  they are marked as non-interactive
@@ -500,27 +500,27 @@ static void event_fire_internal( event_t *event )
 		current_block->param1.event = event;
 		eval( (wchar_t *)b->buff, 0, TOP );
 		parser_pop_block();
-		proc_pop_interactive();
+		proc_pop_interactive();					
 		proc_set_last_status( prev_status );
 	}
 
 	if( b )
 	{
 		sb_destroy( b );
-		free( b );
+		free( b );		
 	}
-
+	
 	if( fire )
 	{
 		al_destroy( fire );
 		free( fire );
 	}
-
+	
 	/*
 	  Free killed events
 	*/
-	event_free_kills();
-
+	event_free_kills();	
+	
 }
 
 /**
@@ -532,7 +532,7 @@ static void event_fire_delayed()
 	int i;
 
 	/*
-	  If is_event is one, we are running the event-handler non-recursively.
+	  If is_event is one, we are running the event-handler non-recursively. 
 
 	  When the event handler has called a piece of code that triggers
 	  another event, we do not want to fire delayed events because of
@@ -541,7 +541,7 @@ static void event_fire_delayed()
 	if( blocked && is_event==1)
 	{
 		array_list_t *new_blocked = 0;
-
+		
 		for( i=0; i<al_get_count( blocked ); i++ )
 		{
 			event_t *e = (event_t *)al_get( blocked, i );
@@ -549,24 +549,24 @@ static void event_fire_delayed()
 			{
 				if( !new_blocked )
 					new_blocked = al_new();
-				al_push( new_blocked, e );
+				al_push( new_blocked, e );			
 			}
 			else
 			{
 				event_fire_internal( e );
 				event_free( e );
 			}
-		}
+		}		
 		al_destroy( blocked );
 		free( blocked );
 		blocked = new_blocked;
 	}
-
+	
 	while( sig_list[active_list].count > 0 )
 	{
 		signal_list_t *lst;
 		event_t e;
-		al_init( &e.arguments );
+		al_init( &e.arguments );		
 
 		/*
 		  Switch signal lists
@@ -576,47 +576,47 @@ static void event_fire_delayed()
 		active_list=1-active_list;
 
 		/*
-		  Set up
+		  Set up 
 		*/
 		e.type=EVENT_SIGNAL;
 		e.function_name=0;
-
+		
 		lst = &sig_list[1-active_list];
-
+		
 		if( lst->overflow )
 		{
 			debug( 0, _( L"Signal list overflow. Signals have been ignored." ) );
 		}
-
+		
 		/*
 		  Send all signals in our private list
 		*/
 		for( i=0; i<lst->count; i++ )
 		{
 			e.param1.signal = lst->signal[i];
-			al_set( &e.arguments, 0, sig2wcs( e.param1.signal ) );
+			al_set( &e.arguments, 0, sig2wcs( e.param1.signal ) );			
 			if( event_is_blocked( &e ) )
 			{
 				if( !blocked )
 					blocked = al_new();
-				al_push( blocked, event_copy(&e, 1) );
+				al_push( blocked, event_copy(&e, 1) );			
 			}
 			else
 			{
 				event_fire_internal( &e );
 			}
 		}
-
+		
 		al_destroy( &e.arguments );
-
-	}
+		
+	}	
 }
 
 
 void event_fire( event_t *event )
 {
 	is_event++;
-
+	
 	if( event && (event->type == EVENT_SIGNAL) )
 	{
 		/*
@@ -636,14 +636,14 @@ void event_fire( event_t *event )
 		  Fire events triggered by signals
 		*/
 		event_fire_delayed();
-
+			
 		if( event )
 		{
 			if( event_is_blocked( event ) )
 			{
 				if( !blocked )
 					blocked = al_new();
-
+				
 				al_push( blocked, event_copy(event, 1) );
 			}
 			else
@@ -651,8 +651,8 @@ void event_fire( event_t *event )
 				event_fire_internal( event );
 			}
 		}
-
-	}
+		
+	}	
 	is_event--;
 }
 
@@ -668,7 +668,7 @@ void event_destroy()
 	{
 		al_foreach( events, (void (*)(void *))&event_free );
 		al_destroy( events );
-		free( events );
+		free( events );		
 		events=0;
 	}
 
@@ -676,9 +676,9 @@ void event_destroy()
 	{
 		al_foreach( killme, (void (*)(void *))&event_free );
 		al_destroy( killme );
-		free( killme );
-		killme=0;
-	}
+		free( killme );		
+		killme=0;		
+	}	
 }
 
 void event_free( event_t *e )
@@ -711,11 +711,11 @@ void event_fire_generic_internal(const wchar_t *name, ...)
 	wchar_t *arg;
 
 	CHECK( name, );
-
+	
 	ev.type = EVENT_GENERIC;
 	ev.param1.param = name;
 	ev.function_name=0;
-
+	
 	al_init( &ev.arguments );
 	va_start( va, name );
 	while( (arg=va_arg(va, wchar_t *) )!= 0 )
@@ -723,9 +723,9 @@ void event_fire_generic_internal(const wchar_t *name, ...)
 		al_push( &ev.arguments, arg );
 	}
 	va_end( va );
-
+	
 	event_fire( &ev );
 }
 
-
+