Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
Copyright Info
Terms of Use
Privacy Info
Masthead / Impressum
Your Account

Private Messages

News Archive
Submit News
User Articles
Web Links


The Web

Who's Online
There are currently, 112 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here




       These are instructions for building Perl under Windows
       9x/NT/2000/XP on the Intel x86 and Itanium architectures.


       Before you start, you should glance through the README
       file found in the top-level directory to which the Perl
       distribution was extracted.  Make sure you read and under­
       stand the terms under which this software is being dis­

       Also make sure you read "BUGS AND CAVEATS" below for the
       known limitations of this port.

       The INSTALL file in the perl top-level has much informa­
       tion that is only relevant to people building Perl on
       Unix-like systems.  In particular, you can safely ignore
       any information that talks about "Configure".

       You may also want to look at two other options for build­
       ing a perl that will work on Windows NT:  the README.cyg­
       win and README.os2 files, each of which give a different
       set of rules to build a Perl that will work on Win32 plat­
       forms.  Those two methods will probably enable you to
       build a more Unix-compatible perl, but you will also need
       to download and use various other build-time and run-time
       support software described in those files.

       This set of instructions is meant to describe a so-called
       "native" port of Perl to Win32 platforms.  This includes
       both 32-bit and 64-bit Windows operating systems.  The
       resulting Perl requires no additional software to run
       (other than what came with your operating system).  Cur­
       rently, this port is capable of using one of the following
       compilers on the Intel x86 architecture:

             Borland C++               version 5.02 or later
             Microsoft Visual C++      version 4.2 or later
             Mingw32 with GCC          version 2.95.2 or better

       The last of these is a high quality freeware compiler.
       Support for it is still experimental.  (Older versions of
       GCC are known not to work.)

       This port can also be built on the Intel IA64 using:

             Microsoft Platform SDK    Nov 2001 (64-bit compiler and tools)

       The MS Platform SDK can be downloaded from

       This port fully supports MakeMaker (the set of modules
           under Windows NT/2000/XP, nmake will work.  All other
           builds need dmake.

           dmake is a freely available make that has very nice
           macro features and parallelability.

           A port of dmake for Windows is available from:


           (This is a fixed version of the original dmake sources
           obtained from http://www.wticorp.com/  As of version
           4.1PL1, the original sources did not build as shipped
           and had various other problems.  A patch is included
           in the above fixed version.)

           Fetch and install dmake somewhere on your path (follow
           the instructions in the README.NOW file).

           There exists a minor coexistence problem with dmake
           and Borland C++ compilers.  Namely, if a distribution
           has C files named with mixed case letters, they will
           be compiled into appropriate .obj-files named with all
           lowercase letters, and every time dmake is invoked to
           bring files up to date, it will try to recompile such
           files again.  For example, Tk distribution has a lot
           of such files, resulting in needless recompiles every
           time dmake is invoked.  To avoid this, you may use the
           script "sync_ext.pl" after a successful build.  It is
           available in the win32 subdirectory of the Perl source

       Command Shell
           Use the default "cmd" shell that comes with NT.  Some
           versions of the popular 4DOS/NT shell have incompati­
           bilities that may cause you trouble.  If the build
           fails under that shell, try building again with the
           cmd shell.

           The nmake Makefile also has known incompatibilities
           with the "command.com" shell that comes with Windows
           9x.  You will need to use dmake and makefile.mk to
           build under Windows 9x.

           The surest way to build it is on Windows NT/2000/XP,
           using the cmd shell.

           Make sure the path to the build directory does not
           contain spaces.  The build usually works in this cir­
           cumstance, but some tests will fail.

       Borland C++
           whatever the directory name under which the Visual C
           dmake configuration lives) in your environment and
           edit win32/config.vc to change "make=nmake" into
           "make=dmake".  The latter step is only essential if
           you want to use dmake as your default make for build­
           ing extensions using MakeMaker.

       Microsoft Platform SDK 64-bit Compiler
           The nmake that comes with the Platform SDK will suf­
           fice for building Perl.  Make sure you are building
           within one of the "Build Environment" shells available
           after you install the Platform SDK from the Start

       MinGW32 with gcc
           The latest release of MinGW (at the time of writing)
           is 2.0.0, which comes with gcc-3.2, and can be down­
           loaded here:


           Perl compiles with earlier releases of gcc (2.95 and
           up) that can be downloaded from the same place. If you
           use gcc-3.2, comment out the line:

               USE_GCC_V3_2        *= define

           in win32\makefile.mk

           You also need dmake.  See "Make" above on how to get

       MinGW release 1
           The MinGW-1.1 bundle comes with gcc-2.95.3.

           Make sure you install the binaries that work with
           MSVCRT.DLL as indicated in the README for the GCC bun­
           dle.  You may need to set up a few environment vari­
           ables (usually ran from a batch file).

           There are a couple of problems with the version of
           gcc-2.95.2-msvcrt.exe released 7 November 1999:

           *   It left out a fix for certain command line quotes.
               To fix this, be sure to download and install the
               file fixes/quote-fix-msvcrt.exe from the above ftp

           *   The definition of the fpos_t type in stdio.h may
               be wrong.  If your stdio.h has this problem, you
               will see an exception when running the test
               t/lib/io_xs.t.  To fix this, change the typedef

           the perl toplevel.  This directory contains a "Make­
           file" that will work with versions of nmake that come
           with Visual C++ or the Platform SDK, and a dmake
           "makefile.mk" that will work for all supported compil­
           ers.  The defaults in the dmake makefile are setup to
           build using Microsoft Visual C++ 6.0 or newer.

       ·   Edit the makefile.mk (or Makefile, if you're using
           nmake) and change the values of INST_DRV and INST_TOP.
           You can also enable various build flags.  These are
           explained in the makefiles.

           You will have to make sure that CCTYPE is set cor­
           rectly and that CCHOME points to wherever you
           installed your compiler.

           The default value for CCHOME in the makefiles for
           Visual C++ may not be correct for some versions.  Make
           sure the default exists and is valid.

           If you have either the source or a library that con­
           tains des_fcrypt(), enable the appropriate option in
           the makefile.  A ready-to-use version of fcrypt.c,
           based on the version originally written by Eric Young
           at ftp://ftp.funet.fi/pub/crypt/mirrors/dsi/libdes/,
           is bundled with the distribution. Set CRYPT_SRC to
           fcrypt.c to use this version.  Alternatively, if you
           have built a library that contains des_fcrypt(), you
           can set CRYPT_LIB to point to the library name.  Perl
           will also build without des_fcrypt(), but the crypt()
           builtin will fail at run time.

           Be sure to read the instructions near the top of the
           makefiles carefully.

       ·   Type "dmake" (or "nmake" if you are using that make).

           This should build everything.  Specifically, it will
           create perl.exe, perl58.dll at the perl toplevel, and
           various other extension dll's under the lib\auto
           directory.  If the build fails for any reason, make
           sure you have done the previous steps correctly.

       Testing Perl on Win32

       Type "dmake test" (or "nmake test").  This will run most
       of the tests from the testsuite (many tests will be

       There should be no test failures when running under Win­
       dows NT/2000/XP.  Many tests will fail under Windows 9x
       due to the inferior command shell.
       directory (usually somewhere like C:\WINNT\SYSTEM32) and
       rerun the test.

       If you're using Borland compiler versions 5.2 and below,
       you may run into problems finding the correct header files
       when building extensions.  For example, building the "Tk"
       extension may fail because both perl and Tk contain a
       header file called "patchlevel.h".  The latest Borland
       compiler (v5.5) is free of this misbehaviour, and it even
       supports an option -VI- for backward (bugward) compatibil­
       ity for using the old Borland search algorithm  to locate
       header files.

       If you run the tests on a FAT partition, you may see some
       failures for "link()" related tests:

           Failed Test                     Stat Wstat Total Fail  Failed  List

           ../ext/IO/lib/IO/t/io_dup.t                    6    4  66.67%  2-5
           ../lib/File/Temp/t/mktemp.t                    9    1  11.11%  2
           ../lib/File/Temp/t/posix.t                     7    1  14.29%  3
           ../lib/File/Temp/t/security.t                 13    1   7.69%  2
           ../lib/File/Temp/t/tempfile.t                 20    2  10.00%  2 4
           comp/multiline.t                               6    2  33.33%  5-6
           io/dup.t                                       8    6  75.00%  2-7
           op/write.t                                    47    7  14.89%  1-3 6 9-11

       Testing on NTFS avoids these errors.

       Furthermore, you should make sure that during "make test"
       you do not have any GNU tool packages in your path: some
       toolkits like Unixutils include some tools ("type" for
       instance) which override the Windows ones and makes tests
       fail. Remove them from your path while testing to avoid
       these errors.

       Please report any other failures as described under "BUGS
       AND CAVEATS".

       Installation of Perl on Win32

       Type "dmake install" (or "nmake install").  This will put
       the newly built perl and the libraries under whatever
       "INST_TOP" points to in the Makefile.  It will also
       install the pod documentation under "$INST_TOP\$VER­
       SION\lib\pod" and HTML versions of the same under
       "$INST_TOP\$VERSION\lib\pod\html".  To use the Perl you
       just installed, you will need to add two components to
       your PATH environment variable, "$INST_TOP\$VERSION\bin"
       and "$INST_TOP\$VERSION\bin\$ARCHNAME".  For example:

           set PATH c:\perl\5.6.0\bin;c:\perl\5.6.0\bin\MSWin32-x86;%PATH%
           thing additional to start using that perl (except add
           its location to your PATH variable).

           If you put extensions in unusual places, you can set
           PERL5LIB to a list of paths separated by semicolons
           where you want perl to look for libraries.  Look for
           descriptions of other environment variables you can
           set in perlrun.

           You can also control the shell that perl uses to run
           system() and backtick commands via PERL5SHELL.  See

           Perl does not depend on the registry, but it can look
           up certain default values if you choose to put them
           there.  Perl attempts to read entries from "HKEY_CUR­
           RENT_USER\Software\Perl" and "HKEY_LOCAL_MACHINE\Soft­
           ware\Perl".  Entries in the former override entries in
           the latter.  One or more of the following entries (of
           type REG_SZ or REG_EXPAND_SZ) may be set:

               lib-$]              version-specific standard library path to add to @INC
               lib                 standard library path to add to @INC
               sitelib-$]          version-specific site library path to add to @INC
               sitelib             site library path to add to @INC
               vendorlib-$]        version-specific vendor library path to add to @INC
               vendorlib           vendor library path to add to @INC
               PERL*               fallback for all %ENV lookups that begin with "PERL"

           Note the $] in the above is not literal.  Substitute
           whatever version of perl you want to honor that entry,
           e.g. 5.6.0.  Paths must be separated with semicolons,
           as usual on win32.

       File Globbing
           By default, perl handles file globbing using the
           File::Glob extension, which provides portable glob­

           If you want perl to use globbing that emulates the
           quirks of DOS filename conventions, you might want to
           consider using File::DosGlob to override the internal
           glob() implementation.  See File::DosGlob for details.

       Using perl from the command line
           If you are accustomed to using perl from various com­
           mand-line shells found in UNIX environments, you will
           be less than pleased with what Windows offers by way
           of a command shell.

           The crucial thing to understand about the Windows
           environment is that the command line you type in is
           you are using a non-standard shell, be inconsistent).
           The only (useful) quote character is the double quote
           (").  It can be used to protect spaces and other spe­
           cial characters in arguments.

           The Windows NT documentation has almost no description
           of how the quoting rules are implemented, but here are
           some general observations based on experiments: The C
           runtime breaks arguments at spaces and passes them to
           programs in argc/argv.  Double quotes can be used to
           prevent arguments with spaces in them from being split
           up.  You can put a double quote in an argument by
           escaping it with a backslash and enclosing the whole
           argument within double quotes.  The backslash and the
           pair of double quotes surrounding the argument will be
           stripped by the C runtime.

           The file redirection characters "<", ">", and "|" can
           be quoted by double quotes (although there are sugges­
           tions that this may not always be true).  Single
           quotes are not treated as quotes by the shell or the C
           runtime, they don't get stripped by the shell (just to
           make this type of quoting completely useless).  The
           caret "^" has also been observed to behave as a quot­
           ing character, but this appears to be a shell feature,
           and the caret is not stripped from the command line,
           so Perl still sees it (and the C runtime phase does
           not treat the caret as a quote character).

           Here are some examples of usage of the "cmd" shell:

           This prints two doublequotes:

               perl -e "print '\"\"' "

           This does the same:

               perl -e "print \"\\\"\\\"\" "

           This prints "bar" and writes "foo" to the file

               perl -e "print 'foo'; print STDERR 'bar'" > blurch

           This prints "foo" ("bar" disappears into nowhereland):

               perl -e "print 'foo'; print STDERR 'bar'" 2> nul

           This prints "bar" and writes "foo" into the file

               perl -e "print 'foo'; print STDERR 'bar'" 1> blurch

           Discovering the usefulness of the "command.com" shell
           on Windows 9x is left as an exercise to the reader :)

           One particularly pernicious problem with the 4NT com­
           mand shell for Windows NT is that it (nearly) always
           treats a % character as indicating that environment
           variable expansion is needed.  Under this shell, it is
           therefore important to always double any % characters
           which you want Perl to see (for example, for hash
           variables), even when they are quoted.

       Building Extensions
           The Comprehensive Perl Archive Network (CPAN) offers a
           wealth of extensions, some of which require a C com­
           piler to build.  Look in http://www.cpan.org/ for more
           information on CPAN.

           Note that not all of the extensions available from
           CPAN may work in the Win32 environment; you should
           check the information at http://testers.cpan.org/
           before investing too much effort into porting modules
           that don't readily build.

           Most extensions (whether they require a C compiler or
           not) can be built, tested and installed with the stan­
           dard mantra:

               perl Makefile.PL
               $MAKE test
               $MAKE install

           where $MAKE is whatever 'make' program you have con­
           figured perl to use.  Use "perl -V:make" to find out
           what this is.  Some extensions may not provide a test­
           suite (so "$MAKE test" may not do anything or fail),
           but most serious ones do.

           It is important that you use a supported 'make' pro­
           gram, and ensure Config.pm knows about it.  If you
           don't have nmake, you can either get dmake from the
           location mentioned earlier or get an old version of
           nmake reportedly available from:


           Another option is to use the make written in Perl,
           available from CPAN.


           to use, edit Config.pm to fix it.

           If a module implements XSUBs, you will need one of the
           supported C compilers.  You must make sure you have
           set up the environment for the compiler for command-
           line compilation.

           If a module does not build for some reason, look care­
           fully for why it failed, and report problems to the
           module author.  If it looks like the extension build­
           ing support is at fault, report that with full details
           of how the build failed using the perlbug utility.

       Command-line Wildcard Expansion
           The default command shells on DOS descendant operating
           systems (such as they are) usually do not expand wild­
           card arguments supplied to programs.  They consider it
           the application's job to handle that.  This is com­
           monly achieved by linking the application (in our
           case, perl) with startup code that the C runtime
           libraries usually provide.  However, doing that
           results in incompatible perl versions (since the
           behavior of the argv expansion code differs depending
           on the compiler, and it is even buggy on some compil­
           ers).  Besides, it may be a source of frustration if
           you use such a perl binary with an alternate shell
           that *does* expand wildcards.

           Instead, the following solution works rather well. The
           nice things about it are 1) you can start using it
           right away; 2) it is more powerful, because it will do
           the right thing with a pattern like */*/*.c; 3) you
           can decide whether you do/don't want to use it; and 4)
           you can extend the method to add any customizations
           (or even entirely different kinds of wildcard expan­

                   C:\> copy con c:\perl\lib\Wild.pm
                   # Wild.pm - emulate shell @ARGV expansion on shells that don't
                   use File::DosGlob;
                   @ARGV = map {
                                 my @g = File::DosGlob::glob($_) if /[*?]/;
                                 @g ? @g : $_;
                               } @ARGV;
                   C:\> set PERL5OPT=-MWild
                   C:\> perl -le "for (@ARGV) { print }" */*/perl*.c

           the C runtime's command line wildcard expansion built
           into perl binary.  The resulting binary will always
           expand unquoted command lines, which may not be what
           you want if you use a shell that does that for you.
           The expansion done is also somewhat less powerful than
           the approach suggested above.

       Win32 Specific Extensions
           A number of extensions specific to the Win32 platform
           are available from CPAN.  You may find that many of
           these extensions are meant to be used under the
           Activeware port of Perl, which used to be the only
           native port for the Win32 platform.  Since the Active­
           ware port does not have adequate support for Perl's
           extension building tools, these extensions typically
           do not support those tools either and, therefore, can­
           not be built using the generic steps shown in the pre­
           vious section.

           To ensure smooth transitioning of existing code that
           uses the ActiveState port, there is a bundle of Win32
           extensions that contains all of the ActiveState exten­
           sions and most other Win32 extensions from CPAN in
           source form, along with many added bugfixes, and with
           MakeMaker support.  This bundle is available at:


           See the README in that distribution for building and
           installation instructions.  Look for later versions
           that may be available at the same location.

       Notes on 64-bit Windows
           Windows .NET Server supports the LLP64 data model on
           the Intel Itanium architecture.

           The LLP64 data model is different from the LP64 data
           model that is the norm on 64-bit Unix platforms.  In
           the former, "int" and "long" are both 32-bit data
           types, while pointers are 64 bits wide.  In addition,
           there is a separate 64-bit wide integral type,
           "__int64".  In contrast, the LP64 data model that is
           pervasive on Unix platforms provides "int" as the
           32-bit type, while both the "long" type and pointers
           are of 64-bit precision.  Note that both models pro­
           vide for 64-bits of addressability.

           64-bit Windows running on Itanium is capable of run­
           ning 32-bit x86 binaries transparently.  This means
           that you could use a 32-bit build of Perl on a 64-bit
           system.  Given this, why would one want to build a
           64-bit build of Perl?  Here are some reasons why you

       Perl scripts on UNIX use the "#!" (a.k.a "shebang") line
       to indicate to the OS that it should execute the file
       using perl.  Win32 has no comparable means to indicate
       arbitrary files are executables.

       Instead, all available methods to execute plain text files
       on Win32 rely on the file "extension".  There are three
       methods to use this to execute perl scripts:

       1       There is a facility called "file extension associ­
               ations" that will work in Windows NT 4.0.  This
               can be manipulated via the two commands "assoc"
               and "ftype" that come standard with Windows NT
               4.0.  Type "ftype /?" for a complete example of
               how to set this up for perl scripts (Say what?
               You thought Windows NT wasn't perl-ready? :).

       2       Since file associations don't work everywhere, and
               there are reportedly bugs with file associations
               where it does work, the old method of wrapping the
               perl script to make it look like a regular batch
               file to the OS, may be used.  The install process
               makes available the "pl2bat.bat" script which can
               be used to wrap perl scripts into batch files.
               For example:

                       pl2bat foo.pl

               will create the file "FOO.BAT".  Note "pl2bat"
               strips any .pl suffix and adds a .bat suffix to
               the generated file.

               If you use the 4DOS/NT or similar command shell,
               note that "pl2bat" uses the "%*" variable in the
               generated batch file to refer to all the command
               line arguments, so you may need to make sure that
               construct works in batch files.  As of this writ­
               ing, 4DOS/NT users will need a "ParameterChar = *"
               statement in their 4NT.INI file or will need to
               execute "setdos /p*" in the 4DOS/NT startup file
               to enable this to work.

       3       Using "pl2bat" has a few problems:  the file name
               gets changed, so scripts that rely on $0 to find
               what they must do may not run properly; running
               "pl2bat" replicates the contents of the original
               script, and so this process can be maintenance
               intensive if the originals get updated often.  A
               different approach that avoids both problems is

               A script called "runperl.bat" is available that
               perl", and type "runperl".  Explain the observed
               behavior, or lack thereof. :) Hint: .gnidnats
               llits er'uoy fi ,"lrepnur" eteled :tniH

       Miscellaneous Things
               A full set of HTML documentation is installed, so
               you should be able to use it if you have a web
               browser installed on your system.

               "perldoc" is also a useful tool for browsing
               information contained in the documentation, espe­
               cially in conjunction with a pager like "less"
               (recent versions of which have Win32 support).
               You may have to set the PAGER environment variable
               to use a specific pager.  "perldoc -f foo" will
               print information about the perl operator "foo".

               One common mistake when using this port with a GUI
               library like "Tk" is assuming that Perl's normal
               behavior of opening a command-line window will go
               away.  This isn't the case.  If you want to start
               a copy of "perl" without opening a command-line
               window, use the "wperl" executable built during
               the installation process.  Usage is exactly the
               same as normal "perl" on Win32, except that
               options like "-h" don't work (since they need a
               command-line window to print to).

               If you find bugs in perl, you can run "perlbug" to
               create a bug report (you may have to send it manu­
               ally if "perlbug" cannot find a mailer on your


       Norton AntiVirus interferes with the build process, par­
       ticularly if set to "AutoProtect, All Files, when Opened".
       Unlike large applications the perl build process opens and
       modifies a lot of files. Having the the AntiVirus scan
       each and every one slows build the process significantly.
       Worse, with PERLIO=stdio the build process fails with
       peculiar messages as the virus checker interacts badly
       with miniperl.exe writing configure files (it seems to
       either catch file part written and treat it as suspicious,
       or virus checker may have it "locked" in a way which
       inhibits miniperl updating it). The build does complete

          set PERLIO=perlio

       but that may be just luck. Other AntiVirus software may
       have similar issues.

       full list.

       Signal handling may not behave as on Unix platforms (where
       it doesn't exactly "behave", either :).  For instance,
       calling "die()" or "exit()" from signal handlers will
       cause an exception, since most implementations of "sig­
       nal()" on Win32 are severely crippled.  Thus, signals may
       work only for simple things like setting a flag variable
       in the handler.  Using signals under this port should cur­
       rently be considered unsupported.

       Please send detailed descriptions of any problems and
       solutions that you may find to <perlbug@perl.com>, along
       with the output produced by "perl -V".


       Gary Ng <71564.1743@CompuServe.COM>
       Gurusamy Sarathy <gsar@activestate.com>
       Nick Ing-Simmons <nick@ing-simmons.net>

       This document is maintained by Gurusamy Sarathy.




       This port was originally contributed by Gary Ng around
       5.003_24, and borrowed from the Hip Communications port
       that was available at the time.  Various people have made
       numerous and sundry hacks since then.

       Borland support was added in 5.004_01 (Gurusamy Sarathy).

       GCC/mingw32 support was added in 5.005 (Nick Ing-Simmons).

       Support for PERL_OBJECT was added in 5.005 (ActiveState
       Tool Corp).

       Support for fork() emulation was added in 5.6 (ActiveState
       Tool Corp).

       Win9x support was added in 5.6 (Benjamin Stuhl).

       Support for 64-bit Windows added in 5.8 (ActiveState

       Last updated: 20 April 2002

perl v5.8.1                 2003-09-02               PERLWIN32(1)



Security Code
Security Code
Type Security Code

Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!

Amazon Wish List

Did You Know?
The Linux Tutorial welcomes your suggestions and ideas.


Tell a Friend About Us

Bookmark and Share

Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.13 Seconds