Free true software for linux

ustr (Micro string library) is a string API for C. A few years ago now I wrote a very extensive String API for C, called Vstr, it was designed to perform extremely well for IO like patterns as that was my planned usage (for instance And-httpd, my Web server). It works very well, for that usage.
Also due to the extensivness of the API I basically used it everywhere, even though there are some things it is somewhat "overkill" for, and I wanted other people to use it so I didnt have to resort to using string.h when creating patches for their code. However more than a few C coders I speak to have one of a few reasons why they dont want to use Vstr. The ustr API should solve all of these problems, and hopefully fill in all the gaps where Vstr is the 500lb hammer.
A Significant example of usage, with comments:
Ustr *s1 = USTR(""); /* == "", always works */
Ustr *s2 = ustr_dup(s1); /* == "", always works */
Ustr *s3 = ustr_dup_cstr(""); /* == "", always works */
ustr_cmp_eq(s1, s2); /* == TRUE */
ustr_cmp_eq(s1, s3); /* == TRUE */
if (ustr_shared(s2)) /* This is TRUE, as a constant/read-only string cannot be freed */
/* whatever */ ;
if (ustr_ro(s2)) /* This is TRUE */
/* whatever */ ;
if (!ustr_add_fmt(&s2, "%s %d %c%d", "x", 4, 0, 8))
/* error */ ;
if (ustr_owner(s1)) /* This will return FALSE, as noone owns the "" read-only string */
/* whatever */ ;
if (ustr_owner(s2)) /* This will return TRUE, as weve now got allocated memory for s2 */
/* whatever */ ;
foo_API(ustr_cstr(s1), ustr_len(s1)); /* == "", 0 */
foo_API(ustr_cstr(s2), ustr_len(s2)); /* == "x 4 008", 6 */
s3 = ustr_dup(s2); /* dont need to free s3 as its empty */
/* dont need to check for errors as s2 == s3 */
if (ustr_owner(s2)) /* This will now return FALSE, weve got two references: s2 and s3 */
/* whatever */ ;
if (ustr_shared(s2)) /* This is FALSE, its a non-shared string referenced by both s2 and s3 */
/* whatever */ ;
ustr_free(s2); /* freed one reference to the data pointed to by both s2 and s3 */
ustr_set_share(s2); /* Make s2/s3 "shared" data,
so it always has infinite references */
if (ustr_shared(s2)) /* This is TRUE */
/* whatever */ ;
if (ustr_ro(s2)) /* This is FALSE */
/* whatever */ ;
s3 = ustr_dup(s2); /* This is the same as s3 = s2; */
ustr_free(s2); /* These do nothing */
ustr_free(s2);
ustr_free(s2);
ustr_free(s2);
if (!ustr_add_cstr(&s3, "abcd"))
/* error */ ;
ustr_add_cstr(&s3, "1234");
ustr_add_cstr(&s3, "xyz");
if (ustr_enomem(s3)) /* check for errors on the last 2 ustr_add_cstr() functions at once
ustr_owner(x) has to be true for this to be reliable,
hence the explicit first check */
/* error */ ;
ustr_set_owner(s2); /* Make s2 be "non-shared" and have a single owner */
ustr_set_owner(s1); /* This fails, as you cant make a read-only string be "non-shared" */
ustr_sc_del(&s2); /* freed s2 and set s2 = USTR("") */
ustr_cmp_eq(s1, s2); /* == TRUE */
s2 = USTR1(x0b, "Hello world"); /* Constant string with data */
if (ustr_shared(s2)) /* This is TRUE */
/* whatever */ ;
if (ustr_ro(s2)) /* This is TRUE */
/* whatever */ ;
/* dont need to "free" anything else */
Enhancements:
- A lot of new functions were added, such as insert, replace, split, substitute, and io_getdelim.
- Documentation improvements were made.
- Build fixes were made for Win32.

Brick::Composers Perl module defines composing functions in the Brick::Constraints package. Each function takes a list of code refs and returns a single code ref that wraps all of them. The single code ref returns true or false (but defined), as with other constraints.

If a composer cannot create the single code ref (for instance, due to bad input) it returns undef of the empty list, indicating a failure in programming rather than a failure of the data to validate.

__and( LIST OF CODEREFS )
__compose_satisfy_all( LIST OF CODEREFS )

This is AND with NO short-circuiting.

( A && B && C )

This function creates a new constraint that returns true if all of its constraints return true. All constraints are checked so there is no short-circuiting. This allows you to get back all of the errors at once.

__or( LIST OF CODEREFS )
__compose_satisfy_any( LIST OF CODEREFS )

This is OR but with NO short-circuiting.

( A || B || C )

This function creates a new constraint that returns true if all of its constraints return true. All constraints are checked so there is no short-circuiting.

__none( LIST OF CODEREFS )
__compose_satisfy_none( LIST OF CODEREFS )

( NOT A && NOT B && NOT C )

NOT ( A || B || C )

This function creates a new constraint that returns true if all of its constraints return false. All constraints are checked so there is no short-circuiting.

__compose_satisfy_N( SCALAR, LIST OF CODEREFS )

This function creates a new constraint that returns true if exactly N of its constraints return true. All constraints are checked so there is no short-circuiting.

__compose_satisfy_N_to_M( LIST OF CODEREFS )

This function creates a new constraint that returns true if between N and M (inclusive) of its constraints return true. All constraints are checked so there is no short-circuiting.

__not( CODEREF )
__compose_not( CODEREF )

This composers negates the sense of the code ref. If the code ref returns true, this composer makes it false, and vice versa.

__compose_until_pass
__compose_pass_or_skip

Go through the list of closures, trying each one until one suceeds. If a closure doesnt die, but doesnt return true, this doesnt fail but just moves on. Return true for the first one that passes, short-circuited the rest. If none of the closures pass, die with an error noting that nothing passed.

If one of the subs dies, this composer still dies.
This can still die for programming (not logic) errors.

__compose_until_fail
__compose_pass_or_stop

Keep going as long as the closures return true.

The closure that returns undef is a selector.

If a closure doesnt die and doesnt dont fail, just move on. Return true for the first one that passes, short-circuited the rest. If none of the closures pass, die with an error noting that nothing passed.

This can still die for programming (not logic) errors.

$result $@ what action
------------------------------------------------------------
1 undef passed go on to next brick

undef undef selector stop, return undef, no die
failed

undef string program stop, die with string
error

undef ref validator stop, die with ref
failed

JSON::PC is a fast JSON parser and converter.

SYNOPSIS

use JSON::PC;

my $json = new JSON::PC;

my $obj = $json->parse(q/{foo => [1,2,3], bar => "perl"}/);

print $json->convert($obj);

# or

$obj = JSON::PC::parse(q/{foo => [1,2,3], bar => "perl"}/);
print JSON::PC::convert($obj);

METHODS

Except new method, all methods are object method.

new()

new(%option)

This is a class method and returns new JSON::PC object.

parse($str)

parse($str, $options_ref)

takes JSON foramt string and returns perl data structure. jsonToObj is an alias.

convert($obj)

convert($obj, $options_ref)

takes perl data structure and returns JSON foramt string. objToJson is an alias.

autoconv($int)

This is an accessor to autoconv. See "AUTOCONVERT" for more info.

skipinvalid($int)

convert() does die() when it encounters any invalid data (for instance, coderefs). If skipinvalid is set with true(integer), the function convets these invalid data into JSON formats null.

execcoderef($int)

convert() does die() when it encounters any code reference. However, if execcoderef is set with true(integer), executes the coderef and uses returned value.

pretty($int)

This is an accessor to pretty. When prrety is true(integer), objToJson() returns prrety-printed string. See "PRETTY PRINTING" for more info.

indent($int)

This is an accessor to indent. See "PRETTY PRINTING" for more info.

delimiter($int)

This is an accessor to delimiter. See "PRETTY PRINTING" for more info.

unmapping($int)

This is an accessor to unmapping. See "UNMAPPING OPTION" for more info.

keysort($int)

keysort($code_ref)

This is an accessor to keysort. See "HASH KEY SORT ORDER" for more info.

convblessed($int)

This is an accessor to convblessed. See "BLESSED OBJECT" for more info.

selfconvert($int)

This is an accessor to selfconvert. See "BLESSED OBJECT" for more info.

singlequote($int)

This is an accessor to singlequote. See "CONVERT WITH SINGLE QUOTES" for more info.

barekey($int)

You can set a true(integer) to parse bare keys of objects.

quotapos($int)

You can set a true(integer) to parse any keys and values quoted by single quotations.

utf8($int)

This is an accessor to utf8. You can set a true(integer) to set UTF8 flag into strings contain utf8.

Graph::Flowchart is a Perl module that can generate easily flowcharts as Graph::Easy objects.

SYNOPSIS

use Graph::Flowchart;

my $flow = Graph::Flowchart->new();

print $flow->as_ascii();

This module lets you easily create flowcharts as Graph::Easy objects. This means you can output your flowchart as HTML, ASCII, Boxart (unicode drawing) or SVG.

Classes

The nodes constructed by the various add_* methods will set the subclass of the node according to the following list:

start

The start block.

end

The end block, created by finish().

block

Orindary code blocks, f.i. from $b = 9;.

if, for, while, until

Blocks for the various constructs for conditional and loop constructs.

sub

For sub routine declarations.

use

For use, no and require statements.

goto, break, return, next, last, continue

Blocks for the various constructs for jumps/returns.

true, false, goto, call, return, break, next, continue

Classes for edges of the true and false if-branches, and for goto, as well as sub routine calls.

Each class will get some default attributes, like if constructs having a diamond-shape.

You can override the graph appearance most easily by changing the (sub)-class attributes:

my $chart = Graph::Flowchart->new();

$chart->add_block($a = 9;);
$chart->add_if_then($a == 9;, $b = 1;);
$chart->finish();

my $graph = $chart->as_graph();

Now $graph is a Graph::Easy object and you can manipulate the class attributes like so:

$graph->set_attribute(node.if, fill, red);
$graph->set_attribute(edge.true, color, green);
print $graph->as_html_file();

This will color all conditional blocks red, and edges that represent the true branch green.