Free code blocks software for linux

MIM Blocks is a set of blocks games (sokoban, taquin and various others) in 3D.

Mim-Blocks is reflexion game, where the goal is to merge different blocks of the same color, by moving them inside a maze. Its still at an early stage of developement, but looks promising!

Gnome Memory Blocks project is a concentration game for GNOME.

This is GNOMEs version of the `memory blocks game originaly come from Semantec game pack for Win-3.11

X11Blocks package is an Objective-C Block oriented X Window System Toolkit.

X11Blocks is a layer above "Xlib" (version 11) and provides functionality that is similar to the "Xt" (X Intrinsics) and Xaw widget libraries.

Whereas much of the X Intrinsics is dedicated to implementing a classing system in C, X11Blocks uses Objective-C (an extension of C) for this purpose.

X11Blocks makes extensive use of Objective-C "Blocks", where Blocks play a role similar to callbacks in the Intrinsics.

Objective-C Blocks, also known as Block closures or Action Expressions, are pieces of code represented by instances of an Objective-C class (called Block) for delayed evaluation.

For example, the action in a "MenuItem" object is a Block.

Blocks are useful for "event-based" programming and offer a significant advantage over "callbacks" in that Blocks can refer to and alter the context in which a Block was created.

Bio::NEXUS::Block is a Perl module that provides useful functions for blocks in NEXUS file (parent class).

SYNOPSIS

This module is the super class of all NEXUS block classes. It is not used specifically from a program; in other words, you dont create a new Bio::NEXUS::Block object. Other modules, like AssumptionsBlock, simply inherit subroutines from this module.

Provides a few useful functions for general blocks (to be used by sub-classes).

METHODS

clone

Title : clone
Usage : my $newblock = $block->clone();
Function: clone a block object (shallow)
Returns : Block object
Args : none

get_type

Title : get_type
Usage : print $block->get_type();
Function: Returns a string containing the block type
Returns : type (string)
Args : none

set_ntax

Title : set_ntax
Usage : print $block->set_ntax();
Function: Sets the value of Dimensions:ntax
Returns : none
Args : number of taxa (scalar)

set_dimensions

Title : set_dimensions
Usage : $block->set_dimensions($dimensions);
Function: set a dimensions command
Returns : none
Args : hash content of dimensions command

get_dimensions

Title : get_dimensions
Usage : $block->get_dimensions($attribute);
Function: get a dimensions command
Returns : hash content of dimensions command, or the value for a particular attribute if specified
Args : none, or a string

set_command

Title : set_command
Usage : $block->set_command($command, $content);
Function: Set a command
Returns : none
Args : comand name, and content (string)

set_title

Title : set_title
Usage : $block->set_title($name);
Function: Set the block name
Returns : none
Args : block name (string)

get_title

Title : get_title
Usage : $block->get_title();
Function: Returns a string containing the block title
Returns : name (string)
Args : none

set_link

Title : set_link
Usage : $block->set_link($link_hashref);
Function: Set the block link commands
Returns : none
Args : block link (hash)

add_link

Title : add_link
Usage : $block->add_link($linkname, $title);
Function: add a link command
Returns : none
Args : $link, $title (of another block)

get_link

Title : get_link
Usage : $block->get_link();
Function: Returns a hash containing the block links
Returns : link (hash)
Args : none

set_taxlabels

Title : set_taxlabels
Usage : $block->set_taxlabels($labels);
Function: Set the taxa names
Returns : none
Args : array of taxa names

add_taxlabel

Title : add_taxlabel
Usage : $block->add_taxlabel($label);
Function: add a taxon name
Returns : none
Args : a taxon name

get_taxlabels

Title : get_taxlabels
Usage : $block->get_taxlabels();
Function: Returns an array of taxa labels
Returns : taxa names
Args : none

set_otus

Title : set_otus
Usage : $block->set_otus($otus);
Function: sets the list of OTUs
Returns : none
Args : array of OTUs

get_otus

Title : get_otus
Usage : $block->get_otus();
Function: Returns array of otus
Returns : all otus
Args : none

set_otuset

Title : set_otuset
Usage : $block->set_otuset($otuset);
Function: Set the otus
Returns : none
Args : TaxUnitSet object

get_otuset

Title : get_otuset
Usage : $block->get_otuset();
Function: get the OTUs
Returns : TaxUnitSet object
Args : none

select_otus

Title : select_otus
Usage : $block->select_otus($names);
Function: select a subset of OTUs
Returns : array of OTUs
Args : OTU names

rename_otus

Title : rename_otus
Usage : $block->rename_otus($names);
Function: rename all OTUs
Returns : none
Args : hash of OTU names

set_comments

Title : set_comments
Usage : $block->set_comments($comments);
Function: Set the block comments
Returns : none
Args : block comments (array of strings)

get_comments

Title : get_comments
Usage : $block->get_comments();
Function: Returns block comments
Returns : comments (array of strings)
Args : none

add_comment

Title : add_comment
Usage : $block->add_comment($comment);
Function: add a comment
Returns : none
Args : comment (string)

equals

Name : equals
Usage : $block->equals($another);
Function: compare if two Block objects are equal
Returns : boolean
Args : a Block object

Pretty Code Web is a syntax highlighter for publishing code, written in any programming language, to the web.
Written in php it uses syntax files separate from the main code to highlight a specified language.
Main features:
- Syntax highlighting for (potentially) any language.
- User defined syntax files.
- User defined colors
- Separate colors for:
- 6 Keyword Groups
- Text Strings
- Operators
- Block and Line Comments
- Bracket Characters

HTML Code Convert helps speed up the conversion of HTML code into different format including Java Script, JavaServer Pages, Microsoft ASP, PHP, Perl, Python, and the UNIX Shell. It is particularly useful in CGI scripting.
Enhancements:
- Colors and font selected in prefeferences box.
- Fixe bug with Quit button. First try to support accessibility.
- Updated schemas.

Code::Splice injects the contents of one subroutine at a specified point elsewhere.

SYNOPSIS

use Code::Splice;

Code::Splice::inject(
code => sub { print "fredn"; },
package => main,
method => foo,
precondition => sub {
my $op = shift;
my $line = shift;
$line =~ m/print/ and $line =~ m/four/;
},
postcondition => sub {
my $op = shift;
my $line = shift;
$line =~ m/print/ and $line =~ m/five/;
},
);

sub foo {
print "onen";
print "twon";
print "threen";
print "fourn";
print "fiven";
}

This module removes the contents of a subroutine (usually an anonymous subroutine created just for the purpose) and splices in into the program elsewhere.

Why, you ask?

Write stronger unit tests than the granularity of the API would otherwise allow

Write unit tests for nasty, interdependant speghetti code (my motivation -- hey, you gotta have tests before you can start refactoring, and if you cant write tests for the code, youre screwed)

Fix stupid bugs and remove stupid restrictions in other peoples code in a way thats more resiliant across upgrades than editing files you dont own

Be what "aspects" should be

Screw with your cow-orkers by introducing monster heisenbugs

Play with self-modifying code

Write self-replicating code (but be nice, were all friends here, right?)

The specifics:

The body of the code { } block are extracted from the subroutine and inserted in a place in the code specified by the call to the splice() function. Where the new code is spliced in, the old code is spliced out. The package and method arguments are required and tell the thing how to find the code to be modified. The code argument is required as it specifies the code to be spliced in. That same code block should not be used for anything else under penalty of coredump.

The rest of the argumets specify where the code is to be inserted. Any number of precondition and postcondition arguments provide callbacks to help locate the exact area to splice the code in at. Before the code can e spliced in, all of the precondition blocks must have returned true, and none of the postcondition blocks may have yet returned true. If a postcondition returns true before all of the precondition blocks have, an error is raised. Both blocks get called numerous times per line and get passed a reference to the B OP object currently under consideration and the text of the current line:

precondition => sub {
my $op = shift;
my $line = shift;
$line =~ m/print/ and $line =~ m/four/;
},
... or...
precondition => sub { my $op = shift; $op->name eq padsv and $op->sv->sv =~ m/fred/; },

Its possible to insert code in the middle of an expression when testing ops, but when testing the text of the line of code, the spliced in code will always replace the whole line.
Ill probably drop sending in the opcode in a future version, at least for the precondition/postcondition blocks, or maybe Ill swap them to the 2nd arg so theyre more optional.

Do not attempt to match text in comments as it wont be there. The code in $line is re-generated from the bytecode using B::Deparse and will vary from the original source code in a few ways, including changes to formatting, changes to some idioms and details of the expressions, and formatting of the code with regards to whitespace.

The splicing code will die if it fails for any reason. This will likely change in possible future versions.
There are also label and line arguments that create preconditions for you, for simple cases. Of course, you shouldnt use line for anything other than simple experimentation.

References to lexical variables in the code to be injected are replaced with references to the lexical variables of the same name in the location the code is inserted into. If a variable of the same name doesnt exist there, its an error. ... but it probably shouldnt be an error, at least in the cases where the code being spliced in declares that lexical with my, or when the variable was initiailized entirely outside of the sub block being spliced in and was merely closed over by it.

See the comments in the source code (at the top, in a nice block) for my todo/desired features. Let me know if there are any features in there or yet unsuggested that you want. I wont promise them, but I would like to hear about them.