package SDL::ConfigData;
use strict;
my $arrayref = eval do {local $/; <DATA>}
  or die "Couldn't load ConfigData data: $@";
close DATA;
my ($config, $features, $auto_features) = @$arrayref;

sub config { $config->{$_[1]} }

sub set_config { $config->{$_[1]} = $_[2] }
sub set_feature { $features->{$_[1]} = 0+!!$_[2] }  # Constrain to 1 or 0

sub auto_feature_names { grep !exists $features->{$_}, keys %$auto_features }

sub feature_names {
  my @features = (keys %$features, auto_feature_names());
  @features;
}

sub config_names  { keys %$config }

sub write {
  my $me = __FILE__;
  require IO::File;

  # Can't use Module::Build::Dumper here because M::B is only a
  # build-time prereq of this module
  require Data::Dumper;

  my $mode_orig = (stat $me)[2] & 07777;
  chmod($mode_orig | 0222, $me); # Make it writeable
  my $fh = IO::File->new($me, 'r+') or die "Can't rewrite $me: $!";
  seek($fh, 0, 0);
  while (<$fh>) {
    last if /^__DATA__$/;
  }
  die "Couldn't find __DATA__ token in $me" if eof($fh);

  seek($fh, tell($fh), 0);
  my $data = [$config, $features, $auto_features];
  $fh->print( 'do{ my '
	      . Data::Dumper->new([$data],['x'])->Purity(1)->Dump()
	      . '$x; }' );
  truncate($fh, tell($fh));
  $fh->close;

  chmod($mode_orig, $me)
    or warn "Couldn't restore permissions on $me: $!";
}

sub feature {
  my ($package, $key) = @_;
  return $features->{$key} if exists $features->{$key};

  my $info = $auto_features->{$key} or return 0;

  # Under perl 5.005, each(%$foo) isn't working correctly when $foo
  # was reanimated with Data::Dumper and eval().  Not sure why, but
  # copying to a new hash seems to solve it.
  my %info = %$info;

  require Module::Build;  # XXX should get rid of this
  while (my ($type, $prereqs) = each %info) {
    next if $type eq 'description' || $type eq 'recommends';

    my %p = %$prereqs;  # Ditto here.
    while (my ($modname, $spec) = each %p) {
      my $status = Module::Build->check_installed_status($modname, $spec);
      if ((!$status->{ok}) xor ($type =~ /conflicts$/)) { return 0; }
      if ( ! eval "require $modname; 1" ) { return 0; }
    }
  }
  return 1;
}


=head1 NAME

SDL::ConfigData - Configuration for SDL

=head1 SYNOPSIS

  use SDL::ConfigData;
  $value = SDL::ConfigData->config('foo');
  $value = SDL::ConfigData->feature('bar');

  @names = SDL::ConfigData->config_names;
  @names = SDL::ConfigData->feature_names;

  SDL::ConfigData->set_config(foo => $new_value);
  SDL::ConfigData->set_feature(bar => $new_value);
  SDL::ConfigData->write;  # Save changes


=head1 DESCRIPTION

This module holds the configuration data for the C<SDL>
module.  It also provides a programmatic interface for getting or
setting that configuration data.  Note that in order to actually make
changes, you'll have to have write access to the C<SDL::ConfigData>
module, and you should attempt to understand the repercussions of your
actions.


=head1 METHODS

=over 4

=item config($name)

Given a string argument, returns the value of the configuration item
by that name, or C<undef> if no such item exists.

=item feature($name)

Given a string argument, returns the value of the feature by that
name, or C<undef> if no such feature exists.

=item set_config($name, $value)

Sets the configuration item with the given name to the given value.
The value may be any Perl scalar that will serialize correctly using
C<Data::Dumper>.  This includes references, objects (usually), and
complex data structures.  It probably does not include transient
things like filehandles or sockets.

=item set_feature($name, $value)

Sets the feature with the given name to the given boolean value.  The
value will be converted to 0 or 1 automatically.

=item config_names()

Returns a list of all the names of config items currently defined in
C<SDL::ConfigData>, or in scalar context the number of items.

=item feature_names()

Returns a list of all the names of features currently defined in
C<SDL::ConfigData>, or in scalar context the number of features.

=item auto_feature_names()

Returns a list of all the names of features whose availability is
dynamically determined, or in scalar context the number of such
features.  Does not include such features that have later been set to
a fixed value.

=item write()

Commits any changes from C<set_config()> and C<set_feature()> to disk.
Requires write access to the C<SDL::ConfigData> module.

=back


=head1 AUTHOR

C<SDL::ConfigData> was automatically created using C<Module::Build>.
C<Module::Build> was written by Ken Williams, but he holds no
authorship claim or copyright claim to the contents of C<SDL::ConfigData>.

=cut


__DATA__
do{ my $x = [
  {
    'libraries' => {
      'SDL_ttf' => {
        'lib' => 'SDL_ttf',
        'header' => 'SDL_ttf.h',
        'define' => 'HAVE_SDL_TTF'
      },
      'SDL_gfx_imagefilter' => {
        'lib' => 'SDL_gfx',
        'define' => 'HAVE_SDL_GFX_IMAGEFILTER',
        'header' => 'SDL_imageFilter.h'
      },
      'SDL_gfx_primitives' => {
        'lib' => 'SDL_gfx',
        'header' => 'SDL_gfxPrimitives.h',
        'define' => 'HAVE_SDL_GFX_PRIMITIVES'
      },
      'SDL_gfx' => {
        'lib' => 'SDL_gfx',
        'define' => 'HAVE_SDL_GFX',
        'header' => 'SDL_gfxPrimitives.h'
      },
      'tiff' => {
        'lib' => 'tiff',
        'define' => 'HAVE_TIFF',
        'header' => 'tiff.h'
      },
      'SDL_mixer' => {
        'header' => 'SDL_mixer.h',
        'define' => 'HAVE_SDL_MIXER',
        'lib' => 'SDL_mixer'
      },
      'GLU' => {
        'lib' => 'GLU',
        'header' => 'GL/glu.h',
        'define' => 'HAVE_GLU'
      },
      'SDL_gfx_framerate' => {
        'define' => 'HAVE_SDL_GFX_FRAMERATE',
        'header' => 'SDL_framerate.h',
        'lib' => 'SDL_gfx'
      },
      'png' => {
        'lib' => 'png',
        'header' => 'png.h',
        'define' => 'HAVE_PNG'
      },
      'SDL_gfx_blitfunc' => {
        'header' => 'SDL_gfxBlitFunc.h',
        'define' => 'HAVE_SDL_GFX_BLITFUNC',
        'lib' => 'SDL_gfx'
      },
      'jpeg' => {
        'lib' => 'jpeg',
        'define' => 'HAVE_JPEG',
        'header' => 'jpeglib.h'
      },
      'SDL' => {
        'header' => 'SDL.h',
        'define' => 'HAVE_SDL',
        'lib' => 'SDL'
      },
      'SDL_Pango' => {
        'lib' => 'SDL_Pango',
        'header' => 'SDL_Pango.h',
        'define' => 'HAVE_SDL_PANGO'
      },
      'SDL_gfx_rotozoom' => {
        'define' => 'HAVE_SDL_GFX_ROTOZOOM',
        'header' => 'SDL_rotozoom.h',
        'lib' => 'SDL_gfx'
      },
      'GL' => {
        'header' => [
          'GL/gl.h',
          'GL/glext.h'
        ],
        'define' => 'HAVE_GL',
        'lib' => 'GL'
      },
      'smpeg' => {
        'define' => 'HAVE_SMPEG',
        'header' => 'smpeg/smpeg.h',
        'lib' => 'smpeg'
      },
      'SDL_image' => {
        'define' => 'HAVE_SDL_IMAGE',
        'header' => 'SDL_image.h',
        'lib' => 'SDL_image'
      }
    },
    'SDL_cfg' => {
      'FPSManager' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_FRAMERATE'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ],
        'libs' => {
          'SDL_gfx_framerate' => 1,
          'SDL' => 1
        }
      },
      'MixerEffects' => {
        'libs' => {
          'SDL_mixer' => 1,
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ]
      },
      'Events' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'Pango' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_PANGO'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_Pango'
        ],
        'libs' => {
          'SDL_Pango' => 1,
          'SDL' => 1
        }
      },
      'Time' => {
        'libs' => {
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ]
      },
      'Cursor' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'AudioSpec' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'LayerManagerX' => {
        'libs' => {
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ]
      },
      'ValidateX' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'Audio' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'SurfaceX' => {
        'libs' => {
          'SDL_gfx_primitives' => 1,
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_PRIMITIVES'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ]
      },
      'CD' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'MixerGroups' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ],
        'libs' => {
          'SDL_mixer' => 1,
          'SDL' => 1
        }
      },
      'SFont' => {
        'libs' => {
          'SDL' => 1,
          'SDL_image' => 1
        },
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_IMAGE'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_image'
        ]
      },
      'Event' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'PixelFormat' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'AudioCVT' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'Surface' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'ImageFilter' => {
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ],
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_IMAGEFILTER'
        ],
        'libs' => {
          'SDL' => 1,
          'SDL_gfx_imagefilter' => 1
        }
      },
      'Rect' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'Framerate' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_FRAMERATE'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ],
        'libs' => {
          'SDL_gfx_framerate' => 1,
          'SDL' => 1
        }
      },
      'MixerChannels' => {
        'libs' => {
          'SDL' => 1,
          'SDL_mixer' => 1
        },
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ],
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ]
      },
      'Version' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'CDTrack' => {
        'libs' => {
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ]
      },
      'InterfaceX' => {
        'libs' => {
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ]
      },
      'BlitFunc' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_BLITFUNC'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ],
        'libs' => {
          'SDL_gfx_blitfunc' => 1,
          'SDL' => 1
        }
      },
      'Mouse' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'RWOps' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'MixerSamples' => {
        'libs' => {
          'SDL' => 1,
          'SDL_mixer' => 1
        },
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ]
      },
      'Primitives' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_PRIMITIVES'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ],
        'libs' => {
          'SDL_gfx_primitives' => 1,
          'SDL' => 1
        }
      },
      'LayerX' => {
        'links' => [
          '-lSDL',
          '-lSDL_image'
        ],
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_IMAGE'
        ],
        'libs' => {
          'SDL' => 1,
          'SDL_image' => 1
        }
      },
      'GFX' => {
        'libs' => {
          'SDL' => 1,
          'SDL_gfx_primitives' => 1
        },
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ],
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_PRIMITIVES'
        ]
      },
      'TTF' => {
        'libs' => {
          'SDL' => 1,
          'SDL_ttf' => 1
        },
        'links' => [
          '-lSDL',
          '-lSDL_ttf'
        ],
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_TTF'
        ]
      },
      'VideoInfo' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'MixMusic' => {
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ],
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ],
        'libs' => {
          'SDL' => 1,
          'SDL_mixer' => 1
        }
      },
      'Rotozoom' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_GFX_ROTOZOOM'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_gfx'
        ],
        'libs' => {
          'SDL' => 1,
          'SDL_gfx_rotozoom' => 1
        }
      },
      'Joystick' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'Context' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_PANGO'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_Pango'
        ],
        'libs' => {
          'SDL' => 1,
          'SDL_Pango' => 1
        }
      },
      'Image' => {
        'links' => [
          '-lSDL',
          '-lSDL_image'
        ],
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_IMAGE'
        ],
        'libs' => {
          'SDL_image' => 1,
          'SDL' => 1
        }
      },
      'SDL' => {
        'libs' => {
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ]
      },
      'Color' => {
        'libs' => {
          'SDL' => 1
        },
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ]
      },
      'MixerMusic' => {
        'libs' => {
          'SDL_mixer' => 1,
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ]
      },
      'TTF_Font' => {
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_TTF'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_ttf'
        ],
        'libs' => {
          'SDL_ttf' => 1,
          'SDL' => 1
        }
      },
      'TimerX' => {
        'libs' => {
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ]
      },
      'MultiThread' => {
        'libs' => {
          'SDL' => 1
        },
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ]
      },
      'Palette' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'MixChunk' => {
        'libs' => {
          'SDL' => 1,
          'SDL_mixer' => 1
        },
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ]
      },
      'Mixer' => {
        'libs' => {
          'SDL_mixer' => 1,
          'SDL' => 1
        },
        'defines' => [
          '-DHAVE_SDL',
          '-DHAVE_SDL_MIXER'
        ],
        'links' => [
          '-lSDL',
          '-lSDL_mixer'
        ]
      },
      'Video' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'CDROM' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'Overlay' => {
        'defines' => [
          '-DHAVE_SDL'
        ],
        'links' => [
          '-lSDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      },
      'StateX' => {
        'links' => [
          '-lSDL'
        ],
        'defines' => [
          '-DHAVE_SDL'
        ],
        'libs' => {
          'SDL' => 1
        }
      }
    },
    'SDL_lib_translate' => {
      'SDL::Mixer::Effects' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDL::CD' => [
        'SDL'
      ],
      'SDL::Rect' => [
        'SDL'
      ],
      'SDL::MultiThread' => [
        'SDL'
      ],
      'SDL::Event' => [
        'SDL'
      ],
      'SDL::Mouse' => [
        'SDL'
      ],
      'SDL::GFX::Rotozoom' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDLx::Controller::State' => [
        'SDL'
      ],
      'SDLx::Controller::Interface' => [
        'SDL'
      ],
      'SDL::CDTrack' => [
        'SDL'
      ],
      'SDL::Mixer' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDL::GFX::FPSManager' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDL::Video' => [
        'SDL'
      ],
      'SDL::AudioCVT' => [
        'SDL'
      ],
      'SDL::AudioSpec' => [
        'SDL'
      ],
      'SDL::GFX::Primitives' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDL::Audio' => [
        'SDL'
      ],
      'SDL::CDROM' => [
        'SDL'
      ],
      'SDLx::Surface' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDL::GFX::Framerate' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDL::Mixer::Groups' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDLx::SFont' => [
        'SDL',
        'SDL_image'
      ],
      'SDL::Surface' => [
        'SDL'
      ],
      'SDLx::Validate' => [
        'SDL'
      ],
      'SDL::TTF::Font' => [
        'SDL',
        'SDL_ttf'
      ],
      'SDL::TTF' => [
        'SDL',
        'SDL_ttf'
      ],
      'SDL::Version' => [
        'SDL'
      ],
      'SDL::Cursor' => [
        'SDL'
      ],
      'SDL::Pango' => [
        'SDL',
        'SDL_Pango'
      ],
      'SDL::Palette' => [
        'SDL'
      ],
      'SDL::Mixer::Music' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDL::Events' => [
        'SDL'
      ],
      'SDL::PixelFormat' => [
        'SDL'
      ],
      'SDL::Time' => [
        'SDL'
      ],
      'SDL::Pango::Context' => [
        'SDL',
        'SDL_Pango'
      ],
      'SDLx::LayerManager' => [
        'SDL'
      ],
      'SDLx::Controller::Timer' => [
        'SDL'
      ],
      'SDL::GFX::BlitFunc' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDL::Mixer::MixChunk' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDL_perl' => [
        'SDL'
      ],
      'SDL::Overlay' => [
        'SDL'
      ],
      'SDL::Mixer::MixMusic' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDL::GFX::ImageFilter' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDL::Image' => [
        'SDL',
        'SDL_image'
      ],
      'SDL::RWOps' => [
        'SDL'
      ],
      'SDL::GFX' => [
        'SDL',
        'SDL_gfx'
      ],
      'SDL::Color' => [
        'SDL'
      ],
      'SDL::VideoInfo' => [
        'SDL'
      ],
      'SDL::Joystick' => [
        'SDL'
      ],
      'SDL::Mixer::Samples' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDL::Mixer::Channels' => [
        'SDL',
        'SDL_mixer'
      ],
      'SDLx::Layer' => [
        'SDL',
        'SDL_image'
      ]
    },
    'subsystems' => {
      'Cursor' => {
        'file' => {
          'to' => 'lib/SDL/Cursor.xs',
          'from' => 'src/Core/objects/Cursor.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'Time' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'to' => 'lib/SDL/Time.xs',
          'from' => 'src/Core/Time.xs'
        }
      },
      'Events' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/Events.xs',
          'to' => 'lib/SDL/Events.xs'
        }
      },
      'Pango' => {
        'file' => {
          'from' => 'src/Pango/Pango.xs',
          'to' => 'lib/SDL/Pango.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_Pango'
        ]
      },
      'MixerEffects' => {
        'file' => {
          'from' => 'src/Mixer/Effects.xs',
          'to' => 'lib/SDL/Mixer/Effects.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ]
      },
      'FPSManager' => {
        'file' => {
          'to' => 'lib/SDL/GFX/FPSManager.xs',
          'from' => 'src/GFX/FPSManager.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_gfx_framerate'
        ]
      },
      'Audio' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/Audio.xs',
          'to' => 'lib/SDL/Audio.xs'
        }
      },
      'LayerManagerX' => {
        'file' => {
          'to' => 'lib/SDLx/LayerManager.xs',
          'from' => 'src/SDLx/LayerManager.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'AudioSpec' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'to' => 'lib/SDL/AudioSpec.xs',
          'from' => 'src/Core/objects/AudioSpec.xs'
        }
      },
      'ValidateX' => {
        'file' => {
          'to' => 'lib/SDLx/Validate.xs',
          'from' => 'src/SDLx/Validate.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'PixelFormat' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/objects/PixelFormat.xs',
          'to' => 'lib/SDL/PixelFormat.xs'
        }
      },
      'Event' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/objects/Event.xs',
          'to' => 'lib/SDL/Event.xs'
        }
      },
      'AudioCVT' => {
        'file' => {
          'to' => 'lib/SDL/AudioCVT.xs',
          'from' => 'src/Core/objects/AudioCVT.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'Surface' => {
        'file' => {
          'from' => 'src/Core/objects/Surface.xs',
          'to' => 'lib/SDL/Surface.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'SurfaceX' => {
        'libraries' => [
          'SDL',
          'SDL_gfx_primitives'
        ],
        'file' => {
          'from' => 'src/SDLx/Surface.xs',
          'to' => 'lib/SDLx/Surface.xs'
        }
      },
      'MixerGroups' => {
        'file' => {
          'to' => 'lib/SDL/Mixer/Groups.xs',
          'from' => 'src/Mixer/Groups.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ]
      },
      'CD' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'to' => 'lib/SDL/CD.xs',
          'from' => 'src/Core/objects/CD.xs'
        }
      },
      'SFont' => {
        'libraries' => [
          'SDL',
          'SDL_image'
        ],
        'file' => {
          'from' => 'src/SDLx/SFont.xs',
          'to' => 'lib/SDLx/SFont.xs'
        }
      },
      'Rect' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'to' => 'lib/SDL/Rect.xs',
          'from' => 'src/Core/objects/Rect.xs'
        }
      },
      'Framerate' => {
        'libraries' => [
          'SDL',
          'SDL_gfx_framerate'
        ],
        'file' => {
          'from' => 'src/GFX/Framerate.xs',
          'to' => 'lib/SDL/GFX/Framerate.xs'
        }
      },
      'ImageFilter' => {
        'file' => {
          'from' => 'src/GFX/ImageFilter.xs',
          'to' => 'lib/SDL/GFX/ImageFilter.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_gfx_imagefilter'
        ]
      },
      'RWOps' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'to' => 'lib/SDL/RWOps.xs',
          'from' => 'src/Core/objects/RWOps.xs'
        }
      },
      'Mouse' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/Mouse.xs',
          'to' => 'lib/SDL/Mouse.xs'
        }
      },
      'InterfaceX' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'to' => 'lib/SDLx/Controller/Interface.xs',
          'from' => 'src/SDLx/Controller/Interface.xs'
        }
      },
      'BlitFunc' => {
        'file' => {
          'to' => 'lib/SDL/GFX/BlitFunc.xs',
          'from' => 'src/GFX/BlitFunc.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_gfx_blitfunc'
        ]
      },
      'Version' => {
        'file' => {
          'from' => 'src/Core/objects/Version.xs',
          'to' => 'lib/SDL/Version.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'CDTrack' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'to' => 'lib/SDL/CDTrack.xs',
          'from' => 'src/Core/objects/CDTrack.xs'
        }
      },
      'MixerChannels' => {
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ],
        'file' => {
          'from' => 'src/Mixer/Channels.xs',
          'to' => 'lib/SDL/Mixer/Channels.xs'
        }
      },
      'Rotozoom' => {
        'libraries' => [
          'SDL',
          'SDL_gfx_rotozoom'
        ],
        'file' => {
          'to' => 'lib/SDL/GFX/Rotozoom.xs',
          'from' => 'src/GFX/Rotozoom.xs'
        }
      },
      'MixMusic' => {
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ],
        'file' => {
          'to' => 'lib/SDL/Mixer/MixMusic.xs',
          'from' => 'src/Mixer/objects/MixMusic.xs'
        }
      },
      'GFX' => {
        'file' => {
          'from' => 'src/GFX/GFX.xs',
          'to' => 'lib/SDL/GFX.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_gfx_primitives'
        ]
      },
      'LayerX' => {
        'file' => {
          'to' => 'lib/SDLx/Layer.xs',
          'from' => 'src/SDLx/Layer.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_image'
        ]
      },
      'VideoInfo' => {
        'file' => {
          'from' => 'src/Core/objects/VideoInfo.xs',
          'to' => 'lib/SDL/VideoInfo.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'TTF' => {
        'file' => {
          'from' => 'src/TTF/TTF.xs',
          'to' => 'lib/SDL/TTF.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_ttf'
        ]
      },
      'MixerSamples' => {
        'file' => {
          'from' => 'src/Mixer/Samples.xs',
          'to' => 'lib/SDL/Mixer/Samples.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ]
      },
      'Primitives' => {
        'libraries' => [
          'SDL',
          'SDL_gfx_primitives'
        ],
        'file' => {
          'from' => 'src/GFX/Primitives.xs',
          'to' => 'lib/SDL/GFX/Primitives.xs'
        }
      },
      'MultiThread' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/MultiThread.xs',
          'to' => 'lib/SDL/MultiThread.xs'
        }
      },
      'Palette' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/objects/Palette.xs',
          'to' => 'lib/SDL/Palette.xs'
        }
      },
      'MixerMusic' => {
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ],
        'file' => {
          'from' => 'src/Mixer/Music.xs',
          'to' => 'lib/SDL/Mixer/Music.xs'
        }
      },
      'TimerX' => {
        'file' => {
          'to' => 'lib/SDLx/Controller/Timer.xs',
          'from' => 'src/SDLx/Timer.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'TTF_Font' => {
        'libraries' => [
          'SDL',
          'SDL_ttf'
        ],
        'file' => {
          'from' => 'src/TTF/objects/Font.xs',
          'to' => 'lib/SDL/TTF/Font.xs'
        }
      },
      'Image' => {
        'libraries' => [
          'SDL',
          'SDL_image'
        ],
        'file' => {
          'from' => 'src/Image.xs',
          'to' => 'lib/SDL/Image.xs'
        }
      },
      'Color' => {
        'file' => {
          'from' => 'src/Core/objects/Color.xs',
          'to' => 'lib/SDL/Color.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'SDL' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/SDL.xs',
          'to' => 'lib/SDL_perl.xs'
        }
      },
      'Context' => {
        'file' => {
          'to' => 'lib/SDL/Pango/Context.xs',
          'from' => 'src/Pango/objects/Context.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_Pango'
        ]
      },
      'Joystick' => {
        'file' => {
          'from' => 'src/Core/Joystick.xs',
          'to' => 'lib/SDL/Joystick.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'Overlay' => {
        'file' => {
          'to' => 'lib/SDL/Overlay.xs',
          'from' => 'src/Core/objects/Overlay.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'StateX' => {
        'file' => {
          'from' => 'src/SDLx/Controller/State.xs',
          'to' => 'lib/SDLx/Controller/State.xs'
        },
        'libraries' => [
          'SDL'
        ]
      },
      'Video' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/Video.xs',
          'to' => 'lib/SDL/Video.xs'
        }
      },
      'CDROM' => {
        'libraries' => [
          'SDL'
        ],
        'file' => {
          'from' => 'src/Core/CDROM.xs',
          'to' => 'lib/SDL/CDROM.xs'
        }
      },
      'MixChunk' => {
        'file' => {
          'from' => 'src/Mixer/objects/MixChunk.xs',
          'to' => 'lib/SDL/Mixer/MixChunk.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ]
      },
      'Mixer' => {
        'file' => {
          'to' => 'lib/SDL/Mixer.xs',
          'from' => 'src/Mixer/Mixer.xs'
        },
        'libraries' => [
          'SDL',
          'SDL_mixer'
        ]
      }
    }
  },
  {},
  {}
];
$x; }