Ports Search

Devel::CallChecker makes some new features of the Perl 5.14.0 C API available to XS modules running on older versions of Perl. The features are centred around the function cv_set_call_checker, which allows XS code to attach a magical annotation to a Perl subroutine, resulting in resolvable calls to that subroutine being mutated at compile time by arbitrary C code. This module makes cv_set_call_checker and several supporting functions available. (It is possible to achieve the effect of cv_set_call_checker from XS code on much earlier Perl versions, but it is painful to achieve without the centralised facility.) Devel::CallCheckerprovides the implementation of the functions at runtime (on Perls where they are not provided by the core). It also, at compile time, supplies the C header file and link library which provide access to the functions. In normal use, "callchecker0_h" and "callchecker_linkable" should be called at build time (not authoring time) for the module that wishes to use the C functions.

Expect::Simple is a wrapper around the Expect module which should suffice for simple applications. It hides most of the Expect machinery; the Expect object is available for tweaking if need be. Generally, one starts by creating an Expect::Simple object using new. This will start up the target program, and will wait until one of the specified prompts is output by the target. At that point the caller should send() commands to the program; the results are available via the before, after, match_str, and match_idx methods. Since Expect simulates a terminal, there will be extra \r characters at the end of each line in the result (on UNIX at least). This is easily fixed: ($res = $obj->before) =~ tr/\r//d; @lines = split( "\n", $res ); This is not done automatically. Exceptions will be thrown on error (match with /Expect::Simple/). Errors from Expect are available via the error_expect method. More human readable errors are available via the error method. The connection is automatically broken (by sending the specified disconnect command to the target) when the Expect::Simple object is destroyed.

This module implements asynchronous I/O using whatever means your operating system supports. Asynchronous means that operations that can normally block your program (e.g. reading from disk) will be done asynchronously: the operation will still block, but you can do something else in the meantime. This is extremely useful for programs that need to stay interactive even when doing heavy I/O (GUI programs, high performance network servers etc.), but can also be used to easily do operations in parallel that are normally done sequentially, e.g. stat'ing many files, which is much faster on a RAID volume or over NFS when you do a number of stat operations concurrently. While most of this works on all types of file descriptors (for example sockets), using these functions on file descriptors that support nonblocking operation (again, sockets, pipes etc.) is very inefficient or might not work (aio_read fails on sockets/pipes/fifos). Use an event loop for that (such as the Event module): IO::AIO will naturally fit into such an event loop itself.

Perl module to prevent leakage of lexical hints Lexical::SealRequireHints works around two historical bugs in Perl's handling of the %^H (lexical hints) variable. One bug causes lexical state in one file to leak into another that is required/used from it. This bug, [perl #68590], was present from Perl 5.6 up to Perl 5.10, fixed in Perl 5.11.0. The second bug causes lexical state (normally a blank %^H once the first bug is fixed) to leak outwards from utf8.pm, if it is automatically loaded during Unicode regular expression matching, into whatever source is compiling at the time of the regexp match. This bug, [perl #73174], was present from Perl 5.8.7 up to Perl 5.11.5, fixed in Perl 5.12.0. Both of these bugs seriously damage the usability of any module relying on %^H for lexical scoping, on the affected Perl versions. It is in practice essential to work around these bugs when using such modules. On versions of Perl that require such a workaround, this module globally changes the behaviour of require, including use and the implicit require performed in Unicode regular expression matching, so that it no longer exhibits these bugs.

The Log::Agent module provides an abstract layer for logging and tracing, which is independent from the actual method used to physically perform those activities. It acts as an agent (hence the name) that collects the requests and delegates processing to a sublayer: the logging driver. The Log::Agent module is meant to be used in all reusable components, since they cannot know in advance how the application which ends up using them will perform its logging activities: either by emitting messages on stdout and errors on stderr, or by directing messages to log files, or by using syslog(3). The logging interface is common for all the logging drivers, and is therefore the result of a compromise between many logging schemes: any information given at this level must be either handled by all drivers, or may be ignored depending on the application's final choice. WARNING: THIS INTERFACE IS STILL SOMEWHAT ALPHA AND COULD STILL CHANGE DEPENDING ON THE FEEDBACK THE AUTHOR RECEIVES, WITHOUT ANY BACKWARD COMPATIBILITY ASSURANCE.

Perl 5.6 introduced something called interpreter threads. Interpreter threads are different from 5005threads (the thread model of Perl 5.005) by creating a new Perl interpreter per thread, and not sharing any data or state between threads by default. Prior to Perl 5.8, this has only been available to people embedding Perl, and for emulating fork() on Windows. The threads API is loosely based on the old Thread.pm API. It is very important to note that variables are not shared between threads, all variables are by default thread local. To use shared variables one must use threads::shared. It is also important to note that you must enable threads by doing use threads as early as possible in the script itself, and that it is not possible to enable threading inside an eval "", do, require, or use. In particular, if you are intending to share variables with threads::shared, you must use threads before you use threads::shared. (threads will emit a warning if you do it the other way around.)

ptmalloc is the original version of the malloc that was later included in GNU libc. This version is also but *not* exclusively LGPL: Copyright (c) 2001-2006 Wolfram Gloger Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notices and this permission notice appear in all copies of the software and related documentation, and (ii) the name of Wolfram Gloger may not be used in any advertising or publicity relating to the software. THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL WOLFRAM GLOGER BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. This package comes with no documentation beyond a README, which isn't worth installing. It appears that the GNU libc man page malloc(3) applies, but it's not included here for copyright reasons.

Ruby Inline is an analog to Perl's Inline::C. Out of the box, it allows you to embed C/++ external module code in your ruby script directly. By writing simple builder classes, you can teach how to cope with new languages (fortran, perl, whatever). The code is compiled and run on the fly when needed. Using the package_inline tool Inline now allows you to package up your inlined object code for distribution to systems without a compiler (read: Windows)! FEATURES/PROBLEMS: * Quick and easy inlining of your C or C++ code embedded in your ruby script. * Extendable to work with other languages. * Automatic conversion between ruby and C basic types o char, unsigned, unsigned int, char *, int, long, unsigned long * inline_c_raw exists for when the automatic conversion isn't sufficient. * Only recompiles if the inlined code has changed. * Pretends to be secure. * Only requires standard ruby libraries, nothing extra to download. * Can generate a basic Rakefile and package up built extensions for distribution.

The Doomsday Engine is an enhanced DOOM source port for Windows, Mac OS X, and various Unix platforms. It is based on the source code of id Software's DOOM and Raven Software's Heretic and Hexen. * Hardware-accelerated OpenGL graphics engine * 3D positional audio for sound effects (not supported by all audio plugins) * 16-player client/server networking via TCP/IP * Graphical Control Panel for configuration, accessed quickly with Shift-Escape * 3D models: Quake's MD2 format and Doomsday's DMD format with LOD support * High-resolution textures (PNG, TGA, PCX) and detail textures * Map lighting emulates the effects of radiosity for a more natual appearance (FakeRadio: shadows in corners) * Smooth movement of objects, world structures and the camera. * Colored, dynamic lighting for world surfaces, 3D models, sprites and particles * Object shadowing effects * Particle generators for special effects * Decoration effects on world surfaces: light sources and particle generators * Lens flares and glowing objects * Support for skyboxes and 3D sky models * EAX and A3D environmental sound processing effects * Upsampling of sound effects

The original puzzle has 9 triangles per face (size = 3) and has period 3 turning (i.e. the face or points turn in 120 degree intervals). The puzzle was designed by Uwe Meffert and called the Pyraminx. This has 2^5*3^8*6!/2 or 75,582,720 different combinations. Another puzzle Senior Pyraminx 3x3x3 exists only on paper, it has period 2 turning (i.e. edges turn with 180 degree intervals) but the corners would fall off unless it had some tricky mechanism. (This may be the same as the Master Pyraminx which has 446,965,972,992,000 different combinations). Another puzzle (which was not widely distributed), the Junior Pyraminx (and similarly the Junior Pyraminx Star, a octahedron formed by two tetrahedra, this has 7!*3^6 or 3,674,160 different combinations), has 4 triangles (size = 2) per face and at the time I designed this computer puzzle thought that it had only period 2 turning (i.e the edges rotate). It turns out the puzzle has a period 4 turning (edges turn with 90 degree intervals) which makes it analogous to the 2x2x2 Rubik's cube. This puzzle makes various non-tetrahedral shapes. The puzzle contained here has no period 4 turning flexability.