b

Skinnable tetris game

<b>Requirements:b>

· Smartphone 2002

B::OptreeShortestPath is a Perl module that adds the methods ->shortest_path( $op ) and ->all_paths() to all B::OP objects in an optree.

<b>SYNOPSISb>

use B qw( main_root main_start );
use B::OptreeShortestPath;

for ( main_start()->shortest_path( main_root() ) ) {
print "$_n";
}

<b>METHODSb>

$op->shortest_path( $other_op )

Returns a list of the shortest paths from $op to $other_op. Each path is a string approximating a bunch of chained method calls.

"->next->sibling->next",
"->sibling->sibling->next"
$op->all_paths()

Returns a list of paths from this node to all other nodes.

B Plugin description
Maxthon add-on that will add to your browser a BB Code Panel with lots of features B-Plugin is a plugin that will add a BB Code panel to your browser.

<b>Here are some key features of "B Plugin":b>

· BB Code buttons
· custom codes (tags) list
· snippets list (hi, Zoni)
· edit all lists on-the-fly (add, delete items)
· undo/redo function
· recover last textarea value function
· quick jump to upload site
· quick jump to your smilies
· smilies list options (add, delete)
· textarea style support
· windows position and size options


<b>Requirements:b>

· Maxthon

b. is a Web-based manager for Web bookmarks. Bookmarks are stored in an XML file. Operations on the data are done with Perl scripts.

<b>Here are some key features of "b":b>

<b>Collaborative bookmarksb>

· A new and powerful feature is the ability to share bookmarks. These shared bookmarks may be publicly viewed by all, while a certain set of users have the ability to add or change them. These users can also add comments to the shared bookmarks, as in a bulletin-board. The display of the shared bookmarks is highly configurable: one can show extra information associated with a bookmark, such as its popularity, when it was last visited, when it was added, etc. With these new features, b. becomes a collaborative space for sharing discoveries of the Web.

· Old-style b. functionality is not lost however: one can still maintain a set of private bookmarks just as before. Whats new is the option to exchange bookmarks between the private and shared sets.

<b>Accessible from any Web browserb>

· The main advantage for storing your bookmarks on the Web is to have them accessible from any Web browser. b. produces XHTML 1.0 code, doesnt use any Javascript, and is best viewed with a CSS1-compliant browser such as Netscape 6+/Mozilla, Internet Explorer 5+, and Opera 5+.

<b>Bookmark data stored in XML formatb>

· XML has quickly become an acknowledged standard for the management of data transmitted over the Internet. Its foundation as a markup language like HTML gives it a wide base of users, and its precept of separating data from its display provides XML versatility for the many possible uses of the data.

· Im using a DTD for collaborative bookmarks called XBEL-collab. Its a slight modification of the XBEL DTD for bookmarks >>, to allow for features like comments and hit counts. The original XBEL DTD was created by python.org.

<b>Customizableb>

· In a themes/ subdirectory, one can determine the look of b. with CSS stylesheets, custom graphics, and HTML templates. There are more customization options with this new release.

<b>Multi-userb>

· b. supports multi-user environments. Using basic Web server user authentication (i.e. by password-protecting the b./ directory), only certain users can have access to b.. Each user has his/her own bookmarks and optionally can have his/her own theme, welcome message, etc.



<b>Limitations:b>

<b>Must close browser to log offb>

· This is a limitation of basic HTTP user authentication: once you have access to a directory, you always have access until your browser session has ended.

<b>Modify bookmarks from one machine at a timeb>

· Problems can result if one attempts to modify bookmarks from two different machines at the same time. (Viewing and accessing the data from more than one machine is fine.) Although a backup of the XML file is written every time it is modified, something more secure could be implemented.

MySysop is a PHP tool with AJAX support for managing MySQL server settings and monitoring process, variables, and status.

<b>Whats Newb> in This Release:

· This version has a prototype window for the dialog window, new stats, and minor bugfixes.

B::XPath class can search Perl optrees with XPath syntax.

<b>SYNOPSISb>

Perl represents programs internally as a tree of opcodes. To execute a program, it walks this tree, performing each operation as it encounters it. The B family of modules allows you to examine (and in some cases, manipulate) this optree on programs even as they run.

B::XPath allows you to use XPath syntax to select ops in the optree.

use B::XPath;

my $node = B::XPath->fetch_root( &some_function );
my $root = B::XPath->fetch_main_root();

# find all global scalar accesses
my @globals = $root->match( //gvsv );

# find all global scalar accesses within some_function() named $bob
my @bobs = $node->match( //gvsv[@NAME="bob"] );

<b>Class Methodsb>

There are two methods to use to start your match; both set the root of the tree to search. Theres also a nice helper method youll probably never use unless you find a bug.

fetch_root( $subref )

This method returns the B::XPath::Node object at the root of the optree for the subroutine reference. All matches performed on this node will search this branch of the optree for matching nodes.

fetch_main_root()

This method returns the B::XPath::Node object at the root of the program. Use this to search your entire program (at least, the part of it outside of any given subroutine).

find_op_class( $op )

Given a B::OP or descendent object, returns the name of the appropriate B::XPath::Node subclass to use to wrap that op so that B::XPath can manipulate it appropriately.

B::TerseSize is a Perl module that prints information about ops and their (estimated) size.

<b>SYNOPSISb>

perl -MO=TerseSize[,OPTIONS] foo.pl

The B::Size and B::TerseSize modules attempt to measure the size of Perl op codes. The output of B::TerseSize is similar to that of B::Terse, but includes the size of each OP in the tree and the PADLIST (subroutine lexical variables). The module can be run just as other compiler backends or used via Apache::Status (version 2.02 and higher).

If the Apache::Status StatusTerseSize option is enabled, there will be a main menu item added, "Memory Usage". Clicking on this link will cause B::TerseSize to produce a summary of package memory usage. This summary can take quite a while to produce, as each package subroutine syntax tree will be walked, adding up the information. This information will be cached, so running httpd in -X (non-forking mode) is a good choice.

When browsing the Apache::Status "Symbol Table Dump", a "Memory Usage" link will be at the bottom of each page. These summaries also include measurements of package global variables.

The Apache::Status symbol table browser will also provide an option to dump a subroutine tree along with the other subroutine options.

ScaleDir is a Kommander Script for a fast and simple Batch Resize of all Pictures in a folder(under use of ImageMagick).

It asks for the following Parameter:

"Path"
"Suffix" of pictures (Type)"
"Präfix" for new pictures
"Horizontal Pixel (Scale)"

<b>Hints:b>

Inputs are case-sensitive, "JPG" isnt the same as "jpg".
Use only the 3 Letters of Types (no "*" or "*." !!!).

Its useful to set preafixes like "small_" or "x_", dont use "/" or "!".

Horizontal Size gives the scale-faktor: If your source-Picture has the Size 1024x768 and you enter a "800" in Pixel you get Pictures in size 800x600 (3/4).

<b>Example:b>

Suffix: jpg
Praefix: scaled_
Scale: 800

results: picture01.jpg (1024x768) -> scaled_picture01.jpg (800x600)

Virgil projetc is an new, object-oriented, light-weight programming language that is designed for building software for resource-constrained embedded systems at the lowest level. Microcontroller programmers can now develop complete software systems, including hardware drivers and OS services, in one language, without the need to resort to unsafe libraries or native code.

Virgil also provides a whole-program compiler system that applies novel global optimization techniques to produce efficient machine code that runs directly on the hardware, without the need of a virtual machine or a language runtime system.

<b>Why are microcontrollers important?b>

Embedded computers are everywhere. While the desktop computer revolution has brought computing to millions of users worldwide, the embedded system revolution has been quietly automating the world we live in--everything from the cars we drive to the roadways we drive them on; from factory production to the goods we use every day. In 2005, nearly 6 billion microcontroller units were manufactured. Today, microcontrollers outnumber people on this planet by more than 5 to 1. Soon, most electronic devices will have a software-programmable embedded computer with capabilities ranging from simple arithmetic to wireless communication, and microcontrollers offer a compelling solution for many of these products.

<b>How is software for embedded systems different?b>

Software in this environment has very different requirements than traditional desktop and server computers. First, embedded programs must control devices that sense and interact with the physical world, in contrast to desktop and server software that is driven by databases, websites, and input from users. Second, embedded systems often operate in safety critical real-time scenarios, where software is tasked with controlling physical processes and actuators that can pose physical danger to people, infrastructure, and the environment. Third, the cost of software update for billions of devices makes it largely infeasible, vastly increasing the importance of software verification.

<b>How can new language technology help?b>

Advances in programming languages over the past 30 years have yielded demonstrable productivity gains, including better static checking, more expressiveness, and better portability and maintability. Yet these advances have not been put into practical use in developing embedded systems software. The continued use of unsafe, low-level languages that frustrate automated program reasoning and verification poses a significant stumbling block to progress. While no magic bullet exists for software development, we believe that applying modern technology to this problem will produce real, tangible gains in both software quality and efficiency.

<b>Here are some key features of "Virgil":b>

<b>Object-oriented Featuresb>
· Classes and single-inheritance
· Virtual methods
· Constructors
· Orphan classes
· Always pass by reference

<b>Procedural Featuresb>
· Components
· Loops
· Switches
· Statements

<b>Functional Featuresb>
· Delegates
· Aggressive inlining *
· Tail call optimization *

<b>Otherb>
· Arrays
· Bit-level types
· Compile-time Application Initialization
· Hardware register access
· Interrupt handlers
· Well-defined language semantics
· Heap optimization
· Exceptions *

* = the implementation of this feature is not yet complete in prototype compiler

B::Deobfuscate Perl module contains the deobfuscate source code.

<b>SYNOPSISb>

perl -MO=Deobfuscate,-csynthetic.yml,-y synthetic.pl

B::Deobfuscate is a backend module for the Perl compiler that generates perl source code, based on the internal compiled structure that perl itself creates after parsing a program. It adds symbol renaming functions to the B::Deparse module. An obfuscated program is already parsed and interpreted correctly by the B::Deparse program. Unfortunately, if the obfuscation involved variable renaming then the resulting program also has obfuscated symbols.

This module takes the last step and fixes names like $z5223ed336 to be a word from a dictionary. While the name still isnt meaningful it is at least easier to distinguish and read. Here are two examples - one from B::Deparse and one from B::Deobfuscate.

Initial input

if(@z6a703c020a){(my($z5a5fa8125d,$zcc158ad3e0)=File::Temp::tempfile(
UNLINK,1));print($z5a5fa8125d "=over 8nn");(print($z5a5fa8125d
@z6a703c020a)or die(((("Cant print $zcc158ad3e0: $!"))); print($z5a5fa8125d
"=backn");(close(*$z5a5fa8125d)or die(((("Cant close ".*$za5fa8125d.": $!")
));(@z8374cc586e=$zcc158ad3e0);($z9e5935eea4=1);}

After B::Deparse:

if (@z6a703c020a) {
(my($z5a5fa8125d, $zcc158ad3e0) = File::Temp::tempfile(UNLINK, 1));
print($z5a5fa8125d "=over 8nn");
(print($z5a5fa8125d @z6a703c020a)
or die((((q[Cant print ] . $zcc158ad3e0) . : ) . $!)));
print($z5a5fa8125d "=backn");
(close(*$z5a5fa8125d)
or die((((q[Cant close ] . *$za5fa8125d) . : . $!)));
(@z8374cc586e = $zcc158ad3e0);
($z9e5935eea4 = 1);
}

After B::Deobfuscate:

if (@parenthesises) {
(my($scrupulousity, $postprocesser) = File::Temp::tempfile(UNLINK, 1));
print($scrupulousity "=over 8nn");
(print($scrupulousity @parenthesises)
or die((((q[Cant print ] . $postprocesser) . : ) . $!)));
print($scrupulousity "=backn");
(close(*$scrupulousity)
or die((((q[Cant close ] . *$postprocesser) . : ) . $!)));
(@interruptable = $postprocesser);
($propagandaist = 1);
}

Youll note that the only real difference is that instead of variable names like $z9e5935eea4 you get $propagandist.

B::LexInfo is a Perl module that shows information about subroutine lexical variables.

<b>SYNOPSISb>

use B::ShowLex ();
my $lexi = B::ShowLex->new;

Perl stores lexical variable names and values inside a padlist within the subroutine. Certain lexicals will maintain certain attributes after the the variable "goes out of scope". For example, when a scalar is assigned a string value, this value remains after the variable has gone out of scope, but is overridden the next time it is assigned to. Lexical Arrays and Hashes will retain their storage space for the maximum number of entries stored at any given point in time.

This module provides methods to record this information, which can be dumped out as-is or to compare two "snapshots". The information learned from these snapshots can be valuable in a number of ways.

<b>METHODSMb>

new

Create a new B::LexInfo object:

my $lexi = B::LexInfo->new;

cvlexinfo

Create a padlist snapshot from a single subroutine:

my $info = $lexi->cvlexinfo(Foo::bar);

stash_cvlexinfo

Create a list of padlist snapshots for each subroutine in the given package:

my $info = $lexi->stash_cvlexinfo(Foo);

dumper

Return a reference to a stringified padlist snapshot:

print ${ $lexi->dumper($info) }

diff

Compare two padlist snapshots and return the difference:

my $before = $lexi->stash_cvlexinfo(__PACKAGE__);
... let some code run
my $after = $lexi->stash_cvlexinfo(__PACKAGE__);

my $diff = B::LexInfo->diff($before, $after);
print $$diff;

NOTE: This function relies on the diff -u command. You might need to configure $B::LexInfo::TmpDir and/or $B::LexInfo::DiffCmd to values other than the defaults in LexInfo.pm.

cvrundiff

Take a padlist snapshot of a subroutine, run the subroutine with the given arguments, take another snapshot and return a diff of the snapshots.

my $diff = $lexi->cvrundiff(Foo::bar, "arg1", $arg2);
print $$diff;

Complete example:

package Foo;
use B::LexInfo ();

sub bar {
my($string) = @_;
}

my $lexi = B::LexInfo->new;
my $diff = $lexi->cvrundiff(Foo::bar, "a string");
print $$diff;

Produces:

--- /tmp/B_LexInfo_1848.before Mon Jun 28 19:48:41 1999
+++ /tmp/B_LexInfo_1848.after Mon Jun 28 19:48:41 1999
@@ -2,8 +2,10 @@
{
Foo::bar => {
$string => {
- TYPE => NULL,
- NULL => 0x80efd58
+ TYPE => PV,
+ LEN => 9,
+ PV => a string,
+ CUR => 8
},
__SPECIAL__1 => {
TYPE => NULL,

SmartEuro is a visual database of the new European coins.

It cointains useful information about physical characteristics, design and quantities of produced coins.

You can also use SmartEuro to track your Euro collection using the checkbox in the top right corner to mark coins you already own.

SmartEuro is FREEWARE.

<b>Requirements:b>

· Palm IIIc
· Palm OS Color

B::Utils is a helper functions for op tree manipulation.

<b>SYNOPSISb>

use B::Utils;


These functions make it easier to manipulate the op tree.

<b>FUNCTIONSb>

all_starts

all_roots

Returns a hash of all of the starting ops or root ops of optrees, keyed to subroutine name; the optree for main program is simply keyed to __MAIN__.

Note: Certain "dangerous" stashes are not scanned for subroutines: the list of such stashes can be found in @B::Utils::bad_stashes. Feel free to examine and/or modify this to suit your needs. The intention is that a simple program which uses no modules other than B and B::Utils would show no addition symbols.

This does not return the details of ops in anonymous subroutines compiled at compile time. For instance, given

$a = sub { ... };

the subroutine will not appear in the hash. This is just as well, since theyre anonymous... If you want to get at them, use...

anon_subs()

This returns an array of hash references. Each element has the keys "start" and "root". These are the starting and root ops of all of the anonymous subroutines in the program.

$op->oldname

Returns the name of the op, even if it is currently optimized to null. This helps you understand the stucture of the op tree.

$op->kids

Returns an array of all this ops non-null children, in order.

$op->first
$op->last
$op->other

Normally if you call first, last or other on anything which is not an UNOP, BINOP or LOGOP respectivly it will die. This leads to lots of code like:

$op->first if $op->can(first);

B::Utils provides every op with first, last and other methods which will simply return nothing if it isnt relevent.

$op->parent

Returns the parent node in the op tree, if possible. Currently "possible" means "if the tree has already been optimized"; that is, if were during a CHECK block. (and hence, if we have valid next pointers.)

In the future, it may be possible to search for the parent before we have the next pointers in place, but itll take me a while to figure out how to do that.

$op->previous

Like $op->next, but not quite.

walkoptree_simple($op, &callback, [$data])

The B module provides various functions to walk the op tree, but theyre all rather difficult to use, requiring you to inject methods into the B::OP class. This is a very simple op tree walker with more expected semantics.

The &callback is called at each op with the op itself passed in as the first argument and any additional $data as the second.

All the walk functions set $B::Utils::file and $B::Utils::line to the appropriate values of file and line number in the program being examined. Since only COPs contain this information it may be unavailable in the first few callback calls.

walkoptree_filtered($op, &filter, &callback, [$data])

This is much the same as walkoptree_simple, but will only call the callback if the filter returns true. The filter is passed the op in question as a parameter; the opgrep function is fantastic for building your own filters.

walkallops_simple(&callback, [$data])

This combines walkoptree_simple with all_roots and anon_subs to examine every op in the program. $B::Utils::sub is set to the subroutine name if youre in a subroutine, __MAIN__ if youre in the main program and __ANON__ if youre in an anonymous subroutine.

walkallops_filtered(&filter, &callback, [$data])

Same as above, but filtered.

B::LintSubs is a Perl compiler backend to check sub linkage.

<b>SYNOPSISb>

perl -MO=LintSubs [FILE] [-e PROGRAM]

When using use strict, subroutine names are not checked at the callsite; this makes the following a perfectly valid program at compiletime, that only blows up at runtime

use strict;
foobar();

When using the B::LintSubs checker instead, this is detected:

$ perl -MO=LintSubs -e use strict;
foobar();
Undefined subroutine foobar called at -e line 2

Imported functions from other modules are of course detected:

$ perl -MO=LintSubs -e use strict;
use List::Util qw( max );
$_ = max( 1, 2, 3 )
-e syntax OK

In order to handle situations where external code is conditionally referenced at runtime, any fully-qualified references to other functions are printed with a warning, but not considered fatal. The programmer is assumed to Know What He Is Doing in this case:

$ perl -MO=LintSubs -e if( 1 ) { require Data::Dumper;
Data::Dumper::Dump( "Hello" ) }

Unable to check call to Data::Dumper::Dump in foreign package at -e line 1

-e syntax OK

40X Writing, 12X ReWriting, 48X Reading CDRW drive.

<b>Features:b>
Enhance drive performance

It is highly recommended to always use the most recent driver version available.
Do not forget to check with our site as often as possible in order to stay updated on the latest drivers, software and games.

Try to set a system restore point before installing a device driver. This will help if you installed a wrong driver. Problems can arise when your hardware device is too old or not supported any longer.

libyama is a malloc implementation that bundles leak tracking by auditing allocations, array bound write detection, detection of access to freed memory, free/realloc on invalid pointers. It grew out of an attempt to build array bound overwrite detection into LeakTrac, a leak tracker I wrote earlier.

Since LeakTrac performed only book keeping and not any allocation, it was not possible to make LeakTrac detect array bound write, hence an allocator that does; and also tracks leaks.

You can think of it as merging LeakTrac and code that was inspired by ElectricFence.

If you only want to track leaks, then LeakTrac is just what you need. If you want an allocator that lets you debug also, then YaMa is the one for you. Sure, there are other similar things on the block - which is why this is Yet another Memory allocator.

<b>Here are some key features of "libyama":b>

· provides malloc, calloc, realloc and free
· tracks and reports leaks
· detects accesses beyond allocated memory
· detects accesses to freed memory
· detects free on non-malloced pointers, NULL pointers
· detects realloc on non-malloced pointers

<b>Installation:b>

Currently YaMa is written for Linux x86. Youll need a kernel that provides mmap etc, and gcc that can build ELF shared libraries. You also need to install binutils, if you havent already (very unlikely) And youll need the /proc filesystem.

To install YaMa
Unpack the archive
Edit Makefile; the only things you need to change are INSTALLDIR and BT.

make lib to make
make install to install. Youll need write permission on INSTALLDIR.
You may need to run ldconfig

<b>Usage:b>

YaMa contains libyama.so, a shared library installed into INSTALLDIR by make install. The library provides malloc, calloc, realloc and free which can be used as replacements to their libc implementations.
A program can be linked against libyama on the command line (-lyama). A more interesting way to use libyama would be to preload it using LD_PRELOAD. The command line

LD_PRELOAD=libyama.so

would cause all calls to malloc, calloc, realloc and free originating from the program being run to be handled by the YaMa implementation. If libyama.so doesnt show up on ldconfig -p or it is not on your LD_LIBRARY_PATH, you need to specify the full path length.
When the program errs by accessing memory across an array bound, i.e, beyond the memory allocated using malloc/calloc/realloc, it receives a SIGSEGV. An access to freed memory also results in a SIGSEGV. If youve compiled your program using -g, you can locate the offending statement using any debugger on the core file. Note that overwrites on statically allocated arrays are not detected by YaMa.
If the program peforms an invalid free or realloc, an "Alert!" message is written to stderr, along with the call chain till the free/realloc. The call fails.

Upon normal program termination, either thro exit or return from main, a summary of leaks is printed on stderr. The size of each chunk of memory that remains un-freed at the end of the program is reported, along with the call chain till the allocation.

The behaviour of YaMa on malloc (0) (or calloc (x, 0)) is controlled by the environment variable ALLOWMALLOCZERO. If this variable is set to values <= 0, YaMa prints an Alert! message on malloc (0) and the call fails. If ALLOWMALLOCZERO is set to 1, libyama prints an Alert! message but the call succeeds and a valid pointer is returned. However, writes on this pointer will immediately trigger a SIGSEGV. If ALLOWMALLOCZERO is >= 2, YaMa returns a valid pointer and no warning is printed. Writes to this pointer, too, will fail. If ALLOWMALLOCZERO is not set, the behaviour is identical to ALLOWMALLOCZERO = 0.

<b>Whats Newb> in This Release:

· Fixed a bug in the stack backtrace code which would crash libyama. Compile time control of backtracing (Ive found it useful at times not to have tracing).

jE6-B project is an emulator of some of the functionality of the E6B Flight Computer.

This program was inspired by the similar application called Virtual E6-B written by Jesse Kempa. However that application does not seem to have been updated for some time and was based on Visual Basic, so is only for Windows (without emulation).

As I am a very keen Python user, I decided to write an Open Source Cross-Platform version of the features provided by this previous program in that language. This is my first open source project, so this program is very much a learning exercise for me. After a little playing with the various GUI toolkits available, I decided to write the program actually in Jython (a Java implementation of Python - see www.jython.org), which would make use of the Java Swing GUI toolset and also the cross-platform advantages offered by Java.