Uniutils consists of five programs for finding out what is in a Unicode file.
They are useful when working with Unicode files when one doesn't know the
writing system, doesn't have the necessary font, needs to inspect invisible
characters, needs to find out whether characters have been combined or in what
order they occur, or needs statistics on which characters occur.
uniname defaults to printing the character offset of each character, its byte
offset, its hex code value, its encoding, the glyph itself, and its name.
unidesc reports the character ranges to which different portions of the text
belong. It can also be used to identify Unicode encodings (e.g. UTF-16be)
flagged by magic numbers.
unihist generates a histogram of the characters in its input, which must be
encoded in UTF-8 Unicode.
ExplicateUTF8 is intended for debugging or for learning about Unicode. It
determines and explains the validity of a sequence of bytes as a UTF8 encoding.
Unirev is a filter that reverses UTF-8 strings character-by-character (as
opposed to byte-by-byte).
This little program analyses the structure of FORTRAN source-code. As a
result you get a little flow diagram in which you can recognize which
SUBROUTINE is called by the program. Further all subroutines called from this
one are displayed. The indciation of the displayed names is a degree for the
level.
A new addition is the change of the starting point for an analysis. Instead to
check the whole source-code you can start with a special SUBROUTINE and see
the depence of this one.
The number of files which contain the routines are not restricted by the
program.
You can report the CALL- and/or SUBROUTINE-statements together with filenames
and line numbers to special files.
Dirk Geschke
7. March 1997
A Python interface to libarchive. It uses the standard ctypes module to
dynamically load and access the C library.
This package provides a Perl interface to the F5 BigIP iControl API.
The F5 BigIP iControl API is an open SOAP/XML for communicating with supported
F5 BigIP products.
This module provides an API for parts of the perl parser. It can be
used to modify code while it's being parsed.
SLOCCount can count physical SLOC for a wide number of languages. It can
gracefully handle awkward situations in many languages, for example, it can
determine the syntax used in different assembly language files and adjust
appropriately, it knows about Python's use of string constants as comments,
and it can handle various Perl oddities (e.g., perlpods, here documents, and
Perl's __END__ marker). It even has a "generic" SLOC counter that you may be
able to use count the SLOC of other languages (depending on the language's
syntax).
SLOCCount can also take a large list of files and automatically categorize
them using a number of different heuristics. The heuristics automatically
determine if a file is a source code file or not, and if so, which language
it's written in. It will even examine file headers to attempt to accurately
determine the file's true type. As a result, you can analyze large systems
completely automatically.
Finally, SLOCCount has some report-generating tools to collect the data
generated, and then present it in several different formats and sorted
different ways. The report-generating tool can also generate simple tab-
separated files so data can be passed on to other analysis tools (such as
spreadsheets and database systems).
The objective of the package is to provide a fast and essential HTML check (esp.
for CGI scripts where response time is important) to prevent a piece of user
input HTML code from messing up the rest of a file, i.e., to minimize and
localize any possible damage created by including a piece of user input HTML
text in a dynamic document.
HTMLQuickCheck checks for unmatched < and >, unmatched tags and improper
nesting, which could ruin the rest of the document. Attributes and elements
with optional end tags are not checked, as they should not cause disasters with
any decent browsers (they should ignore any unrecognized tags and attributes
according to the standard). A piece of HTML that passes HTMLQuickCheck may not
necessarily be valid HTML, but it would be very unlikely to screw others but
itself. A valid piece of HTML that doesn't pass the HTMLQuickCheck is however
very likely to screw many browsers(which are obviously broken in terms of strict
conformance).
HTMLQuickCheck currently supports HTML 1.0, 2.x (draft), 3.0 (draft) and
netscape extensions (1.1).
*** WARNING *** THIS MODULE IS STILL EXPERIMENTAL !!!
This module is related to the possible transition of Catalyst from NEXT
to Class::C3. This transition hasn't happened yet, and might not for
a while.
This module is only intended for use by Catalyst module developers at
this time. You would know it if you should be using this module.
*** END WARNING ***
Torrus is designed to be the universal data series processing framework.
Although most users deploy Torrus for SNMP monitoring, it might be useful for
data series of any nature. Tobi Oetiker's RRDtool is used for data storage.
* Configuration compiler and validator. It processes the XML configuration
files and saves the configuration into a database.
* View renderer and the web interface. They generate HTML and the graphical
representation of the datasources and provide user authentication and
authorization. All generated output is controlled by the configuration
parameters and templates. The users can easily create their own
presentation of data series.
* SNMP Collector. Modular collector core architecture allows further
extension with new collector and storage types. Any datasource can have
its own polling schedule.
* SNMP Device Discovery Tool. Devdiscover is a new, modular, flexible, and
expandable tool for automatic generation of Torrus configuration files.
New device types and MIBs are easily added as independent Perl modules.
* Threshold monitor. All data, regardless of their type and nature, can be
monitored according to the user-defined rules. The rules can also include
the datasource-specific parameters, e.g. boundary values etc. The
thresholds are specified by RPN expressions.
QEMU is a FAST! processor emulator using dynamic translation to achieve
good emulation speed.
QEMU has two operating modes:
* Full system emulation. In this mode, QEMU emulates a full system
(for example a PC), including a processor and various peripherials.
It can be used to launch different Operating Systems without rebooting
the PC or to debug system code.
* User mode emulation (Linux host only). In this mode, QEMU can launch
Linux processes compiled for one CPU on another CPU. It can be used to
launch the Wine Windows API emulator or to ease cross-compilation and
cross-debugging.
As QEMU requires no host kernel patches to run, it is very safe and easy to use.
This is a slave port of emulators/qemu-sbruno to build only static
bsd-user targets named like qemu-mips-static. While still being
experimental people have already built quite a few armv6/mips/mips64
packages using these and e.g. poudriere. Some notes are also here:
http://wiki.freebsd.org/QemuUserModeHowTo