Free string software for linux

String::Scanf can emulate sscanf() of the C library.

SYNOPSIS

use String::Scanf; # imports sscanf()

($a, $b, $c, $d) = sscanf("%d+%d %f-%s", $input);
($e, $f, $g, $h) = sscanf("%x %o %s:%3c"); # input defaults to $_

$r = String::Scanf::format_to_re($f);
or
# works only for Perl 5.005
use String::Scanf qw(); # import nothing

my $s1 = String::Scanf->new("%d+%d %f-%s");
my $s2 = String::Scanf->new("%x %o %s:%3c");

($a, $b, $c, $d) = $s1->sscanf($input);
($e, $f, $g, $h) = $s2->sscanf(); # input defaults to $_

String::Scanf supports scanning strings for data using formats similar to the libc/stdio sscanf().

The supported sscanf() formats are as follows:

%d

Decimal integer, with optional plus or minus sign.

%u

Decimal unsigned integer, with optional plus sign.

%x
Hexadecimal unsigned integer, with optional "0x" or "0x" in front.

%o

Octal unsigned integer.

%e %f %g

(The [efg] work identically.)

Decimal floating point number, with optional plus or minus sign, in any of these formats:

1
1.
1.23
.23
1e45
1.e45
1.23e45
.23e45

The exponent has an optional plus or minus sign, and the e may also be E.

The various borderline cases like Inf and Nan are not recognized.

%s

A non-whitespace string.

%c

A string of characters. An array reference is returned containing the numerical values of the characters.

%%

A literal %.

The sscanf() formats [pnSC] are not supported.

The %s and %c have an optional maximum width, e.g. %4s, in which case at most so many characters are consumed (but fewer characters are also accecpted).

The numeric formats may also have such a width but it is ignored.

The numeric formats may have [hl before the main option, e.g. %hd, but since such widths have no meaning in Perl, they are ignored.

Non-format parts of the parameter string are matched literally (e.g. : matches as :), expect that any whitespace is matched as any whitespace (e.g. matches as s+).

String::RexxParse is a Perl implementation of REXX parse command.
SYNOPSIS
use String::RexxParse qw(parse);
parse $source, q! $var1 $var2 ( $var3 ) $var4 ($var5) $var6 !;
or
use String::PexxParse;
$parse = String::RexxParse->new(q! $var1 $var2 ( $var3 ) $var4 ($var5) $var6 !);
$parse->parse($source);
SYNTAX
parse EXPR, EXPR
The first EXPR is the source string to be parsed and must resolve to a scalar value.
The second EXPR is the template specification. The first time parse is called with a particular template, the template is compiled, then used to parse the source expression. Subsequent parse calls with the same template will use the previously compiled version of the template rather than compile the template again.
The template is specified as a single expression, usually using some single-quotish type of quoting, like q!...! for instance. The variable specifications, (or lvalue specifications) must not contain spaces. If you want data assigned to $qq{$one}, do not specify it as $qq{ $one } but as $qq{$one}. Although both are valid in Perl, only the latter is valid in a String::RexxParse template. Likewise, substr( $b , pos( $source ) , length( $match ) ) is NOT valid, but substr($b,pos($source),length($match)) is. Also, there must be white space following any lvalue specification (unless its the last item in the template). q/$b $c/ is OK, but q/$b$c/ is not.
If a variables value is to be used as a pattern, it is enclosed in parentheses.
Literal patterns are enclosed in either single or double quotes. Patterns can contain spaces within the quotes or parentheses.
A period (.) is used as a placeholder to skip part of the source string.
Numeric patterns (absolute or relative position) are supported. 3, =7, +5, -12, =($n), +($x), -($somenumber) are all numeric patterns (if you use variables inside parentheses preceeded by =, +, or -, make sure they contain numeric values). Remember that Perl starts counting position at zero, so absolute numeric patterns should be one less than in REXX to identify the same character position.
All Perl variables used must either be in the package that called parse, or they must be explicitly referenced with their package name (i.e., if parse is called from package Pack, $a implies $Pack::a -- if you want $a in package Sack, you must specify $Sack::a ). Lexical variables can not be used in the template. To assign values to lexical variables do somthing like this:
my ($b, $c, $d, $e) = parse $a, q! $x . $x ( $x ) $x !;
If youre concerned about the compiled templates taking up memory after youre done with them, you can add drop to the import list when you use String::RexxParse. Then pass the template to drop when youre done with it. Or just call String::RexxParse::drop($template). Or use the object oriented flavor discussed below.
Consult your favorite REXX manual for more details on templates.
$parse = String::RexxParse->new(EXPR);
$parse->parse(EXPR);
If you like, you can use String::RexxParse->new(EXPR) to create a String::RexxParse object. The EXPR passed to new is a template specification as described above. When you want to parse an EXPR, you just pass the string to the String::RexxParse object like so: $parse->parse(EXPR);
Enhancements:
- Fixed bug introduced in 1.07 and added j.t to test suite.

Math::String::Charset is a simple charset for Math::String objects.

SYNOPSIS

use Math::String::Charset;

$a = new Math::String::Charset; # default a-z
$b = new Math::String::Charset [a..z]; # same
$c = new Math::String::Charset
{ start => [a..z], sep => }; # with between chars

print $b->length(); # a-z => 26

# construct a charset from bigram table, and an initial set (containing
# valid start-characters)
# Note: After an a, either an b, c or a can follow, in this order
# After an d only an a can follow
$bi = new Math::String::Charset ( {
start => a..d,
bi => {
a => [ b, c, a ],
b => [ c, b ],
c => [ a, c ],
d => [ a, ],
q => [ ], # q will be automatically in end
}
end => [ a, b, ],
} );
print $bi->length(); # a,b => 2 (cross of end and start)
print scalar $bi->class(2); # count of combinations with 2 letters
# will be 3+2+2+1 => 8

$d = new Math::String::Charset ( { start => [a..z],
minlen => 2, maxlen => 4, } );

print $d->first(0),"n"; # undef, too short
print $d->first(1),"n"; # undef, to short
print $d->first(2),"n"; # aa

$d = new Math::String::Charset ( { start => [a..z] } );

print $d->first(0),"n"; #
print $d->first(1),"n"; # a
print $d->last(1),"n"; # z
print $d->first(2),"n"; # aa

This module lets you create an charset object, which is used to contruct Math::String objects. This object knows how to handle simple charsets as well as complex onex consisting of bi-grams (later tri and more).

In case of more complex charsets, a reference to a Math::String::Charset::Nested or Math::String::Charset::grouped will be returned.

The default charset is the set containing "abcdefghijklmnopqrstuvwxyz" (thus producing always lower case output).

Better String Library is an abstraction of a string data type which is superior to the C library char buffer string type and C++s std::string.

The library is totally stand alone, portable (known to work with gcc/g++, MSVC++, Intel C++, WATCOM C/C++, Turbo C, Borland C++, IBMs native CC compiler on Windows, Linux and Mac OS X), high performance, easy to use and is not part of some other collection of data structures. Even the file I/O functions are totally abstracted (so that other stream-like mechanisms, like sockets, can be used.)

Nevertheless, it is adequate as a complete replacement of the C string library for string manipulation in any C program.

The library includes a robust C++ wrapper that uses overloaded operators, rich constructors, exceptions, stream I/O and STL to make the CBString struct a natural and powerful string abstraction with more functionality and higher performance than std::string.

Bstrlib is stable, well tested and suitable for any software production environment.