Free barrier software for linux

libGarbageCollector is an incremental garbage collector with a tri-color, Baker treadmill, write-barrier implementation.

libGarbageCollector is built from the garbage collector code used in the Io programming language project.

WAusers application is one component of the WAhelper Web accessibility testing suite.

WAusers serves for managing Web accessibility testing sites where users can register, create their own Web accessibility testing projects, and log into all their projects using a single global password.

Web pages are often designed without handicapped users in mind. Despite there exist Web accessibility guidelines such as W3C Accessibility Guidelines or U.S. Section 508 law, many Web designers are not aware about problems they cause to handicapped visitors of their pages. And even when a Web designer tries to make Web pages accessible, he may not be aware about all the obstacles handicapped users can meet.

- Software tools can be helpful here. Several Web accessibility checking tools already exist, but they have various problems:
Most of them are non-free and you cant use them freely to evaluate accessibility of your website effectively. Making things accessible means removing barriers and it is important to make the barriers as low as possible.
- New tests usually cant be added easily. An easily extensible and freely modifiable tool is needed so that its features can be improved efficiently. A good and maintained tool can make the whole process of making Web pages accessible more effective.
- The tools often dont try to go beyond semi-automated tests. But there are many accessibility problems which cant be detected, diagnosed and reported without human assistance. A tool helping humans with the testing process is needed.

AdaControl is a free (GMGPL) tool that detects the use of various kinds of constructs in Ada programs. AdaControls first goal is to control proper usage of style or programming rules, but it can also be used as a powerful tool to search for use (or non-use) of various forms of programming styles or design patterns. Searched elements range from very simple, like the occurrence of certaine entities, declarations, or statements, to very sophisticated, like verifying that certain programming patterns are being obeyed..
Which elements or constructs are searched is defined by a set of rules; the following table gives a short summary of rules currently checked by AdaControl. The number in parentheses after the rule name gives the number of subrules, if any. Considering all possible rules and subrules, this makes 216 tests that can be performed currently by AdaControl!
- Abnormal_Function_Return Controls a design pattern that ensures that a function always returns a result .
- Allocators Controls ocurrences of allocators, either all of them, or those targeting specified types.
- Array_Declarations (x2) Controls several metrics in array declarations.
- Barrier_Expressions Controls elements allowed in the expression of protected entries barriers
- Case_Statement (x4) Controls several metrics in case statements.
- Control_Characters Controls occurrences of control characters (like tabs) in the source.
- Declarations (x75) Controls occurrences of certain Ada declarations.
- Default_Parameter Controls subprogram calls and generic instantiations that use (or not) the default value for a given parameter.
- Directly_Accessed_Globals Controls a design pattern that ensures that all global variables are accessed only through dedicated subprograms.
- Entities Controls occurrences of any Ada entity.
- Entity_Inside_Exception Controls occurrences of entities inside exception handlers.
- Exception_Propagation (x4) Controls that certain subprograms (or tasks) cannot propagate exceptions, or that no elaboration can propagate exceptions.
- Expressions (x9) Controls usage of certain forms of expressions
- Global_References Controls unsynchronized accesses to global variables.
- Header_Comments (x2) Controls the presence of comments at the start of each module.
- If_For_Case Controls if statements that could be replaced by case statements.
- Instantiations Controls generic instantiations, either all of them, or those that use specified entities.
- Insufficient_Parameters Controls the use of positional parameters in calls where the value does not provide sufficient information.
- Local_Hiding Controls occurrences of local identifiers that hide an identical outer one.
- Local_Instantiation Controls instantiations in local scopes.
- Max_Blank_Lines Controls the occurrence of more than a specified number of consecutive empty lines.
- Max_Call_Depth Controls the maximum depth of subprogram calls.
- Max_Line_Length Controls maximal length of source lines.
- Max_Nesting Controls scopes nested more deeply than a given limit.
- Max_Parameters (x6) Controls the maximum numbers of parameters in callable entities (procedures, functions and entries)
- Max_Statement_Nesting (x5) Controls composite statements nested more deeply than a given limit.
- Movable_Accept_Statements Controls statements that could be moved outside an accept statement.
- Naming_Convention Controls the form of allowed (or forbidden) names in declarations.
- No_Safe_Initialization Controls a design pattern that ensures that any variable is initialized before being used.
- Non_Static (x3) Controls non static expressions in index or discriminant constraints, or in instantiations.
- Not_Elaboration_Calls Controls subprogram calls performed from places outside package elaboration code.
- Other_Dependencies Controls semantic dependencies to other units than those indicated
- Parameter_Aliasing Controls subprograms and entry calls where a variable is provided to more than one [in] out parameter.
- Potentially_Blocking_Operations Controls the use of potentially blocking operations from within protected operations.
- Pragmas Controls the use of specific pragmas.
- Real_Operators Controls occurrences of = or /= operators on real types.
- Reduceable_Scope Controls declarations that could be move to more deeply nested scopes.
- Representation_Clauses Controls occurrences of representation clauses.
- Return_Type Controls the use of certain kinds of types as return types of functions.
- Side_Effect_Parameters Controls subprogram calls and generic instantiations that call functions with side effect, thus creating a dependance to the order of evaluation.
- Silent_Exceptions Controls exception handlers that do not reraise exceptions nor call indicated subprograms.
- Simplifiable_Expressions (x4) Controls occurrences of various forms of expressions that could be simplified.
- Special_Comments Controls the presence of certain string patterns in comments.
- Statements (x42) Controls occurrences of Ada statements.
- Style (x12) Controls various forms of constructs generally recommended in style rules.
- Terminating_Tasks Controls a design pattern that ensures that tasks never terminate.
- Uncheckable (x3) Controls constructs that are not statically checkable by other rules
- Unnecessary_Use_Clause Controls use clauses on packages, where no element of the package is referred to within the scope of the use clause.
- Unsafe_Paired_Calls Controls a design pattern that ensures that certain calls are allways paired (like P/V procedures).
- Unsafe_Unchecked_Conversion Controls instantiations of Unchecked_Conversion between types of different or unspecified sizes.
- Usage (x5) Controls usage of objects under certain conditions (in package specifications, read, written modified...).
- Use_Clauses Controls occurrences of use clauses, except for indicated packages.
- With_Clauses (x3) Controls proper usage of with clauses.
Enhancements:
- This release adds rules to check that header comments match a given pattern.
- It has indication of possible false positives and false negatives due to non-statically analyzable constructs.
- There is a fine definition of constructs allowed in entry barriers (including the one of the Ravenscar profile).
- There is better integration into GPS, and much more.

Wipe is a file and block device wiping utility. It is based on work by Peter Gutmann.
There are some low level issues that must be taken into consideration. One of these is that there must be some sort of write barrier between passes. Wipe uses fdatasync(2)
(or fsync(2)) as a write barrier, or if fsync(2) isnt available, the file is opened with the O_DSYNC or O_SYNC flag.
For wipe to be effective, each pass must be completely written. To ensure this, the drive must support some form of a write barrier, write cache flush, or write cache disabling. SCSI supports ordered command tags, has a force
media access bit for commands, and write cache can be disable on mode page 8. IDE/ATA drives support write cache flushes and write cache disabling.
Unfortunetly, not all drives actually disable write cache when yjhis is set up.Those drives are broken. Write caching should always be disabled, unless your system is battery backed and always powers down cleanly.
Enhancements:
- typo in Makefile.in (Ricardo Branco)

Net::Chat::Jabber is a Jabber protocol adapter for Net::Chat::Daemon.

API

new()

class - the name of the class were creating
jid - a string giving the JID, or a JID object
%options
password - the password to provide during authentication. TODO: if
this is not provided but a password is needed, some sort of
authCallback is needed.
loglevel - logs with level higher than this are not displayed.
Defaults to 0.
connect()

Connect to the server, attempting to register if the specified user is not yet registered.
reconnect()

Reestablish a broken connection.
subscribe($jid)

Subscribe to messages coming from $jid.
post($to,$message,options...)

Send the message text $message to $to. Available options:
subject: set the subject of the message (rarely used)
thread: mark the message as a reply in the given thread
attachments: an array of attachments, where each attachment
is either a chunk of text, or an XML tree.
send_request(to,message,options...)

Send out a request, but do not wait for the reply.
request(to,message,options...)

Make a synchronous request. Returns the body of the reply message.
start_transaction($transaction_id, $onReply)

Start a transaction. A transaction is identified by the given id, and... blah blah blah this is very important but I dont remember what I did here.
end_transaction($transaction_id)

Normally called automatically. Terminates a transaction and erases the transaction callback.
count_transactions($transaction_id)

Return the number of active karfloomer hangers for the given transaction. The method name is awful; this is counting karfloomer hangers for a given transaction, not the number of transactions. FIXME when I figure this all out.
barrier()

Wait until no more active transactions are outstanding.
poll()

Check whether any messages are available.
wait([$timeout])

Wait $timeout seconds for more messages to come in. If $timeout is not given or undefined, block until a message is received.
Return value: 1 = data received, 0 = ok but no data received, undef = error

RTEMS (Real-Time Executive for Multiprocessor Systems) is a commercial grade real-time operating system designed for deeply embedded systems. The project is a free (as in beer and speech) open-source solution that supports multi-processor systems.
RTEMS is designed to support applications with the most stringent real-time requirements while being compatable with open standards such as POSIX. Its been ported to over ten processor architectures including ARM, PowerPC, i386, M68K, Coldfire, MIPS, SPARC, SH, H8, and C3x/C4x DSPs.
Using the GNU tools for cross development, you can use any number of systems as development hosts including both Unix and Windows platforms.
Main features:
- realtime system design
- semantics of BSP building and maintenance
- driver development for clock, timer and RTC drivers
- console drivers for raw and termios mode
- network drivers
- BSP structure
- handling of target depenencies
- Classic API
- POSIX API
Enhancements:
- This is the first snapshot from the CVS head since the 4.7 release branch was made.
- It adds POSIX barriers, spinlocks, rwlocks, and Classic API Barriers.
- It adds a new port to the Altera NIOS II.
- There is also the usual assortment of cleanup and name changes to increase adherance to coding conventions.

Common Lisp Kanji Drill, or CLKD in short, is a newly-released program for learning the meanings of Chinese/Japanese characters (kanji) by means of repeated tests. The project is developed using CLISP, and runs on GNU/Linux and on MS Windows under Cygwin. CLKD uses a web browser as its interface. (These work best: Firefox 1.0.4 or newer; or Internet Explorer 7 or newer),. Japanese fonts are required.

CLKD is not intended for complete beginners in Japanese or Chinese to just start learning characters by rote. Its best to learn something about the structure of these characters by reading a few good books about them. It helps to know how to write them, how to count strokes, and how to look up characters in dictionaries which classify them by radical and components.

But all these resources still leave a big task: the raw memorization of hundreds and hundreds of characters. That is where a tool like CLKD becomes valuable.

CLKD is ideally suited to someone who has already broken through the unfamiliarity barrier: the student who can already recognize familiar components in an unfamiliar character and mentally form a mnemonic to which he or she can anchor the meanings of that character, and who is ready to begin internalizing a large number of characters.

Games::Lineofsight is a Perl module.

Many games (Ultima, Nethack) use two-dimensional maps that consists of the squares of the same size in a grid. Line-of-sight means that some of the squares may represent the items that block the vision of the player from seeing squares behind them. With this module you can add that behaviour to your games.

SYNOPSIS

use Games::Lineofsight qw(lineofsight);

# The map has to be a two-dimensional array. Each member (or "cell") of the array represents one
# square in the map. In this example each cell contains only one character but you can put strings
# to the cells also - practical with the graphical games.

my @map=(
[split //,"..:..::........."], # this is the map
[split //,".......:..X....:"], # . and : represents the ground
[split //,"...X.....:...:.."], # X is the barrier for the sight
[split //,".:...:....:....."],
[split //,"..X....:..X....."],
[split //,"..X..:........:."],
);

my($width)=scalar(@{@map[0]}); # the width of the map
my($height)=scalar(@map); # the height of the map
my($barrier_str)="X"; # string that represents the barrier
my($hidden_str)="*"; # string that represents a cell behind a barrier
my($man_str)="@"; # string that represents the viewer
my($man_x,$man_y)=(7,3); # view point coordinates - the player is here

# recreate the map with line-of-sight

@map=lineofsight(@map,$man_x,$man_y,$barrier_str,$hidden_str);

# draw the map

for(my $i=0;$i < $height;$i++){
for(my $j=0;$j < $width;$j++){
print $man_x == $j && $man_y == $i ? $man_str : $map[$i][$j];
}
print "n";
}
or
# The lineofsight() calls get_barriers() and analyze_map() each time its called. If the viewer
# moves around the map a lot, its much faster to read in the barriers once and call only
# analyze_map() each time before drawing it.

use Games::Lineofsight qw(get_barriers analyze_map);

# The map has to be a two-dimensional array. Each member (or "cell") of the array represents one
# square in the map. In this example each cell contains only one character but you can put strings
# to the cells also - practical with the graphical games.

my @map=(
[split //,"..:..::........."], # this is the map
[split //,".......:..X....:"], # . and : represents the ground
[split //,"...X.....:...:.."], # X is the barrier for the sight
[split //,".:...:....:....."],
[split //,"..X....:..X....."],
[split //,"..X..:........:."],
);

my($width)=scalar(@{@map[0]}); # the width of the map
my($height)=scalar(@map); # the height of the map
my($barrier_str)="X"; # string that represents the barrier
my($hidden_str)="*"; # string that represents a cell behind a barrier
my($man_str)="@"; # string that represents the viewer
my($man_x,$man_y)=(7,3); # view point coordinates - the player is here

# get_barriers() returns a hash with the information about barriers in the map. In this example we
# declare the "X"-character as a barrier. As well you can declare it to be a string in the graphical
# games; for example "barrier.jpg".

my %barrier=get_barriers($width,$height,@map,$barrier_str);

# analyze_map() returns an array containing the original map looked from the view point. The cells
# behind the barriers are replaced with given strings. The barriers should be told to the subroutine
# calling first get_barriers()-subroutine as we already did.

my @map2=analyze_map($width,$height,@map,%barrier,$man_x,$man_y,$hidden_str);

#draw the map with the lineofsight

print "nOriginal map:n";

draw($width,$height,$man_x,$man_y,@map2,$man_str);

# move the viewer two squares right

$man_x+=2;

# refresh the map

my @map2=analyze_map($width,$height,@map,%barrier,$man_x,$man_y,$hidden_str);

#draw the map again

print "nViewer has moved:n";

draw($width,$height,$man_x,$man_y,@map2,$man_str);

sub draw{
my($width,$height,$man_x,$man_y,$map,$man_str)=@_;
for(my $i=0;$i < $height;$i++){
for(my $j=0;$j < $width;$j++){
print $man_x == $j && $man_y == $i ? $man_str : $$map[$i][$j];
}
print "n";
}

}