Xalan-Java is an XSLT processor for transforming XML documents into HTML, text,
or other XML document types. It implements the W3C Recommendations for XSL
Transformations (XSLT) Version 1.0 and the XML Path Language (XPath) Version
1.0. It can be used from the command line, in an applet or a servlet, or as a
module in other program.
Xalan-Java recasts Xalan as an implementation of the Transformation API for XML
(TrAX) interfaces, part of the Java API for XML Processing 1.2. TrAX provides a
modular framework and a standard API for performing XML transformations, and it
utilizes system properties to determine which Transformer and which XML parser
to use.
Xalan-Java also builds on SAX 2 and DOM level 2.
MasonX::Interp::WithCallbacks subclasses HTML::Mason::Interp in order to
provide a Mason callback system built on Params::CallbackRequest. Callbacks
may be either code references provided to the C<new()> constructor, or methods
defined in subclasses of Params::Callback. Callbacks are triggered either for
every request or by specially named keys in the Mason request arguments, and
all callbacks are executed at the beginning of a request, just before Mason
creates and executes the request component stack.
This module brings support for a sort of plugin architecture based on
Params::CallbackRequest to Mason. Mason then executes code before executing
any components. This approach allows you to carry out logical processing of
data submitted from a form, to affect the contents of the Mason request
arguments (and thus the %ARGS hash in components), and even to redirect or
abort the request before Mason handles it.
Cross platform
==============
Kivy is running on Linux, Windows, MacOSX, Android and IOS. You can run the
same code on all supported platforms. It can use natively most inputs
protocols and devices like WM_Touch, WM_Pen, Mac OS X Trackpad and Magic Mouse,
Mtdev, Linux Kernel HID, TUIO. A multi-touch mouse simulator is included.
Business Friendly
=================
Kivy is 100% free to use, under LGPL 3 licence. The toolkit is professionally
developed, backed and used. You can use it in a product and sell your product.
The framework is stable and has a documented API, plus a programming guide to
help for in the first step.
GPU Accelerated
===============
The graphics engine is built over OpenGL ES 2, using modern and fast way of
doing graphics. The toolkit is coming with more than 20 widgets designed to be
extensible. Many parts are written in C using Cython, tested with regression
tests.
XORSearch is a program to search for a given string in an XOR or
ROL encoded binary file. An XOR encoded binary file is a file where
some (or all) bytes have been XORed with a constant value (the key).
A ROL (or ROR) encoded file has it bytes rotated by a certain number
of bits (the key). XOR and ROL/ROR encoding is used by malware
programmers to obfuscate strings like URLs.
XORSearch will try all XOR keys (0 to 255) and ROL keys (1 to 7)
when searching. I programmed XORSearch to include key 0, because
this allows to search in an unencoded binary file (X XOR 0 equals
X).
If the search string is found, XORSearch will print it until the 0
(byte zero) is encountered or until 50 characters have been printed,
which ever comes first. 50 is the default value, it can be changed
with option -l. Unprintable characters are replaced by a dot.
clockspeed uses a hardware tick counter to compensate for a persistently
fast or slow system clock. Given a few time measurements from a reliable
source, it computes and then eliminates the clock skew.
sntpclock checks another system's NTP clock, and prints the results in a
format suitable for input to clockspeed. sntpclock is the simplest
available NTP/SNTP client.
taiclock and taiclockd form an even simpler alternative to SNTP. They
are suitable for precise time synchronization over a local area network,
without the hassles and potential security problems of an NTP server.
This version of clockspeed can use the Pentium RDTSC tick counter or the
Solaris gethrtime() nanosecond counter.
A port to non-i386 platforms was done using the clock_gettime(2)
function. Since this is somewhat experimental, there might be some
tiny precision differences from the i386 platform versions. You
have been warned!
CVC3 is an automatic theorem prover for Satisfiability Modulo Theories (SMT)
problems. It can be used to prove the validity (or, dually, the
satisfiability) of first-order formulas in a large number of built-in logical
theories and their combination.
CVC3 is the last offspring of a series of popular SMT provers, which originated
at Stanford University with the SVC system. In particular, it builds on the
code base of CVC Lite, its most recent predecessor. Its high level design
follows that of the Sammy prover.
CVC3 works with a version of first-order logic with polymorphic types and has
a wide variety of features including:
* several built-in base theories: rational and integer linear arithmetic,
arrays, tuples, records, inductive data types, bit vectors, and equality
over uninterpreted function symbols;
* support for quantifiers;
* an interactive text-based interface;
* a rich C and C++ API for embedding in other systems;
* proof and model generation abilities;
* predicate subtyping;
* essentially no limit on its use for research or commercial purposes
(see license).
[ excerpt from developer's site ]
It is a free library for decoding mpeg-2 and mpeg-1 video
streams. The main goals in libmpeg2 development are:
Conformance - libmpeg2 is able to decode all mpeg streams that
conform to certain restrictions: "constrained parameters" for
mpeg-1, and "main profile" for mpeg-2. In practice, this is what
most people are using. For streams that follow these restrictions,
we believe libmpeg2 is 100% conformant to the mpeg standards - and
we have a pretty extensive test suite to check this.
Speed - for most current systems, the display will actually take
more time than the mpeg-2 decoding. For systems that have hardware
color conversion and scaling (as we can use with the xv extension
in Xfree 4), you should be able to watch DVD streams on a Celeron
400. On a PIII/666 with null display you should get about 110 frames
per second.
Portability - most of the code is written in C, and when we use
platform-specific optimizations we always have a generic C routine
to fall back on.
PPSSPP is a HLE ("high level emulation") emulator, it simulates the
PSP OS as seen by the game rather than the full hardware. A program
running on the PSP OS can send raw display lists to the graphics
chips, but can't access the flash controller or the Media Engine
directly, instead it has to go through libraries and the PSP OS
kernel. We simply simulate these. This is a lot of work though, the
PSP OS is large and has plenty of functionality so achieving 100%
compatibility is difficult bordering on the impossible. We can get
close though.
File-HStore is a very minimalist perl library to store files on a
filesystem using a very simple hash-based storage.
File-HStore is nothing more than a simple wrapper interface to a
storage containing a specific directory structure where files are hold
based on their hashes. The name of the directories is based on the
first two bytes of the hexadecimal form of the digest. The file is
stored and named with its full hexadecimal form in the corresponding
prefixed directory.
The current version is supporting the SHA-1 and SHA-2 (256 bits)
algorithm. The FAT (Free Archive Toolkit) format is also supported and
it is composed of the date of submission plus the SHA-2 real digest
part.
gbemol is a graphical frontend for the Music Player Daemon (MPD) it is
written in C and uses the GTK+ toolkit for it's interface.