Free blob metal solid 1.07 software for linux

Pagetool provides a CMS (content management system) that allows people with limited technical skills to contribute to a website.
What is Pagetool?
Pagetool is a program that allows people with limited technical skills to modify and contribute to an organizations web site via a web browser. There is no need for using an FTP program or for purchasing html editing programs like Dream Weaver or Go Live!. Furthermore, for basic site maintenance, no knowledge of HTML is necessary.
How Does it Work?
Pagetool stores all web pages in a database. To the average web user, it looks and acts like a typical web site. However, it you go to the special admin section and enter the correct username and password, you will be able to see a list of web pages on your site. By selecting a web page and clicking "edit" you will be able to change the content of that particular page.
Was Pagetool designed specifically for Nonprofits?
Media Jumpstart launched the Pagetool project (as a branch of myphpPagetool) with the express goal of making a web content management system appropriate for nonprofit organizations. As the project developed, however, it has attracted diverse developers who have been adapting it to work with for profit organizations, consultants, and universities, making it useful to a wide spectrum of organizations. The Pagetool project has since been taken over by Dave Guerin.
Enhancements:
- Added a link from the first setup page to the README_CGI.txt file for those that might need to do a manual install.
- Added an if !isset for $pt_action in pt_admin.inc. Maybe Pagetool 1.x will run with E_ALL error reporting someday :-)
- The new profile and edit profile admin screens now have valid html, plus a note about changing the colspan values for the header td and footer td thats required if theres no news bar.

Text::Bloom can evaluate Bloom signature of a set of terms.

SYNOPSIS

my $b = Text::Bloom->new();
$b->Compute( qw( foo bar baz ) );
my $sig = $b->WriteToString();
$b->WriteToFile( afile.sig );
my $b2 = Text::Bloom::NewFromFile( afile.sig );
my $b3 = Text::Bloom->new();
$b3->Compute( qw( foo bar barbaz ) );
my $sim = $b->Similarity( $b2 );
my $b4 = Text::Bloom::NewFromString( $sig );

Text::Bloom applies the Bloom filtering technique to the statistical analysis of documents.

The terms in the document are quantized using a base-36 radix representation; each term thus corresponds to an integer in the range 0..p-1, where p is a prime, currently set to the greatest prime less than 2^32.

Each quantized value is mapped to d integers in the range 0..size-1, where size is an integer less than p, currently 2^17, using a family of hash functions, computed by the HashV function.

Each hashed value is used as the index in a large bit vector. Bits corresponding to terms present in the document are set to 1; all other bits are set to 0.

Of course, collisions may cause the same bit to be set twice, by different terms. It follows that, if the document contains n distinct terms, in the resulting bit vector at most n * d bits are set to 1.

The resulting bit string is a very compact representation of the presence/absence of terms in the document, and is therefore characterised as a signature. Moreover, it does not depend on a pre-set dictionary of terms.

The signature may be used for:

testing whether a given set of terms is present in the document,
computing which fraction of terms are common to two documents.

The bit representation may be written to and read from a file. Text::Bloom prepends a header to the bit stream proper; moreover, whenever the package Compress::Zlib is available, the bit vector is compressed, so that disk space requirements are drastically reduced, especially for small documents.

The hash function is obviously a crucial component of the filter; the reference implementation uses a radix representation of strings. Each term must therefore match the regular expression /[0-9a-z]+/.

There are quite a few viable alternatives, which can be pursued by subclassing and redefining the method QuantizeV.

Easy SVN is a subversion browser via the Web. Easy SVN Browser is easy because only a command line svn program and Perl are required to run it; no extra software needs to be installed. After configuring the Perl script as cgi-bin program, SVN repositories can be navigated, and entries viewed for contents, history, and diffs.
Installation:
Follow these steps for a quick installation of web-svn-view:
1. Log in as the user who is running the webserver (e.g., www).
2. As this user, make sure you have read-access on your repository. Issue an svn command to make sure that if necessary, you are prompted for a username and password. Once the viewer is running, logins must take place automatically.
3. Obtain web-svn-view by getting the archive http://public.e-tunity.com/web-svn-view/web-svn-view-latest.tar.gz . Save the archive on your disk as e.g.
/tmp/web-svn-view-latest.tar.gz.
4. Change-dir to a directory where the webserver will run the viewer.
5. Unpack, using tar xzf /tmp/web-svn-view-latest.tar.gz. Note the full paths to the contained directories cgi-bin, css and img. In the following example well assume that the base directory is /Users/e/src/e.
6. Edit cgi-bin/web-svn-view and modify the configuration variables at the top of the file. The variables are documented in the script.
7. Edit the servers configuration file. E.g, for Apache, edit httpd.conf and add the following lines:
ScriptAlias /svnbin /Users/e/src/e/web-svn-view/cgi-bin
Alias /svncss /Users/e/src/e/web-svn-view/css
Alias /svnimg /Users/e/src/e/web-svn-view/img
< Location / >
Order deny,allow
Deny from all
< /Location >
< Location /svnbin >
Order allow,deny
Allow from all
< /Location >
< Location /svncss >
Order allow,deny
Allow from all
< /Location >
< Location /svnimg >
Order allow,deny
Allow from all
< /Location >
You will need to supply the right directories for your system.
8. Restart the webserver.
9. Point your browser to http://yoursite/svnbin/web-svn-view.
Enhancements:
- The configuration settings in cgi-bin/web-svn-view can now be overridden by environment variables.
- That makes it possible to re-use the same SVN browser to view many repositories, based on environment variables passed by the Web server.
- The documentation was updated with an example.

execline projct consists of a (non-interactive) scripting language, like sh ; but its syntax is quite different from a traditional shell syntax. The execlineb program is meant to be used as an interpreter for a text file; the other commands are essentially useful inside an execlineb script.
execline is now as powerful as a shell: it features conditional loops, getopt-style option handling, filename globbing, and more. Meanwhile, its syntax is far more logic and predictable than the shells syntax, and has no security issues.
Installation
execline follows the slashpackage convention.
- Create a /package directory:
mkdir -p /package
chmod 1755 /package
cd /package
Unpack the execline package:
tar -zxpvf execline-1.06.tar.gz
if you do not have GNU tar, check with your gunzip and tar manual pages.
rm execline-1.06.tar.gz
cd admin/execline-1.06
If you want to use another compiler and linker than the default, edit conf-compile/conf-cc and conf-compile/conf-ld as needed.
For instance, if your libc makes it easy, you could modify those files to make static binaries, which perform better. Dont try this with the GNU libc, though - on Linux, use the diet libc.
If you want to change the default stripping behaviour of executables and libraries, edit conf-compile/conf-stripbins and conf-compile/conf-striplibs as needed.
Compile and set up execline:
package/install
or perform package/compile to compile it, then look into the command subdirectory and copy the binaries where you need them.
You can then delete the compile subdirectory to save disk space.
Look into the etc subdirectory: edit the files there to suit your needs, then copy them to /etc.
Enhancements:
- Some user-suggested improvements have been implemented.
- The code base itself is stable and has no reason to change.

MARC is a Perl extension to manipulate MAchine Readable Cataloging records.

SYNOPSIS

use MARC;

# constructors
$x=MARC->new();
$x=MARC->new("filename","fileformat");
$x->openmarc({file=>"makrbrkr.mrc",format=>"marcmaker",
increment=>"5", lineterm=>"n",
charset=>%char_hash});
$record_num=$x->createrecord({leader=>"00000nmm 2200000 a 4500"});

# input/output operations
$y=$x->nextmarc(10); # increment
$x->closemarc();
print $x->marc_count();
$x->deletemarc({record=>2,field=>110});
$y=$x->selectmarc([4,21-50,60]);

# character translation
my %inc = %{$x->usmarc_default()}; # MARCMaker input charset
my %outc = %{$x->ustext_default()}; # MARCBreaker output charset

# data queries
@records = $x->searchmarc({field=>"245"});
@records = $x->searchmarc({field=>"260",subfield=>"c",
regex=>"/19../"});
@records = $x->searchmarc({field=>"245",notregex=>"/huckleberry/i"});
@results = $x->getvalue({record=>12,field=>856,subfield=>u});

# header and control field operations
$rldr = $x->unpack_ldr($record);
print "Desc is $rldr->{Desc}";
next if ($x->bib_format($record) eq SERIALS);
$rff = $x->unpack_008($record);
last if ($rff->{Date1}=~/00/ or $rff->{Date2}=~/00/);

# data modifications
$x->addfield({record=>"2", field=>"245",
i1=>"1", i2=>"4", ordered=>y, value=>
[a=>"The adventures of Huckleberry Finn /",
c=>"Mark Twain ; illustrated by E.W. Kemble."]});

my $update245 = {field=>245,record=>2,ordered=>y};
my @u245 = $x->getupdate($update245);
$x->deletemarc($update245);
$x->addfield($update245, @u245_modified);

# outputs
$y = $x->output({format=>"marcmaker", charset=>%outc});
$x->output({file=>">>my_text.txt",format=>"ascii",record=>2});
$x->output({file=>">my_marcmaker.mkr",format=>"marcmaker",
nolinebreak=>y,lineterm=>n});
$x->output({file=>">titles.html",format=>"html", 245=>"Title: "});

# manipulation of individual marc records.
@recs = $x[1..$#$x];
grep {$_->unpack_ldr() && 0} @recs;
@LCs = grep {$_->unp_ldr{Desc} eq a &&
$_->getvalue({field=>040}) =~/DLCc_.DLC/} @recs;
foreach my $rec (@LCs) {
print $rec->output({format=>usmarc});
}

# manipulation as strings.
foreach my $rec (@LCs) {
my $stringvar = $rec->as_string();
$stringvar=~s[^(
100s # main entries of this stripe..
..s # (dont care about indicators)
c_.s*
)(S) # take the first letter..
] [
${1}uc($2) # and upcase it. All authors have
# upcase first letters in my library.
]xm; # x means ignore whitespace and allow
# embedded comments.
$rec->from_string($stringvar);
my ($i2,$article) = $stringvar =~/245 .(.) c_.(.{0,9})/;
$article = substr($article,0,$i2) if $i2=~/d/;
print "article $article is not common" unless $COMMON_ARTS{$article};
}

MARC.pm is a Perl 5 module for reading in, manipulating, and outputting bibliographic records in the USMARC format. You will need to have Perl 5.004 or greater for MARC.pm to work properly. Since it is a Perl module you use MARC.pm from one of your own Perl scripts. To see what sorts of conversions are possible you can try out a web interface to MARC.pm which will allow you to upload MARC files and retrieve the results (for details see the section below entitled "Web Interface").

However, to get the full functionality you will probably want to install MARC.pm on your server or PC. MARC.pm can handle both single and batches of MARC records. The limit on the number of records in a batch is determined by the memory capacity of the machine you are running. If memory is an issue for you MARC.pm will allow you to read in records from a batch gradually. MARC.pm also includes a variety of tools for searching, removing, and even creating records from scratch.

Ident2 is an alternative approach to auth/ident services. The project was written from the ground up and can run either as a child handler of inetd or as a standalone daemon with no user intervention.
Users can set their own replies or toggle random replies, all at the system administrators preference, of course. Full compliance with RFC1413 is attempted.
Enhancements:
- This release adds support for SunOS, NetBSD, OpenBSD, OSF/1, and HP-UX.
- It fixes a buffer overflow in the getline function.
- A buffer overflow on FreeBSD has been fixed.
- Neither of these have known exploits or are known to be exploitable.
- Ident2 servers do not announce their version information to the Internet.
- All users are encouraged to upgrade.

Metal Mech is a fully web-based mass multiplayer game of battle between robots and space exploration. Metal Mech is a game of strategy, economic, role-playing and combat.

Each player can handle own war robot and battle against other players to be the Emperor of the Universe. Players war against each other for resources, energy, money, buildings and other.

In the game players can build fabrics, mines, buildings and product robots, weapons, devices & etc. Also players can trade with each other.

Project will be fully written in PHP and XML(XSLT).