Free lr software for linux

Solaris::MapDev Perl module contains a map between instance numbers and device names.

SYNOPSIS

use Solaris::MapDev qw(inst_to_dev dev_to_inst);
my $disk = inst_to_dev("sd0");
my $nfs = inst_to_dev("nfs123");
my $inst = dev_to_inst("c0t0d0s0");
mapdev_data_files(path_to_inst => "/copy/of/a/path_to_inst",
mnttab => "/copy/of/a/mnttab",
dev_ls => { "/dev/rdsk" => "ls-lR/of/dev_dsk",
"/dev/rmt" => "ls-lR/of/dev_rmt" });
my $tape = inst_to_dev("st1");

This module maps both ways between device instance names (e.g. sd0) and /dev entries (e.g. c0t0d0). Vanilla SCSI disks, SSA disks, A1000, A3000, A3500 and A5000 disks are all catered for, as are tape devices and NFS mounts.

FUNCTIONS

inst_to_dev($inst)

Return the device name name given the instance name

dev_to_inst($dev)

Return the instance name given the device name

get_inst_names

Return a sorted list of all the instance names

get_dev_names

Return a sorted list of all the device names

mapdev_data_files

This tells mapdev to use data held in copies of the real datafiles, rather than the current "live" files on the system. This is useful for example when examining explorer output. A list of key-value pairs is expected as the arguments. Valid keys-value pairs are:

path_to_inst => "/copy/of/a/path_to_inst",

A valid path_to_inst file. This is mandatory.

mnttab => "/copy/of/a/mnttab",

A valid /etc/mnttab file. This is optional - if not
specified, no information on NFS devices will be displayed.

dev_ls => { "/dir/path" => "/ls-lR/of/dir/path",
... });

A hash containing path/datafile pairs. The paths should
be one of /dev/rdsk, /dev/osa/rdsk, /dev/osa/dev/rdsk or
/dev/rmt. The datafiles should be the output of a "ls -l"
of the specified directory. A single file containing a
recursive "ls -Rl" of /dev is also acceptable.

mapdev_system_files

This tells mapdev to revert to using the current "live" datafiles on the system - see "mapdev_data_files()"

Rats! is an easily extensible parser generator for C-like languages; though currently it only generates parsers in Java. Rats! project has been explicitly designed so that grammars are concise and easily modifiable. To this end, Rats!
- organizes grammars into modules,
- builds on parsing expression grammars instead of context-free grammars and vintegrates lexing with parsing, i.e., is scannerless,
- supports the automatic generation of abstract syntax trees,
- and provides a well-defined interface for extending parsers to recognize context-sensitive languages and formats.
Parsers generated by Rats! memoize intermediate results, which ensures linear time performance in the presence of unlimited lookahead and backtracking. As a result, they are essentially functional (even though they are implemented in an imperative language) and also called "packrat parsers."
Main features:
- Rats! relies on a module system to structure grammars and their extensions. In particular, it relies on modules to group related productions into separate units. Next, module modifications concisely express extensions to other modules and can add, change, or remove individual alternatives in productions. Finally, module parameters are used to compose modules and their extensions with each other.
- Rats! grammars build on parsing expression grammars (PEGs). While PEGs share many constructs with the familiar EBNF notation, a key difference is that they utilize ordered choices instead of the unordered choices used by context-free grammars (CFGs) and other parser generators, such as Yacc or ANTLR. As a result, Rats! grammars avoid ambiguities and support localized changes. Additional flexibility is offered through syntactic predicates, which match expressions but do not consume the input, thus providing unlimited lookahead, and through the integration of lexing with parsing, which greatly simplifies the addition of new tokens to a grammar. PEGs have the additional benefit that they are not only closed under composition (unlike the LR or LL grammars used by Yacc and ANTLR), but also intersection and complement (unlike CFGs in general).
- To eliminate the need for explicit semantic actions, Rats! can automatically generate abstract syntax trees. In particular, it supports productions that return no semantic values (such as those recognizing spaces or comments), string values (such as those recognizing literals or identifiers), and generic tree nodes (potentially all other productions).
- Since some computer-readable formats are inherently context-sensitive and cannot be expressed as PEGs (or CFGs), Rats! supports two techniques for managing parser context or state, thus providing a well-defined interface for extending parsers. First, Rats! provides parser actions to recognize expressions that depend on local context, i.e., expressions that depend on immediately preceding expressions within the same production. An example for such local context is an explicit length preceding as many instances of some expression. Second, Rats! supports a global state object to recognize expressions that depend on possibly global context. State modifications are performed within lightweight transactions, which preserve the basically functional nature of Rats!-generated parsers. An example for a global context is the symbol table used for disambiguating variable and typedef names when parsing C.
Enhancements:
- Release highlights are support for formatting-preserving source refactorings through parse trees, support for parsing and pretty printing Java 5, (an improved abstract syntax tree for Java, and improved support for type checking C and Java ASTs.

CurlFtpFS is a filesystem for acessing FTP hosts based on FUSE and libcurl. CurlFtpFS project automatically reconnects if the server times out.

Examples:

Using CurlFtpFS is quite simple. Take a look at this example:

$ mkdir sunet
$ curlftpfs ftp://ftp.sunet.se/ sunet/
$ cd sunet/
$ ls -l
total 0
dr-xr-xr-x 3 root root 96 Feb 23 2004 bin
dr-xr-xr-x 2 root root 72 Mar 2 2004 dev
dr-xr-xr-x 2 root root 48 Feb 23 2004 etc
dr-xr-xr-x 2 root root 120 Feb 23 2004 lib
-rw-r--r-- 1 root root 622187310 Mar 11 06:13 ls-lR
-rw-r--r-- 1 root root 76389037 Mar 11 06:15 ls-lR.gz
drwxrwxr-x 37 root root 1272 Feb 27 14:17 pub
dr-xr-xr-x 3 root root 72 Feb 23 2004 usr

File::Listing is a Perl module to parse directory listing.

SYNOPSIS

use File::Listing qw(parse_dir);
for (parse_dir(`ls -l`)) {
($name, $type, $size, $mtime, $mode) = @$_;
next if $type ne f; # plain file
#...
}

# directory listing can also be read from a file
open(LISTING, "zcat ls-lR.gz|");
$dir = parse_dir(*LISTING, +0000);

This module exports a single function called parse_dir(), which can be used to parse directory listings. Currently it only understand Unix ls -l and ls -lR format. It should eventually be able to most things you might get back from a ftp server file listing (LIST command), i.e. VMS listings, NT listings, DOS listings,...
The first parameter to parse_dir() is the directory listing to parse. It can be a scalar, a reference to an array of directory lines or a glob representing a filehandle to read the directory listing from.

The second parameter is the time zone to use when parsing time stamps in the listing. If this value is undefined, then the local time zone is assumed.
The third parameter is the type of listing to assume. The values will be strings like unix, vms, dos. Currently only unix is implemented and this is also the default value. Ideally, the listing type should be determined automatically.
The fourth parameter specifies how unparseable lines should be treated. Values can be ignore, warn or a code reference. Warn means that the perl warn() function will be called. If a code reference is passed, then this routine will be called and the return value from it will be incorporated in the listing. The default is ignore.

Only the first parameter is mandatory.

The return value from parse_dir() is a list of directory entries. In a scalar context the return value is a reference to the list. The directory entries are represented by an array consisting of [ $filename, $filetype, $filesize, $filetime, $filemode ]. The $filetype value is one of the letters f, d, l or ?. The $filetime value is the seconds since Jan 1, 1970. The $filemode is a bitmask like the mode returned by stat().

Net::Google::tool is a base class for Net::Google service classes.

Base class and shared methods for Net::Google service classes.

SYNOPSIS

use Net::Google;
use constant LOCAL_GOOGLE_KEY => "********************************";

my $google = Net::Google->new(key=>LOCAL_GOOGLE_KEY);
my $search = $google->search();

# Search interface

$search->query(qw(aaron straup cope));
$search->lr(qw(en fr));
$search->starts_at(5);
$search->max_results(15);

map { print $_->title()."n"; } @{$search->results()};

# or...

foreach my $r (@{$search->response()}) {
print "Search time :".$r->searchTime()."n";

# returns an array ref of Result objects
# the same as the $search->results() method
map { print $_->URL()."n"; } @{$r->resultElements()};
}

# Spelling interface

print $google->spelling(phrase=>"muntreal qwebec")->suggest(),"n";

# Cache interface

my $cache = $google->cache(url=>"http://search.cpan.org/recent");
print $cache->get();

Dragon is a powerful parser generator. It produces a consequent, object-oriented, integrated scanner and parser solution. Dragon parser generator also scales for very large grammar defintions. Since dragon parses LR(1) grammars, the generation algorithm is quite CPU intensive.
Using LR(1) instead of LALR decreases efficiency of the parser, but avoids some reduce/reduce conflicts in some cases. Dragon provides a very clean and structured way for the integration of application specific context code. Dragon combines the lexical and syntactical analysis and the corresponding code generation.
Enhancements:
- The switch option -y was added to switch between a dynamically allocated parse table or a static parse table.
- An escape feature was added for special token definitions.

jPicEdt is a multi-platform vector-based graphic editor for LaTeX and related packages, including eepic and PsTricks.
The LaTeX picture environment is a special environment for inserting simple drawing commands into a LaTeX file.
This environment was obviously not intented to replace more sophisticated graphical formats such as Postscript or PDF (and their associated design tools: Adobe Illustrator, Macromedia Freehand,...), but was merely aimed at easily incorporating small and simple drawings (e.g. graphs, electrical schematics,...)
Yet picture commands are flexible enough to allow one to build rather complicated drawings, including circles, rectangles, lines and vectors, bezier splines.
Besides, using epic/eepic or PsTricks packages largely increases the set of available commands, and amongst other things, allows for shape-filling (and colours with PsTricks) and a better rendering of shapes.
Finally, one of the main benefits of using the picture environment is the ability to incorporate text containing any LaTeX command allowed in LR mode, e.g. equations, arrays or user-defined commands.
Main features:
- Every graphical element allowed by the picture environment commands: lines, arrows, circles, boxes.
- Emulated elements, for example lines of any slope (which LaTeX doesnt support natively), circles of any size, ellipses, arcs and polygons. This makes a strong use of the multiput command.
- Nearly every object allowed by the epic/eepic packages (excluding grids and textured filling): dashed lines, filled (whitened, blackened or shaded) ellipses or polygons, arcs,... Using this package is optional.
- Starting from version 1.3.2, nearly every object in the pstricks.sty package (this include : filling with colors, hatches, textures, setting various stroke parameters, rotating texts,...). Support for pst-node.sty and other related packages is either experimental (meaning that you must recompile with a boolean flag turned on) or simply underway.