Free common features software for linux

Common Music (CM) is an object-oriented music composition environment.

Common Music produces sound by transforming a high-level representation of musical structure into a variety of control protocols for sound synthesis and display.

CMU Common Lisp is a free implementation of the Common Lisp programming language which runs on most major Unix platforms. CMU Common Lisp project mainly conforms to the ANSI Common Lisp standard.
Main features:
- a sophisticated native-code compiler which is capable of powerful type inferences, and generates code competitive in speed with C compilers.
- generational garbage collection and multiprocessing capability on the x86 ports.
- a foreign function interface which allows interfacing with C code and system libraries, including shared libraries on most platforms, and direct access to Unix system calls.
- support for interprocess communication and remote procedure calls.
- an implementation of CLOS, the Common Lisp Object System, which includes multimethods and a metaobject protocol.
- a graphical source-level debugger using a Motif interface, and a code profiler.
- an interface to the X11 Window System (CLX), and a sophisticated graphical widget library (Garnet).
- programmer-extensible input and output streams.
- an Emacs-like editor implemented in Common Lisp.
- freely redistributable: free, with full source code (most of which is in the public domain) and no strings attached (and no warranty). Like the GNU/Linux and *BSD operating systems, CMUCL is maintained and improved by a team of volunteers collaborating over the Internet.
Common Lisp is well suited to large programming projects and explorative programming. The language has a dynamic semantics which distinguishes it from languages such as C and Ada.
It features automatic memory management, an interactive incremental development environment, a module system, a large number of powerful data structures, a large standard library of useful functions, a sophisticated object system supporting multiple inheritance and generic functions, an exception system, user-defined types and a macro system which allows programmers to extend the language.
Enhancements:
- A new float type EXT:DOUBLE-DOUBLE-FLOAT is supported.
- A DOUBLE-DOUBLE-FLOAT uses two DOUBLE-FLOATs to represent a number with >= 106 bits of precision (about 33 digits).
- Hash tables now support weak value, weak key- and-value, and weak key-or-value tables.
- LONG-LONG and UNSIGNED-LONG-LONG are recognized types in the C-CALL package for signed and unsigned 64-bit integers.
- The generational garbage collector has been ported to Darwin/ PPC.
- Numerous bugs and ANSI-compliance problems have been fixed.

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.

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.

Common Text Transformation Library, CTTL for short, is a set of C++ classes and functions to understand and modify text data. Common Text Transformation Library implementation is based on STL classes and algorithms.
Concept of a substring plays major role in design of the text transformation library. CTTL substring is an object that interacts with fragments of text encapsulated by STL std::basic_string template class.
Template classes cttl::const_edge and cttl::edge, designed for constant and mutable data access, respectively, represent CTTL substrings. Substrings may be compared, inserted, deleted, or replaced across multiple text inputs. If content of text mutates, the substrings adjust their positions accordingly to the change. CTTL guarantees that substrings remain stable with respect to a potentially mutable text.
Within CTTL framework, a substring may be parsed with EBNF-like grammar. CTTL lexical analysis engine generates a stream of substrings corresponding to the parsed symbols. BNF and EBNF grammars can be written directly in C++.
Template meta-programming and operator overloading offer features to write C++ expressions that describe grammar rules. No additional steps of parsing, compiling, or generating source code are required. Compiled CTTL program implements LL(INF)-parser, the recursive-descent parser with infinite lookahead.
Enhancements:
- This release focuses on documentation enhancements, which include multiple documentation improvements and revisions.
- An alphabetical index of all CTTL facilities was added: http://cttl.sourceforge.net/documentation_idx.html.

Smart Common Input Method platform is a development platform that significantly reduces the difficulty of input method development.
SCIM splits input method into three parts: FrontEnd, which handles user interface and communication with client applications, Server, which handles the key event to string conversion work, and BackEnd, which manages all of the Servers.
Enhancements:
- The implementation of scim::Socket was improved for better error handling.
- A high power consumption issue caused by the X11 frontend was fixed.

GNU Common C++ project is a C++ framework offering portable support for threading, sockets, file access, daemons, persistence, serial I/O, XML parsing, and system services, initially started by David Sugar and Daniel Silverstone.

GNU Common C++ is a GNU package and is licensed to the terms of the GNU GPL with specific privileges similar to Guile, which constitute privileges similar to the LGPL but more appropriate for a C++ class framework. GNU Common C++ offers support and portable classes for threading and sockets for both UNIX (Posix systems with "pthread" support) and the Windows "Win32" API.

GNU Common C++ uses extensive autoconf macro sets for automatic detection of various levels of "pthread compliance" in your target platform and attempts to adjust itself appropriately. GNU Common C++ has been tested from time to time with GNU/Linux, FreeBSD, Solaris, and DEC Tru64 Unix. Recent work has also been done to help support HP/UX. While GNU Common C++ is not directly related to GNU portable threading (GNU Pth), it should work with the Pth "pthread emulation" library at present. Work is planned to make GNU Common C++ directly support GNU Pth.

The primary goal of GNU Common C++ is to promote a very low overhead abstract C++ interface to common system services. Consistent with this goal, and the desire for broad portability with wide compiler support, specific aspects and practices in C++ programming were selected when writing code in this package, and other practices were discarded that seemed to detract from this goal.

Regexp::Common::time Perl module contains date and time regexps.

SYNOPSIS

use Regexp::Common qw(time);

# Piecemeal, Time::Format-like patterns
$RE{time}{tf}{-pat => pattern}

# Piecemeal, strftime-like patterns
$RE{time}{strftime}{-pat => pattern}

# Match ISO8601-style date/time strings
$RE{time}{iso}

# Fuzzy date patterns
# YEAR/MONTH/DAY
$RE{time}{ymd} # Most flexible
$RE{time}{YMD} # Strictest (equivalent to y4m2d2)
# Other available patterns: y2md, y4md, y2m2d2, y4m2d2

# MONTH/DAY/YEAR (American style)
$RE{time}{mdy} # Most flexible
$RE{time}{MDY} # Strictest (equivalent to m2d2y4)
# Other available patterns: mdy2, mdy4, m2d2y2, m2d2y4

# DAY/MONTH/YEAR (European style)
$RE{time}{mdy} # Most flexible
$RE{time}{MDY} # Strictest (equivalent to d2m2y4)
# Other available patterns: dmy2, dmy4, d2m2y2, d2m2y4

# Fuzzy time pattern
# HOUR/MINUTE/SECOND
$RE{time}{hms} # H: matches 1 or 2 digits; 12 or 24 hours
# M: matches 2 digits.
# S: matches 2 digits; may be omitted
# May be followed by "a", "am", "p.m.", etc.

This module creates regular expressions that can be used for parsing dates and times. See Regexp::Common for a general description of how to use this interface.

Parsing dates is a dirty business. Dates are generally specified in one of three possible orders: year/month/day, month/day/year, and day/month/year. Years can be specified with four digits or with two digits (with assumptions made about the century). Months can be specified as one digit, two digits, as a spelled-out name, or as a three-letter abbreviation. Day numbers can be one digit or two digits, with limits depending on the month (and, in the case of February, even the year). Also, different people use different punctuation for separating the various elements.
A human can easily recognize that "October 21, 2005" and "21.10.05" refer to the same date, but its tricky to get a program to come to the same conclusion. This module attempts to make it possible to do so, with a minimum of difficulty.

If you know the exact format of the data to be matched, use one of the specific, piecemeal pattern builders: tf or strftime. If there is some variability, use one of the fuzzy-matching patterns in the dmy, mdy, or ymd families. If the data are wildly variable, such as raw user input, give up and use the Date::Manip or Date::Parse module.

Time values are generally much simpler to parse than date values. Only one fuzzy pattern is provided, and it should suffice for most needs.