Free entry points software for linux

OCamlI18N is an OCaml library for programs internationalization.
OCamlI18N (will) provide an I18N module modeling locales, time zones, calendars and dates, numbers and collations for any language, provided enough locale information has been given to him.
The design is heavily inspired by Javas model of localization classes and its motivation was to have a completely thread-safe implementation of internationalization for OCaml fans. If you have any suggestions about the code, contact me (mattam AT mattam DOT org).
OCamlI18N is distributed under the terms of the LGPL.
Enhancements:
- Makefile (VERSION): Set to 0.3, for first release of LDML parsing code.
- src/ISO*.ml*, src/KeyTypes.ml*, src/Variants.ml*, src/ISO_types.ml*: Support for ISO and LDML types, with direct encoding of the enumerations as variant types.
- src/generate_parser.ml: Parser generator, using camlp4 for code construction and capable of producing class types, implementations and parsing code from DTDs.
- src/LDML_types.ml*, src/LDML_impl.ml*: generated code for parsing LDML documents using pxp.
- src/LDML_support.ml*: Support functions for parsing.
- src/LDML.ml*: main entry point to access LDML information.

SPindent (Server Page Indenter) is a JSP/PHP structural validator and indenter. It performs structural compatibility check of inner HTML generated from "parallel" branches of process flow statements such as if/else.

It allows for those HTML branches to have different entry and exit HTML stack points, as far as the branches are compatible.

This allows for verification and proper indentation of handy workarounds, as well as rusty pyramids. It is based on MixedCC (Mixed Compiler Compiler).

It is a package useful to collect statistics from remote nodes. That includes standard server metrics and any other numerical quantity we can use to characterize the node state (as the number of users or processes).

It is built under a distributed agent-manager model. RRDtool is used as database, so representation capabilities are bundled.

Although rrdUtils are not a requisite, they are used in some auxiliar tasks and using both tools is highly recommended.

Installation:

Manager side

gunzip -c rrdUtils-3.1.tar.gz | tar -xf -
cd rrdUtils
./configure --with-rrddir=/stats
make install

gunzip -c stats-station-3.0.tar.gz | tar -xf -
cd stats-station
./configure --with-statsdir=/stats --with-port=666
make install

cd rrdConf
./install_confs.sh
./haz_index.sh -g

The -g flag creates graphs with the html pages, and reduces the number of error messages that haz_index will issue.
The only task that needs to be completed at this point is the periodic graphs generation by a crontab entry that calls the make_graphs.sh script.
Once we start the server using the provided initscript, we get the manager side ready.

Agent side

gunzip -c stats-3.0.tar.gz | tar -xf -
cd stats
./configure --with-host=central.node --with-port=666
--with-statsdir=/usr/local/stats
make install

With a crontab entry to execute the statlaunch script every 15 minutes, the whole system is up and running.

ELFIO is a C++ library for reading and generating files in the ELF binary format. This library is unique and not based on any other product. It is also platform independent. The library uses standard ANSI C++ constructions and runs on a wide variety of architectures.
While the librarys implementation does make your work easier: a basic knowledge of the ELF binary format is required. Information about ELF is included in the TIS (Tool Interface Standards) documentation you received with the librarys source code.
The ELFIO library consists of two independent parts: ELF File Reader (IELFI) and ELF Producer (IELFO). Each is represented by its own set of interfaces. The library does not contain any classes that need to be explicitly instantiated. ELFIO itself provides the interfaces that are used to access the librarys functionality.
To make the program recognize all ELFIO interface classes, the ELFIO.h header file is needed. This header file defines all standard definitions from the TIS documentation.
#include < ELFIO.h >
This chapter will explain how to work with the reader component of the ELFIO library. The first step is to get a pointer onto the ELF File Reader:
IELFI* pReader;
ELFIO::GetInstance()->CreateELFI( &pReader );
Now, that there is a pointer on the IELFI interface: initialize the object by loading the ELF file:
char* filename = "file.o";
pReader->Load( filename );
From here, there is access to the ELF header. This makes it possible to request file parameters such as encoding, machine type, entry point, etc. To get the encoding of the file use:
unsigned char encoding = pReader->GetEncoding();
Please note: standard types and constants from the TIS document are defined in the ELFTypes.h header file. This file is included automatically into the project. For example: ELFDATA2LSB and ELFDATA2MSB constants define a value for little and big endian encoding.
ELF binary files consist of several sections. Each section has its own responsibility: some contain executable code; others describe program dependencies; others symbol tables and so on. See the TIS documentation for a full description of each section.
To see how many sections the ELF file contains, including their names and sizes, is demonstated in the following code:
int nSecNo = pReader->GetSectionsNum();
for ( int i = 0; i < nSecNo; ++i ) { // For all sections
const IELFISection* pSec = pReader->GetSection( i );
std::cout GetName() GetSection( .symtab );
Second, create a symbol section reader:
IELFISymbolTable* pSymTbl = 0;
pReader->CreateSectionReader( IELFI::ELFI_SYMBOL,
pSec,
(void**)&pSymTbl );
And finally, use the section reader to process all entries (print operations are omitted):
std::string name;
Elf32_Addr value;
Elf32_Word size;
unsigned char bind;
unsigned char type;
Elf32_Half section;
int nSymNo = pSymTbl->GetSymbolNum();
if ( 0 < nSymNo ) {
for ( int i = 0; i < nSymNo; ++i ) {
pSymTbl->GetSymbol( i, name, value, size,
bind, type, section );
}
}
pSymTbl->Release();
pSec->Release();
All interfaces from the ELFIO library should be freed after use. Each interface has a Release() function. It is not enough to only free the high level interface because one of the sections or readers will still be held and its resources will not be cleared.
The interfaces are freed immediately after their use, in this example we will free only the pReader object:
pReader->Release();
The source code for the ELF Dumping Utility can be found in the "Examples" directory; included there are more examples on how to use different ELFIO reader interfaces.
Enhancements:
- Fixes endian conversion in the ELFIRelocation and ELFINote sections adapters.

pmacct-fe is a frontend tool for presenting network statistics in tables and plots. pmacct-fe project works by reading aggregates stored into a PostgreSQL database by pmacct.

Features include user authentication and capabilities, support for multiple observation points and customizable report types.

Batrachians is a game where you control a frog. Your goal is to eat more flies and score more points than the computers frog.

It is a clone of the 1982 Frog Bog video game by Mattel Electronics.

Sheep is a game where you are a shepherd. Guide your sheep to juicy flowers, afterwards to the stable!

Installation:

1. Unpack the archive into a directory of your choice.
2. Open a command line interface (console), change to this directory, type
./install_sheep.cmd (english version)
./install_schafe.cmd (german version) wait until compilation and linking has finished. You may ignore warnings.

3. Start game from the CLI by changing to the directory schafe, type ./sheep, Start leveleditor by changing to the directory schafe, type ./leveleditor, or start programs from a directory manager by (double-) clicking, or make a link/icon on the desktop pointing to these programs, work directory: the directory the programs are is in.

Configuration:

If you want to play only on your local machine, you may skip steps 1 and 2.

1. Open the file hiscore.ini

2. Set the path in the second path entry to your network path. You need Read/Write permission for this path. You may switch the actual List via Menu2.

3. After starting the game reset every hiscore list via Menu.

LJ::Simple is a Perl module to provide a simple OOP-based API for accessing the LiveJournal system.
Main features:
- Log into LiveJournal
- Post a journal entry
- Edit a journal entry
- Delete a journal entry
Example
The following example posts a simple message into the test LiveJournal using the LJ::Simple::QuickPost method.
use LJ::Simple;
LJ::Simple::QuickPost(
user => "test",
pass => "test",
entry => "Just a simple entry",
) || die "$0: Failed to post entry: $LJ::Simple::errorn";
The next example shows how to post an entry into the test LiveJournal using the complete, object-based, interface:
use LJ::Simple;
my $lj = new LJ::Simple ({
user => "test",
pass => "test",
});
(defined $lj)
|| die "$0: Failed to log into LiveJournal: $LJ::Simple::errorn";
my %Event=();
$lj->NewEntry(%Event) ||
die "$0: Failed to create new entry: $LJ::Simple::errorn";
my $entry=SetMood(%Event,"happy")
|| die "$0: Failed to set mood: $LJ::Simple::errorn";
$lj->Setprop_nocomments(%Event,1);
my ($item_id,$anum,$html_id)=$lj->PostEntry(%Event);
(defined $item_id)
|| die "$0: Failed to post journal entry: $LJ::Simple::errorn";