This module attempts to generate a stack dump from a core file by
locating the best available debugger (if any) and running it with the
appropriate arguments and command script.
Annoy, like your annoying friend that asks you questions all the time. Rudy
uses annoy to present the user with a simple question before continuing with a
destructive action.
xa is a high-speed, two-pass portable cross-assembler. It understands
mnemonics and generates code for:
NMOS 6502s (such as 6502A, 6504, 6507, 6510, 7501, 8500, 8501, 8502, ...)
CMOS 6502s (65C02 and Rockwell R65C02) and the 65816
Key amongst its features:
- C-like preprocessor (understands cpp for additional feature support)
- Rich expression syntax and pseudo-op vocabulary
- Multiple character sets
- Binary linking
- Supports o65 relocatable objects with a full linker and relocation
suite, as well as "bare" plain binary object files
- Block structure for label scoping
This automatically logs a user out if they're idle for a set amount
of time. We define 'idle' as having not refreshed the right-hand
frame. The administrator can set a standard time for all users or
allow users to set their own timeout values.
In Perl 5.8.0 the so-called "safe signals" were introduced. This means that Perl
no longer handles signals immediately but instead "between opcodes", when it is
safe to do so. The earlier immediate handling easily could corrupt the internal
state of Perl, resulting in mysterious crashes.
It's possible since perl 5.8.1 to globally disable this feature by using the
PERL_SIGNALS environment variables (as specified in "PERL_SIGNALS" in perlrun);
but there's no way to disable it locally, for a short period of time. That's
however something you might want to do, if, for example, your Perl program calls
a C routine that will potentially run for a long time and for which you want to
set a timeout.
This module therefore allows you to define UNSAFE_SIGNALS blocks in which
signals will be handled "unsafely".
GNU Prolog is a free Prolog compiler with constraint solving over finite
domains developed by Daniel Diaz.
GNU Prolog accepts Prolog+constraint programs and produces native binaries
(like gcc does from a C source). The obtained executable is then stand-alone.
The size of this executable can be quite small since GNU Prolog can avoid to
link the code of most unused built-in predicates. The performances of GNU
Prolog are very encouraging (comparable to commercial systems).
Beside the native-code compilation, GNU Prolog offers a classical interactive
interpreter (top-level) with a debugger.
The Prolog part conforms to the ISO standard for Prolog with many extensions
very useful in practice (global variables, OS interface, sockets,...).
GNU Prolog also includes an efficient constraint solver over Finite Domains
(FD). This opens contraint logic pogramming to the user combining the power
of constraint programming to the declarativity of logic programming.
Paraphrasing the website:
Mailman is a mailing list manager (MLM); that is, software to help manage
email discussion lists, much like Majordomo, LISTSERV, and the like.
Unlike most similar products, Mailman gives each mailing list a web page
and allows users to subscribe, unsubscribe, and change their preferences
via the web. Even a list manager can administer his or her list(s)
entirely via the web. Mailman integrates many common MLM features,
including web-based archiving (though it also has hooks for external
archivers), mail-to-news gateways, bounce handling, spam prevention,
Majordomo-style email-based list administration, direct SMTP delivery (with
fast bulk mailing), digest delivery, virtual domain support, and more.
Mailman is written mostly in Python (with a smattering of C where necessary
for security purposes), and includes hooks to make it easily scriptable and
extensible. It is compatible with most web servers and browsers, and most
mail transfer agents (mail servers). Mailman's documentation may be found on
its website.
CRlibm is an efficient and proven mathematical library, which
provides implementations of the double-precision C99 standard
elementary functions, correctly rounded in the four IEEE-754 rounding
modes, and sufficiently efficient in average time, worst-case time,
and memory consumption to replace existing libms transparently.
The distribution includes extensive documentation with the proof
of each function (currently more than 100 pages), as well as all
the Maple scripts used to develop the functions. This makes this
library an excellent tutorial on software elementary function
development.
CRlibm also includes a lightweight library for multiple precision,
scslib (Software Carry Save Library). This library has been developed
specifically to answer the needs of the CRlibm project: precision
up to a few hundred bits, portability, compatibility with IEEE
floating-point standards, performance comparable to or better than
GMP, and a small footprint. It uses a data-structure which allows
carry propagations to be avoided during multiple-precision
multiplications, and supports addition, subtraction, multiplication,
and conversions.
oRTP - Real-time Transport Protocol library
Features:
* Written in C, works under Linux (and probably any Unix) and Windows
* Implement the RFC3550 (RTP) with a easy to use API with high and low level
access
* Includes support for multiples profiles, AV profile (RFC3551) being the
one by default
* Includes a packet scheduler for to send and recv packet "on time",
according to their timestamp. Scheduling is optionnal, rtp sessions can
remain not scheduled
* Supports mutiplexing IO, so that hundreds of RTP sessions can be scheduled
by a single thread
* Features an adaptive jitter algorithm for a receiver to adapt to the
clockrate of the sender
* Supports part of RFC2833 for telephone events over RTP
* The API is well documented using doxygen
* Licensed under the Lesser Gnu Public License
* RTCP messages sent periodically since 0.7.0 (compound packet including
sender report or receiver report + SDES)
* Includes an API to parse incoming RTCP packets
Parse::Flex works similar to Parse::Lex, but it uses XS for faster
performance.
This module allows you to construct a lexer analyzer with your custom
rules. Parse::Flex is not intended to be used directly; instead, use the
script makelexer.pl to submit your grammar file. The output of the script
is a custom shared library and a custom .pm module which, among other
things, will transparently load the library and provide interface to your
(custom) lexer. In other words, you supply a grammar.l file to
makelexer.pl and you receive Flex01.pm and Flex02.so . Then, use only the
Flex01.pm - since Flex01.pm will automatically load Flex01.so.
The grammar.l file requires the same syntax as flex(1); that is, the
actions are written in C . See the flex(1) documentation to learn the
syntax, or fetch the sample t/grammar.l file inside this package.