package EcgDebug; 
use strict; 
  
# ( I left out all the header stuff ) 
  
#----- Initialization Code --------------------------------------------- 
  
BEGIN { 
  no strict 'refs'; 
  $DBENV = \%{'main::DBENV'}; 
} 
  
  
#----- Interface Definition -------------------------------------------- 
  
# The interface between the debug parser and the plugin is a hash table 
# called `Interface'. It tells the debug parser which routines to call 
# for certain messages or debug message ids. 
  
our %Interface = 
( 
  # Debugger Control & Status Message Headers 
  # ````````````````````````````````````````` 
  # The debug parser needs to know these in case you want to put 
  # routines for debug messages in your plugin. The two keys must be 
  # both existing or both missing, otherwise the parser will fail. 
  
  DebugControlHeader => 'ThreeChanEcg_1_General_9_Int_1', 
  DebugStatusHeader  => 'ThreeChanEcg_1_General_10_Int_1', 
  
  # Parser Table 
  # ```````````` 
  # The parser table again is a hash table with either debug message 
  # ids or message headers as keys and subroutine references as values. 
  # You may add as much entries as you like. If your parser subroutine 
  # can handle more than one header or message id, feel free to use 
  # the same subroutine reference for different keys. 
  
  Parsers => 
  { 
    ThreeChanEcg_1_Ecg_1_MdilRTSA_2_ObsVSPk => \&MyParser, 
    DB_MY_DEBUG_ID                          => \&MyParser, 
  }, 
  
  # Routine Table 
  # ````````````` 
  # The routine table is used for describing special properties of 
  # your parser routines. At the moment, the only special property 
  # of a routine is `options', which means that this routine can 
  # handle several option. Routines only need to be entered in the 
  # routine table if they have special properties. So if your 
  # routine doesn't take options, you don't have to put it in the 
  # routine table. 
  # An option is defined as a key => value pair with the key being 
  # the name of the option (an upper- or lowercase character) and 
  # the value being a string describing the option. The option 
  # name may be followed by a colon (`:') if the option takes an 
  # argument.  
  
  Routines => 
  { 
    \&MyParser => 
    { 
      options => { 
                   'w'  => 'write wave files', 
                   'e:' => 'do something mysterious', 
                 }, 
    }, 
  } 
); 
  
###################################################################### 
# 
# ROUTINE: MyParser 
# 
# WRITTEN BY:                                   ON: 
# CHANGED BY:                                   ON: 
# 
###################################################################### 
# 
# DESCRIPTION: This is my favourite message parser. 
# 
###################################################################### 
  
sub MyParser 
{ 
  return whoami unless @_;  # if called without arguments, return name 
  my $opt = shift;          # get options 
  
  Print "No Options :-(\n" unless scalar %{$opt}; 
  foreach( keys %{$opt} ) { 
    Print "Option `-$_' => $opt->{$_}\n"; 
  } 
  
  if( exists $DBENV->{compiler} ) { 
    Print "ah, we're using the $DBENV->{compiler} compiler...\n"; 
  } 
  else { 
    Print "no compiler info available...\n"; 
  } 
  
  # just print the rest of the arguments 
  Print "@_\n"; 
} 
  
1;

foreach( keys %plugin ) { 
  eval "require '$_.pm'" or die "$@\n"; 
  { 
    no strict 'refs'; 
  
    die "Invalid interface for plugin `$_'\n" 
        unless defined %{$_.'::Interface'}; 
  
    $plugin{$_}->{interface} = \%{$_.'::Interface'}; 
  } 
  # ... 
}

*DBENV = \%::DBENV;

for (keys %plugins) { 
  require;  # require()s $_ 
  die "Invalid interface for $_" unless $::{"${_}::Interface::"}; 
  $plugin{$_}{interface} = $::{"${_}::Interface"}; 
}