Free windows version software for linux

DBIx::Version is a Perl extension for getting database software name and version.

SYNOPSIS

use DBIx::Version;

my $dbh = DBI->connect( ... );
my ($dbname, $dbver, $dbverfull) = DBIx::Version::Version($dbh);

DBIx::Version lets you query which database software and version you are connected to.

Return Examples:

(undef, undef, undef)
(mysql, 4.0.17, 4.0.17-standard-log)
(postgresql, 7.4.1, PostgreSQL 7.4.1 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.3.2 20031107 (Red Hat Linux 3.3.2-2))
(oracle, 8.1.7.0.0, 8.1.7.0.0)
(sqlserver, 8.00.384, Microsoft SQL Server 2000 - 8.00.384 (Intel X86)
May 23 2001 00:02:52
Copyright (c) 1988-2000 Microsoft Corporation
Standard Edition on Windows NT 5.0 (Build 2195: Service Pack 2))
(sybase,12.5.0.1,Adaptive Server Enterprise/12.5.0.1/SWR 9982 IR/P/Sun_svr4/OS 5.8/rel12501/1776/ 64-bit/FBO/Tue Feb 26 01:22:10 2002)
(sybase,12.5.0.2,Adaptive Server Enterprise/12.5.0.2/EBF 14000 IR/P/Sun_svr4/OS 5.8/rel12502/1776/64-bit/FBO/Tue Jun 4 01:22:10 2002)

Answer 1: This module is useful for cross-platform coding, and in environments like shared hosting where you actually didnt install the database yourself and are curious.

Sort::Versions is a Perl 5 module for sorting of revision-like numbers.

SYNOPSIS

use Sort::Versions;
@l = sort { versioncmp($a, $b) } qw( 1.2 1.2.0 1.2a.0 1.2.a 1.a 02.a );

...

use Sort::Versions;
print lower if versioncmp(1.2, 1.2a) == -1;

...

use Sort::Versions;
%h = (1 => d, 2 => c, 3 => b, 4 => a);
@h = sort { versioncmp($h{$a}, $h{$b}) } keys %h;

Sort::Versions allows easy sorting of mixed non-numeric and numeric strings, like the version numbers that many shared library systems and revision control packages use. This is quite useful if you are trying to deal with shared libraries. It can also be applied to applications that intersperse variable-width numeric fields within text. Other applications can undoubtedly be found.

For an explanation of the algorithm, its simplest to look at these examples:

1.1 < 1.2
1.1a < 1.2
1.1 < 1.1.1
1.1 < 1.1a
1.1.a < 1.1a
1 < a
a < b
1 < 2
1.1-3 < 1.1-4
1.1-5 < 1.1.6

More precisely (but less comprehensibly), the two strings are treated as subunits delimited by periods or hyphens. Each subunit can contain any number of groups of digits or non-digits. If digit groups are being compared on both sides, a numeric comparison is used, otherwise a ASCII ordering is used. A group or subgroup with more units will win if all comparisons are equal. A period binds digit groups together more tightly than a hyphen.

Some packages use a different style of version numbering: a simple real number written as a decimal. Sort::Versions has limited support for this style: when comparing two subunits which are both digit groups, if either subunit has a leading zero, then both are treated like digits after a decimal point. So for example:

0002 < 1
1.06 < 1.5

This wont always work, because there wont always be a leading zero in real-number style version numbers. There is no way for Sort::Versions to know which style was intended. But a lot of the time it will do the right thing. If you are making up version numbers, the style with (possibly) more than one dot is the style to use.

USAGE

The function versioncmp() takes two arguments and compares them like cmp. With perl 5.6 or later, you can also use this function directly in sorting:

@l = sort versioncmp qw(1.1 1.2 1.0.3);

The function versions() can be used directly as a sort function even on perl 5.005 and earlier, but its use is deprecated.

Module::Versions is a Perl module to handle versions of loaded modules with flexible result interface.

SYNOPSIS

use Module::Versions;

# Simple Interface
list Module::Versions; # prints formatted results to STDOUT
Module::Versions->list; # prints formatted results to STDOUT

# Shortcuts
$vers = get Module::Versions; # retrieves loaded modules

$vers = Module::Versions->get; # retrieves loaded modules

$array = Module::Versions->ARRAY; # returns array with version infos
$hash = Module::Versions->HASH; # returns hash with version infos

$list = Module::Versions->SCALAR; # returns text list with version infos
$csv = Module::Versions->CSV; # returns csv list with version infos
$xml = Module::Versions->XML; # returns xml struct with version infos
$xsd = Module::Versions->XSD; # returns xml schema of version infos
$dtd = Module::Versions->DTD; # returns DTD of version infos

# Individual Parameters
$vers = Module::Versions # retrieves mods and vars as defined
->new($mods,$vars)
->get($criteria);

$vers->list($fd,$mask); # prints formatted results to file
$vers->list($fd,$preform); # prints preformatted results to file
$vers->list($fd,&cb); # prints serialied results as handled
# in callback routine
$vers->data(&cb); # returns transformed results as
# defined in callback routine
# Individual formatted output
list Module::Versions(*LOG, %5d %1s %-20s %10s %-16s);
# prints individually formatted
# results to LOG
list Module::Versions(*DBIMPORT, %s|%s|%s);
# prints individually formatted
# results to Database Import file

list Module::Versions(*FD, SCALAR);# prints text list results to file
list Module::Versions(*FD, CSV); # prints csv list results to file
list Module::Versions(*FD, XML); # prints xml struct results to file
list Module::Versions(*FD, XSD); # prints xml schema to file
list Module::Versions(*FD, DTD); # prints DTD to file

list Module::Versions(*FD, ARRAY); # prints serialized results to file
list Module::Versions(*FD, HASH); # prints serialized results to file

Module::Versions->list(*LOG); # prints formatted results to LOG

# Pretty Compact
Module::Versions->list # prints formatted results on STDOUT
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*XSD,XSD) # prints xml schema to XSD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*DTD,DTD) # prints DTD to DTD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions handles versions of loaded modules with a flexible result interface. The main goal is to get as much version informations as possible about a module or module list with a simple call interface and an absolutely flexible result interface. Module::Versions handles *loaded* and *loadable* modules.

The motivation for writing this module was the need for better support facilities to get informations about the used modules and versions in the productivity environment. Module::Versions allows shipping applications basically with something like a -version option (See Getopt::Long) but with expanded functions.

Module::Versions tries to read the loaded/loadable modules $VERSION. For extended purposes any private project version variables can be fetched ($_VERSION, $version, $REV, etc.).

Module::Versions has a flexible result interface to satisfy different needs: results can be lists and data structures with different formats - pre-formed ARRAY, HASH, SCALAR, CSV, XML/XSD/DTD and a full flexible user callback interface.
It is for example very simple to print a good formatted version list to the console and save a version.xml file (in conjunction with an xsd-schema) at the same time with an absolutely minimum of coding (SYNOPSIS, Pretty Compact) .
Module::Versions tries to load version.pm to support Perl 5.10.0s $VERSION formatting.

pvswitch is a very tiny program which makes it possible to use different program installations on one machine flawlessly.
Its flexibility is intended for people who need to run programs against different interpreter versions.
But it can also be used for different purposes like switching the version of a compiler, text editor, mail reader, browser, whatever.
It is most useful for developers of interpreter based programs which are started via a hash-bang line (#!).
The following example explains the usage for perl programs, but the very same is true for all other interpreter languages.
If you install two or more different perl versions on your machine, you could just call the respective perl binary you want to use..
perl myscript.pl
/path/to/another/perl myscript.pl
This works fine, although it isnt very convenient. However if you are starting your program using the hash-bang line like
#! /usr/bin/perl
and then just start it by
./myscript.pl
you would need to change the file itself to use another perl version. Again it is possible, but not very convenient.
And here comes pvswitch: its purpose is to make such situations convenient. Further it solve some problems which come up if multiple people want to use different perl versions. pvswitch allows even to run one program in two shells with different perl versions.
This is possible because pvswitch uses a environment variable to select the interpreter version to use. This environment variable can be set in different sessions independently.
pvswitch is installed as new program binary (e.g. perl) the old one will be renamed to program.pvswitch.
Now every time you execute a this program (e.g. perl), pvswitch is executed. It doesnt matter how you start the program...
perl myscript.pl
./myscript.pl # if it has a hash-bang #! /usr/bin/perl
for both cases the pvswitch binary will be executed, pvswitch will than check for the environment variable PVSWITCH_PERL_BINARY (if you are running perl), if it is found it tries to find this key in the configuration file pvswitch.conf and execute the program which is configured for the version configured set in the environment variable (e.g. perl.pvswitch).
So it just executes the real program (e.g. perl interpreter). Depending on the environment a different version might be selected.
There are some convenient tools (e.g. perlver, pvconfig) to configure this.
Enhancements:
- Fixed a bug which could cause segmentation violation.

Minesweeper is a Java game clone from the Windows version of Minesweeper.

Minesweeper is a game written by Chris Dailey in Java using Swing.

Version 1.1 features the basic game play.

The following table shows what the mouse clicks on squares do while the game is started.

COVERED

Set the square to UNCOVERED.
If there is a mine, the game ends (lose).
If all empty squares are uncovered, the game ends (win).
Otherwise the game continues. Set the square to FLAGGED.

UNCOVERED

Nothing if the number of flags in adjacent squares equals the number in the uncovered square
UNCOVER adjacent covered squares
else
temporarily highlight adjacent covered squares

FLAGGED

Nothing Set the square to QUESTIONED.

QUESTIONED

Nothing Set the square to COVERED.

FindIt NIX project is a clone of a great find-the-difference game.
FindItNIX is a clone of the Windows game FindItXP. The goal is to spot the 5 differences between 2 images within a certain amount of time. The quicker you find them, the higher the bonus will be.
FindItNIX features high scores compatible with those of the Windows version and over 1200 levels available on the Internet.
Enhancements:
- Implemented hack in Makefile so the program links to the libqt-2.x.x.so in stead of the 3.x libraries which cause an unknown problem. Until I fixed this, and qt-2.x.x is
- still on your system you wont have any problems compiling nymore.
- Some minor documentation updates.