fuse/event.c

/* event.c: Routines needed for dealing with the event list
   Copyright (c) 2000-2015 Philip Kendall

   $Id$

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   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.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

   Author contact information:

   E-mail: philip-fuse@shadowmagic.org.uk

*/

#include <config.h>

#include <string.h>

#include <libspectrum.h>

#include "event.h"
#include "infrastructure/startup_manager.h"
#include "fuse.h"
#include "ui/ui.h"
#include "utils.h"

/* A large value to mean `no events due' */
static const libspectrum_dword event_no_events = 0xffffffff;

/* When will the next event happen? */
libspectrum_dword event_next_event;

/* The actual list of events */
static GSList *event_list = NULL;

/* An event ready to be reused */
static event_t *event_free = NULL;

/* A null event */
int event_type_null;

typedef struct event_descriptor_t {
  event_fn_t fn;
  char *description;
} event_descriptor_t; 

static GArray *registered_events;

static int
event_init( void *context )
{
  registered_events = g_array_new( FALSE, FALSE, sizeof( event_descriptor_t ) );

  event_type_null = event_register( NULL, "[Deleted event]" );

  event_next_event = event_no_events;

  return 0;
}

int
event_register( event_fn_t fn, const char *description )
{
  event_descriptor_t descriptor;

  descriptor.fn = fn;
  descriptor.description = utils_safe_strdup( description );

  g_array_append_val( registered_events, descriptor );

  return registered_events->len - 1;
}

static gint
event_add_cmp( gconstpointer a1, gconstpointer b1 )
{
  const event_t *a = a1, *b = b1;

  return a->tstates != b->tstates ? a->tstates - b->tstates
		                  : a->type - b->type;
}

/* Add an event at the correct place in the event list */
void
event_add_with_data( libspectrum_dword event_time, int type, void *user_data )
{
  event_t *ptr;

  if( event_free ) {
    ptr = event_free;
    event_free = NULL;
  } else {
    ptr = libspectrum_new( event_t, 1 );
  }

  ptr->tstates = event_time;
  ptr->type =type;
  ptr->user_data = user_data;

  if( event_time < event_next_event ) {
    event_next_event = event_time;
    event_list = g_slist_prepend( event_list, ptr );
  } else {
    event_list = g_slist_insert_sorted( event_list, ptr, event_add_cmp );
  }
}

/* Do all events which have passed */
int
event_do_events( void )
{
  event_t *ptr;

  while(event_next_event <= tstates) {
    event_descriptor_t descriptor;
    ptr = event_list->data;
    descriptor =
      g_array_index( registered_events, event_descriptor_t, ptr->type );

    /* Remove the event from the list *before* processing */
    event_list = g_slist_remove( event_list, ptr );

    if( event_list == NULL ) {
      event_next_event = event_no_events;
    } else {
      event_next_event = ((event_t*)(event_list->data))->tstates;
    }

    if( descriptor.fn ) descriptor.fn( ptr->tstates, ptr->type, ptr->user_data );

    if( event_free ) {
      libspectrum_free( ptr );
    } else {
      event_free = ptr;
    }
  }

  return 0;
}

static void
event_reduce_tstates( gpointer data, gpointer user_data )
{
  event_t *ptr = data;
  libspectrum_dword *tstates_per_frame = user_data;

  ptr->tstates -= *tstates_per_frame;
}

/* Called at end of frame to reduce T-state count of all entries */
void
event_frame( libspectrum_dword tstates_per_frame )
{
  g_slist_foreach( event_list, event_reduce_tstates, &tstates_per_frame );

  event_next_event = event_list ?
    ((event_t*)(event_list->data))->tstates : event_no_events;
}

/* Do all events that would happen between the current time and when
   the next interrupt will occur; called only when RZX playback is in
   effect */
void
event_force_events( void )
{
  while( event_next_event < machine_current->timings.tstates_per_frame ) {

    /* Jump along to the next event */
    tstates = event_next_event;
    
    /* And do that event */
    event_do_events();

  }
}

static void
set_event_null( gpointer data, gpointer user_data )
{
  event_t *ptr = data;
  int *type = user_data;

  if( ptr->type == *type ) ptr->type = event_type_null;
}

static void
set_event_null_with_user_data( gpointer data, gpointer user_data )
{
  event_t *event = data;
  event_t *template = user_data;

  if( event->type == template->type && event->user_data == template->user_data )
    event->type = event_type_null;
}

/* Remove all events of a specific type from the stack */
void
event_remove_type( int type )
{
  g_slist_foreach( event_list, set_event_null, &type );
}

/* Remove all events of a specific type and user data from the stack */
void
event_remove_type_user_data( int type, gpointer user_data )
{
  event_t template;

  template.type = type;
  template.user_data = user_data;
  g_slist_foreach( event_list, set_event_null_with_user_data, &template );
}

/* Free the memory used by a specific entry */
static void
event_free_entry( gpointer data, gpointer user_data GCC_UNUSED )
{
  libspectrum_free( data );
}

/* Clear the event stack */
void
event_reset( void )
{
  g_slist_foreach( event_list, event_free_entry, NULL );
  g_slist_free( event_list );
  event_list = NULL;

  event_next_event = event_no_events;

  libspectrum_free( event_free );
  event_free = NULL;
}

/* Call a user-supplied function for every event in the current list */
void
event_foreach( GFunc function, gpointer user_data )
{
  g_slist_foreach( event_list, function, user_data );
}

/* A textual representation of each event type */
const char*
event_name( int type )
{
  return g_array_index( registered_events, event_descriptor_t, type ).description;
}

static void
registered_events_free( void )
{
  int i;
  event_descriptor_t descriptor;

  if( !registered_events ) return;

  for( i = 0; i < registered_events->len; i++ ) {
    descriptor = g_array_index( registered_events, event_descriptor_t, i );
    libspectrum_free( descriptor.description );
  }

  g_array_free( registered_events, TRUE );
  registered_events = NULL;
}

/* Tidy-up function called at end of emulation */
static void
event_end( void )
{
  event_reset();
  registered_events_free();
}

void
event_register_startup( void )
{
  startup_manager_module dependencies[] = { STARTUP_MANAGER_MODULE_SETUID };
  startup_manager_register( STARTUP_MANAGER_MODULE_EVENT, dependencies,
                            ARRAY_SIZE( dependencies ), event_init, NULL,
                            event_end );
}