Free common lisp software for linux

Emacs Common Lisp is an implementation of Common Lisp, written in Emacs Lisp. It does not yet purport to conform to the ANSI standard since, among other things, CLOS, and pretty printing are missing.

However, most other Common Lisp features like lexical closures,
packages, readtables, multiple values, bignums, adjustable arrays, etc, are present. At this stage many bugs remain and error checking is sparse.

This implementation provides a Common Lisp environment, separate from Emacs Lisp, running in Emacs. It does not intend to extend Emacs Lisp with Common Lisp functionality; however, Common Lisp functions compile to byte code, so Emacs Lisp functions can call Common Lisp functions and vice versa.

All Emacs Lisp data can be passed unchanged to Common Lisp functions, except vectors, which are used to implement various Common Lisp types not present in Emacs Lisp.

An Emacs Lisp vector should be converted to a Common Lisp vector (SIMPLE-VECTOR or VECTOR) when passed to a Common Lisp function.

Common Lisp Kanji Drill, or CLKD in short, is a newly-released program for learning the meanings of Chinese/Japanese characters (kanji) by means of repeated tests. The project is developed using CLISP, and runs on GNU/Linux and on MS Windows under Cygwin. CLKD uses a web browser as its interface. (These work best: Firefox 1.0.4 or newer; or Internet Explorer 7 or newer),. Japanese fonts are required.

CLKD is not intended for complete beginners in Japanese or Chinese to just start learning characters by rote. Its best to learn something about the structure of these characters by reading a few good books about them. It helps to know how to write them, how to count strokes, and how to look up characters in dictionaries which classify them by radical and components.

But all these resources still leave a big task: the raw memorization of hundreds and hundreds of characters. That is where a tool like CLKD becomes valuable.

CLKD is ideally suited to someone who has already broken through the unfamiliarity barrier: the student who can already recognize familiar components in an unfamiliar character and mentally form a mnemonic to which he or she can anchor the meanings of that character, and who is ready to begin internalizing a large number of characters.

GNU ccRTP is an implementation of RTP, the real-time transport protocol from the IETF (see RFC 3550, RFC 3551 and RFC 3555). ccRTP is a C++ library based on GNU Common C++ which provides a high performance, flexible and extensible standards-compliant RTP stack with full RTCP support. The design and implementation of ccRTP make it suitable for high capacity servers and gateways as well as personal client applications.
In designing ccRTP, we have taken into account that RTP has been defined as an application level protocol framework rather than a typical Internet transport protocol such as TCP and UDP. Thus, RTP is hardly ever implemented as a layer separated from the application.
Consequently, RTP applications often must customize the adaptable RTP packet layout and processing rules, timing constraints, session membership rules as well as other RTP and RTCP mechanisms. ccRTP aims to provide a framework for the RTP framework, rather than being just an RTP packet manipulation library.
Support for both audio and video data is also considered in the design of ccRTP, that can do partial frame splits/re-assembly. Unicast, multi-unicast and multicast transport models are supported, as well as multiple active synchronization sources, multiple RTP sessions (SSRC spaces), and multiple RTP applications (CNAME spaces). This allows its use for building all forms of Internet standards based audio and visual conferencing systems.
GNU ccRTP is threadsafe and high performance. It uses packet queue lists for the reception and transmission of data packets. Both inter-media and intra-media synchronization is automatically handled within the incoming and outgoing packet queues. GNU ccRTP offers support for RTCP and many other standard and extended features that are needed for both compatible and advanced streaming applications.
It can mix multiple payload types in stream, and hence can be used to impliment RFC 2833 compliant signaling applications as well as other specialized things. GNU ccRTP also offers direct RTP and RTCP packet filtering.
GNU ccRTP uses templates to isolate threading and sockets related dependencies, so that it can be used to impliment realtime streaming with different threading models and underlying transport protocols, not just with IPV4 UDP sockets. For a more detailed list of ccRTP features you can have a look at the programmers manual.
At its highest level, ccRTP provides classes for the real-time transport of data through RTP sessions, as well as the control functions of RTCP.
The main concept in the ccRTP implementation of RTP sessions is the use of packet queues to handle transmission and reception of RTP data packets/application data units. In ccRTP, a data block is transmitted by putting it into the transmission (outgoing packets) queue, and received by getting it from the reception (incoming packets) queue.
Main features:
- Highly extensible to specialized stacks.
- Supports unicast, multi-unicast and multicast. Handles multiple sources (including synchronization sources and contributing sources) and destinations. Also supports symmetric RTP.
- Automatic RTCP functions handling, such as association of synchronization sources from the same participant or NTP-RTP timestamp mapping.
- Genericity as for underlying network and transport protocols through templates.
- It is threadsafe and supports almost any threading model.
- Generic and extensible RTP and RTCP header validity checks.
- Handles source states and information as well as statistics recording.
- Automatically handles SSRC collisions and performs loop detection.
- Implements timer reconsideration and reverse reconsideration.
- Provides good random numbers, based on /dev/urandom or, alternatively, on MD5.
There are several levels of interface (public interface, public or protected inheritance, etc) in ccRTP. For instance, the rtphello demo program distributed with ccRTP just uses the public interface of the RTPSession class and does not redefine the virtual method onGotSR, thus what this program knows about SR reports is the information conveyed in the last sender report from any source, which can be retrieved via the getMRSenderInfo method of the SyncSource class.
On the contrary, the rtplisten demo program redefines onGotSR by means of inheritance and could do specialized processing of these RTCP packets. Generally, both data and control packets are not directly accessible through the most external interface.
All this functions are performed through a few essential classes and types. The most basic ones are the enumerated type StaticPayloadType, and the classes StaticPayloadFormat and DynamicPayloadFormat.
The most important ones are the classes RTPSession, SyncSource, Participant and AppDataUnit, that represent RTP sessions, synchronization sources, participants in an RTP application, and application data units conveyed in RTP data packets, respectively.
When using ccRTP, both sending and receiving of data transported over RTP sessions is done through reception and transmission queues handled by the RTP stack. In the most common case, a separate execution thread for each RTP session handles the queues. This case is the threading model that we will generally assume throughout this document. Note however that ccRTP supports other threading models, particularly ccRTP supports the use of a single execution thread to serve a set of RTP sessions. It is also possible to not associate any separate thread with any RTP session, manually calling the main data and control service methods from whatever other thread.
The basic idea for packet reception with ccRTP is that the application does not directly read packets from sockets but gets them from a reception queue. The stack is responsible for inserting received packets in the reception queue and handling this queue. In general, a packet reception and insertion in the reception queue does not occur at the same time the application gets it from the queue.
Conversely, the basic idea for packet transmission with ccRTP is that packets are not directly written to sockets but inserted in a transmission queue handled by the stack. In general, packet insertion and transmission occur at different times, though it is not necessary.
In order to use ccRTP, you must include the main header (#include < ccrtp/rtp.h >. Two additional headers are provided by ccRTP:
#include < ccrtp/rtppool.h
Classes for pools of RTP service threads.
#include < ccrtp/rtpext.h >
Classes for RTP extensions which are not mature yet.
You must also link in the library, currently ccrtp1.
Enhancements:
- Brand new support has been introduced for Secure RTP Profile (srtp) as per RFC 3711.
- This release also supports a new add-on package, libzrtpcpp, that directly offers native zfone (zrtp) compatible encryption capabilities to Common C++ RTP based applications.
- This is the first softphone client to use both Common C++ RTP srtp and zrtp support.

GNU CLISP is an ANSI Common Lisp implementation with an interpreter, compiler, debugger, object system (CLOS, MOP), sockets, fast bignums, and foreign language interface which runs on most UNIXes and Win32.
Common Lisp is a high-level, all-purpose, object-oriented, dynamic, functional programming language.
CLISP is a Common Lisp implementation by Bruno Haible, then of Karlsruhe University, and Michael Stoll, then of Munich University, both in Germany. GNU CLISP supports the Lisp described in the ANSI Common Lisp standard plus many extensions.
CLISP includes an interpreter, a compiler, a debugger, CLOS, MOP, a foreign language interface, i18n, regular expressions, a socket interface, and more. An X11 interface is available through CLX, Garnet and CLUE/CLIO. Command line editing is provided by readline. CLISP runs Maxima, ACL2 and many other Common Lisp packages.
CLISP runs on most Unix workstations (Linux, FreeBSD, NetBSD, OpenBSD, Solaris, Tru64, HP-UX, BeOS, NeXTstep, IRIX, AIX and others) and on other systems (Windows NT/2000/XP, Windows 95/98/ME) and needs only 4 MB of RAM.
CLISP is Free Software and may be distributed under the terms of GNU GPL. You may distribute commercial proprietary applications compiled with CLISP, see file COPYRIGHT in the CLISP distribution.
The user interface comes in English, German, French, Spanish, Dutch, Russian and Danish, and can be changed at run time.
Enhancements:
- The new libsvm module makes Support Vector Machines available in CLISP.

XNap Commons project provides a set of utility Java classes for easy handling of common tasks like sortable tables, auto completion, and internationalization, a settings framework, and Swing components like common dialogs, a wizard, a closeable tabbed pane, a directory chooser, and whats-this-style context help.
Enhancements:
# New Features:
- IconHelper has been enhanced with a methods getApplicationIcons() to retrieve a list of application icons and getSystemTrayIcon() to retrieve an icon for the Java 6 system tray.
# Fixed bugs:
- The CloseableTabbedPane has been fixed to work on Java 6.

MyPageKit::Common is a Perl model class containing code common across site.

This class contains methods that are common across the site, such as authentication and session key generation. This particular class is an example class that is used for the old pagekit.org website. It is derived from Apache::PageKit::Model and a base class for the Model classes for the pagekit.org site.

It is a good starting point for building your own base class for your Model classes.

Shelisp is a very short program that provides mechanisms for composing and running Unix shell (particularly bash) commands and constructs from Common Lisp.
To run shelisp, say at the command prompt:
lisp -load shelisp.lisp
This should start CMU Common Lisp and provide the prompt, *. A more convenient form could be to start emacs, and issue the command M-x cmulisp that will start an `inferior lisp mode with cmu; then, say:
(load "shelisp.lisp")
The bang (!) escape to shell
Now you can say (the * is already put there by cmulisp):
- !ls
And it will execute the shell ls command (by running a bash instance and passing the command to it.
Of course, you are actually in Lisp. You can try this:
- (defun factorial (x) (if (zerop x) 1 (* x (factorial (1- x)))))
FACTORIAL
- (factorial 33)
8683317618811886495518194401280000000
So, if you enter ``! the rest of the line (until the first end of line that is not escaped with a ``) is interpreted as a bash command and the result is printed on the standard output.
Now try:
- !echo ?(+ 2 3) zuzu
5zuzu
The `? is the lisp escape. It is followed by an s-expression which is read, executed and printed (with princ) and the printed result replaces the `? and the expression in the shell command. It can be any Lisp expression.
- !echo ?(+ 2/3 2/11) "<<less