Free resemble software for linux

RIMPS is a web-based MP3 and Ogg server.
Its written in PHP, to make Apache an MP3 and Ogg server.
It features searching, individual song-playing, and playlist creation.
RIMPS is meant to resemble a personal mp3.com of your own MP3s and Oggs, with the addition of playlists.
Enhancements:
- id3v2 support!
- browse improvements
- ogg streaming/reencoding
- many, many bug fixes!

Symlinker is a minimalistic file manager that is built to primarily operate with symlinks. The project is written in PHP.
Why would I use it?
There are many PHP hosting providers nowadays. Unfortunately most of them only provides you FTP to upload your files to their servers which imposes several restrictions on you.
You probably use a content management systems (CMS) on your site and you may want to make multiply installations of the same CMS. Such an installation traditionally involves duplicating the complete directory structure of your CMS, but that may take much disk space and its painful to upgrade the individual installations this way. There is a much better way.
You can solve this problem by placing the directory structure of your CMS in only one directory and symlink the individual CMS instances that you want to use to point to this particular directory. This is called a symlink farm. Unfortunately its not possible to handle symlinks with FTP because the FTP protocol doesnt have such commands that operate on symlinks.
This scenario is a perfect one where Symlinker comes handy.
How can I install it?
1. Download symlinker.php and put it somewhere under your webspace.
2. Set the $password variable in the beginning of symlinker.php. This will be your login password that Symlinker will ask you upon login.
3. You may also set the $default_path variable in the beginning of symlinker.php. This will be your default path after login.
How can I use it?
First, point your browser to the URL where you put symlinker.php. Symlinker will ask you the login password, so enter it correctly and log in.
If everything went well, you should see a page that resembles the picture that you can see on the right side. Lets see what operations you can use here:
- You can navigate in the directory tree by using the navigation bar which resides in the top left corner of the page or editing the path argument in the URL.
- You can create a new symlink by entering the filename and the target of the symlink into the upper text fields and pressing the symlink button.
- You can update the target of the symlinks of the current directory by editing the text fields related to the specific filenames and pressing the update button.
- You can log out by visiting the logout link which resides in the top right corner of the page.
How can I set up a symlink farm?
To better understand how to set up a symlink farm, take a look at the picture on the right side.
I use the MediaWiki content management system here. I have a special directory, /web/monda/apps where I keep the installations of the CMSes that I use.
First, I create a symlink with the filename mediawiki which points to ../../apps/mediawiki-1.9.3, the exact version of the MediaWiki installation which I want to use within this directory. Later when I want to upgrade MediaWiki, I can just rename the target of this symlink to point to a more recent version of MediaWiki.
As you can see, most of the filenames in this directory are symlinked to mediawiki, but some are not. This is because most CMS holds some data which are specific to the individual CMS instances so they must have their own separate directory.
Enhancements:
- Logout works correctly.
- Works with register_globals turned off for better security.

Universe project is a Open Source Master Of Orion-like game.

Universe is an Open-Source game which resembles Master Of Orion. It is written in Java.

The goal is to have as few arbitrary limits as possible, allowing games as large as you wish. It also supports a concept called "Schemes" which allows programmers to develop distinct rule sets and extensions.

Devel::TraceFuncs is a Perl module with trace function calls as they happen.

SYNOPSIS

Usage:

require Devel::TraceFuncs;

max_trace_depth 5;
trace_file "foo.out";
trace_file $file_handle;

sub foo {
IN(my $f, "a message");

DEBUG "hellooo!";
}

Devel::TraceFuncs provides utilities to trace the execution of a program. It can print traces that look something like:

+-> global: 0
| +-> main::fo(4, 5) (in ./t.pm:32): now then
| | +-> main::fp(4, 5) (in ./t.pm:19)
| | | +-> main::fq() (in ./t.pm:13)
| | | | que pee doll (in ./t.pm:8)
| | | +-< main::fq() (in ./t.pm:13)
| | | cee dee (in ./t.pm:14)
| | +-< main::fp(4, 5) (in ./t.pm:19)
| | ha
| | hs (in ./t.pm:20)
| +-< main::fo(4, 5) (in ./t.pm:32): now then
| done (in ./t.pm:34)
+-< global: 0

IN

A trace begins when a function calls IN. A myd variable is passed in, such that when that function exits, the destructor for the variable is called. If this trace is to be printed, the opening line of the trace in printed at this time. Any other parameters are concatenated together, and printed on both the opening and closing lines of the trace.

I wish the syntax could be a little nicer here, but I couldnt find anything in perl that resembles Tcls uplevel or upvar commands. If I was one of the perl gods, I could have figured out a way to do something like perl5db.pl:

sub sub {
# create a new subroutine, with a myd TraceFunc object
}

DEBUG

Print some text to the trace file, at the correct depth in the trace. If the last parameter ends in "!", the arguments are printed, regardless of current depth.

trace_file

trace_file takes one argument, which is either a file name or an open file handle. All trace output will go to this file.

max_trace_depth

To avoid lots of nesting, particularly from recursive function calls, you can set the maximum depth to be traced. If this is -1 (the default), all levels of functions are traced. If it is 0, no trace output occurs, except for DEBUG statements that end in "!".

editApage.org is a simple and flexible tool that helps Web designers and people who yearn for control over their websites.

editApage.org project provides the ease of use of Blogging without forcing the end result to resemble a diary.

How does it work?

1. Point editApage.org to any URL on the web.

2. editApage.org loads a copy of the rendered source, and lets you choose which parts youd like to make editable.

3. Enter the FTP settings for the pages final destination, and make some choices on who should be able to edit this page.

4. Enter the pages URL into editApage.org, preview changes youre making, and publish to your live box. Its all the ease of blogging, with none of the forced architecture.

Simple Sockets Library provides a simple C programming interface to sockets.
The Simple Sockets Library makes sockets easy to use and comes as public domain source code. It resembles Cs file I/O, uses whatever port is available, has named servers and port reuse, streaming/blocking sockets used, polling support, blocking/selection support via numerous functions, timeout control and firewall support.
Main features:
- Resembles Cs file i/o:
- Sclose() Sgets() Sopen() Sprintf() Sputs() Sread() Sscanf() Swrite() Svprintf()
- Uses currently available ports only, so if a server can be brought up, it will be
- Named sockets -- servers have names, not fixed port addresses!
- (no more REUSEADDR problems, linger setting, zombie sockets!)
- Streaming/blocking sockets used
- Polling supported (ie. avoids blocking):
- Stest() Smasktest() Speek()
- Numerous functions to handle multiple concurrent clients:
- Smaskfdset() Smaskpush() Smasktime() Smaskunset() Smaskwait()
- Smaskget() Smaskset() Smaskunfdset() Smaskuse() Sprtmask()
- Smaskpop() Smasktest()
- Timeout control:
- Stimeoutwait() Smasktime()
- The PortMaster (Spm): Maintains a distributed port/server-name database Each machine runs a PortMaster which maps servers by name to their ports (transparent to programmers and users!)
- Firewall Support
- The PortMaster can (optionally) only "put through" connections from approved machine sites
- Supports "path"ing for sockets: one can use an environment variable to track down a server, by name, on any machine in a group:
- Sopenv()
- Doesnt need root privileges (thats Unix lingo...)
- Now supports fixed ports (servers and/or clients) to facilitate interfacing to non-SSL servers/clients
The Simple Sockets Librarys main purpose is to provide an Application Programming Interface that strongly resembles the standard C librarys file handling interface. Thus programmers find that the Simple Sockets Librarys learning curve is particularly short. As a secondary purpose the Simple Sockets Library helps programmers avoid some common programming problems with sockets (avoided: large buffers that dont transfer in their entirety without special effort, the Nagle algorithms practical effect of often limiting one to five transfers per second, servers whose ports refuse to re-open until two minutes have passed, etc). Strings are null-byte terminated just like regular C/C++ strings, facilitating their ease of use in C/C++ programming.
The Simple Sockets Library preferentially uses names for its servers rather than requiring hard-coded port numbers. Imagine if, instead of files having names, everyone went about saying "use sector 4 and track 14" or somesuch thing. This situation reflects what we now have with sockets -- and when two programs use the same port number for their servers, they cant co-exist simultaneously on a system. However, especially for those whose programs must interface with other programs using hard-coded port numbers, the Simple Socket Library also supports hard-code port numbers.
The Simple Sockets Library opens streaming sockets. Thus the Simple Sockets Librarys sockets provide guaranteed delivery of information in the correct order (unlike datagrams, for example).
The PortMaster (Spm), source code for which is part of the library, provides a "phonebook" to map server names to dynamically allocated port numbers. Port numbers thus wont clash; the operating system determines which ones are currently available and the PortMasters effectively publish the result.
Enhancements:
- (Marcel Satchel) improved for Windows
- (Aug 22, 2005) included the "b" option for Sopen() (block until requested server becomes available)
- (Marcel Satchel) Sinit.c fixed (yet again!)

Pod::Compiler can compile POD into an object tree.

This package, based on Pod::Parser, compiles a given POD document into an object tree (based on Tree::DAG_Node). It prints errors and warnings about the POD it reads. The result can be used to conveniently convert the POD into any other format.

The resulting objects have a variety of methods to ease the subsequent conversion.

There are two script based on this package, namely podchecker2, an enhanced POD syntax checker and podlint, which beautifies the POD of a given file.

This package is object-oriented, which means that you can quite easily build a derived package and override some methods in case the given behaviour does not exactly suit your needs.

Package Functions

The following functions can be imported and called from a script, e.g. like this:

use Pod::Compiler qw(pod_compile);
my $root = pod_compile(myfile.pod);

pod_compile( { %options } , $file )
pod_compile( $file )

Compile the given $file using some %options and return the root of the object tree representing the POD in $file. The return value is either undef if some fatal error occured or an object of type Pod::root. See below for methods applicable to this class and for the options.

The special option -compiler => class lets you specify an alternate (derived) compiler class rather than Pod::Compiler.

Compiler Object Interface

The following section describes the OO interface of Pod::Compiler.

$c = Pod::Compiler->new( %options )

Set up a new compiler object. Options (see below) can be passed as a hash, e.g.

$c = Pod::Compiler->new( -warnings => 0 ); # dont be silly

Pod::Compiler inherits from Pod::Parser. See Pod::Parser for additional methods.

$c->initialize()

Initalize, set defaults. The following options are set to the given defaults unless they have been defined at object creation:

-errors => 1

Print POD syntax errors (using messagehandler) if option value is true.

-warnings => 1

Print POD syntax warnings (using messagehandler) if option value is true.

-idlength => 20

Pod::Compiler creates a unique node id for each =head, =item and X, consisting only of w characters. The option value specifies how many characters from the original node text are used for the node id by the built-in make_unique_node_id method. See below for more information.

-ignore => BCFS

This option specifies which interior sequences (e.g. B< ... >) are ignored when nested in itself, e.g. B< ...B< ... >... >. The inner B is simply discarded if the corresponding letter appears in the option value string.

-unwrap => I

This option specifies which interior sequences (e.g. I< ... >) are unwrapped when nested in itself, e.g. I< ...I< ... >... > is turned into I< ... >...I< ... >. While some destination formats may handle such nestings appropriately, other might have problems. This option solves it right away. By the way, from a typographical point of view, italics are often used for emphasis. In order to emphasize something within an emphasis, one reverts to the non-italic font.

name =>

This is used to store the (logical) name of the POD, i.e. for example the module name as it appears in use module;. It is used internally only to detect internal links pointing to the explicit page name. Example: You compile the file Compiler.pm which contains the package Pod::Compiler. You set name to Pod::Compiler (there is no safe automatic way to do so). Thus if the file includes a link like L< Pod::Compiler/messagehandler > it is recognized as an internal link and it is checked whether it resolves. Of course you should have written the link as L< /messagehandler >...

-perlcode => 0

If set to true, the compiler will also return the Perl code blocks as objects Pod::perlcode, rather than only the POD embedded in the file. This is used e.g. by podlint.

$c->option( $name , $value )

Get or set the compile option (see above) given by $name. If $value is defined, the option is set to this value. The resulting (or unchanged) value is returned.

$c->messagehandler( $severity , $message )

This method is called every time a warning or error occurs. $severity is one of ERROR or WARNING, $message is a one-line string. The built-in method simply does

warn "$severity: $messagen";
$c->name( [ $name ] )

Set/retrieve the name property, i.e. the canonical Pod name (e.g. Pod::HTML). See above for more details.

$c->root()

Return the root element (instance of class Pod::root) representing the compiled POD document. See below for more info about its methods.

$c->make_unique_node_id($string)

Turn given text string into a document unique node id. Can be overridden to adapt this to specific formatter needs. Basically this method takes a string and must return something (more or less dependent on the string) that is unique for this POD document. The built-in method maps all consecutive non-word characters and underlines to a single underline and truncates the result to -idlength (see options above). If the result already exists, a suffix _n is appended, where n is a number starting with 1. A different method could e.g. just return ascending numbers, but if you think of HTML output, a node id that resembles the text and has a fair chance to remain constant over subsequent compiles of the same document gives the opportunity to link to such anchors from external documents.

TCDialer is a DTMF dialer. Designed to resemble telephone keypad. Useful for those who end up in a hotel with a pulse phone.

DTMF generator for those without a touch-tone phone.

Push the buttons. Hear the DTMF tones. Pretty simple.