Free utils software for linux

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

SYNOPSIS

use B::Utils;


These functions make it easier to manipulate the op tree.

FUNCTIONS

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.

CGI::Utils is a Perl module for retrieving information through the Common Gateway Interface and mod_perl.
Enhancements:
- This release adds support for mod_perl 2 in addition to mod_perl 1.
- It fixes some formatting issues with the POD documentation and adds underscore versions of more methods.

Array::Utils module contains small utils for array manipulation.

SYNOPSIS

use Array::Utils qw(:all);

my @a = qw( a b c d );
my @b = qw( c d e f );

# symmetric difference
my @diff = array_diff(@a, @b);

# intersection
my @isect = intersect(@a, @b);

# unique union
my @unique = unique(@a, @b);

# check if arrays contain same members

if ( !array_diff(@a, @b) ) {
# do something
}

FUNCTIONS

unique

Returns an array of unique items in the arguments list.

intersect

Returns an intersection of two arrays passed as arguments.

array_diff

Return symmetric difference of two arrays passed as arguments

Prima::Utils are miscellanneous routines.

The module contains several helper routines, implemented in both C and perl. Whereas the C-coded parts are accessible only if use Prima; statement was issued prior to the use Prima::Utils invocation, the perl-coded are always available. This makes the module valuable when used without the rest of toolkit code.

API

alarm $TIMEOUT, $SUB, @PARAMS

Calls SUB with PARAMS after TIMEOUT milliseconds.

beep [ FLAGS = mb::Error ]

Invokes the system-depended sound and/or visual bell, corresponding to one of following constants:

mb::Error
mb::Warning
mb::Information
mb::Question

get_gui

Returns one of gui::XXX constants, reflecting the graphic user interface used in the system:
gui::Default
gui::PM
gui::Windows
gui::XLib
gui::OpenLook
gui::Motif

The meaning of the return value is somewhat vague, and might be deprecated in future releases.

get_os

Returns one of apc::XXX constants, reflecting the platfrom. Currently, the list of the supported platforms is:

apc::Os2
apc::Win32
apc::Unix

ceil DOUBLE

Obsolete function.

Returns stdlibs ceil() of DOUBLE

find_image PATH

Converts PATH from perl module notation into a file path, and searches for the file in @INC paths set. If a file is found, its full filename is returned; otherwise undef is returned.

floor DOUBLE

Obsolete function.

Returns stdlibs floor() of DOUBLE

getdir PATH

Reads content of PATH directory and returns array of string pairs, where the first item is a file name, and the second is a file type.

The file type is a string, one of the following:
"fifo" - named pipe
"chr" - character special file
"dir" - directory
"blk" - block special file
"reg" - regular file
"lnk" - symbolic link
"sock" - socket
"wht" - whiteout

This function was implemented for faster directory reading, to avoid successive call of stat for every file.

path [ FILE ]

If called with no parameters, returns path to a directory, usually ~/.prima, that can be used to contain the user settings of a toolkit module or a program. If FILE is specified, appends it to the path and returns the full file name. In the latter case the path is automatically created by File::Path::mkpath unless it already exists.

post $SUB, @PARAMS

Postpones a call to SUB with PARAMS until the next event loop tick.

query_drives_map [ FIRST_DRIVE = "A:" ]

Returns anonymous array to drive letters, used by the system. FIRST_DRIVE can be set to other value to start enumeration from. Some OSes can probe eventual diskette drives inside the drive enumeration routines, so there is a chance to increase responsiveness of the function it might be reasonable to set FIRST_DRIVE to C: string.

If the system supports no drive letters, empty array reference is returned ( unix ).

query_drive_type DRIVE

Returns one of dt::XXX constants, describing the type of drive, where DRIVE is a 1-character string. If there is no such drive, or the system supports no drive letters ( unix ), dt::None is returned.

dt::None
dt::Unknown
dt::Floppy
dt::HDD
dt::Network
dt::CDROM
dt::Memory

sound [ FREQUENCY = 2000, DURATION = 100 ]

Issues a tone of FREQUENCY in Hz with DURATION in milliseconds.

username

Returns the login name of the user. Sometimes is preferred to the perl-provided getlogin ( see "getlogin" in perlfunc ) .

xcolor COLOR

Accepts COLOR string on one of the three formats:

#rgb
#rrggbb
#rrrgggbbb

and returns 24-bit RGB integer value.

B::JVM::Utils is a Perl module that contains utility functions for B::JVM.

SYNOPSIS

use B::JVM::Utils qw(method1 method2);

This package is a set of utilties that are useful when compiling Perl to the JVM architecture. They are a hodgepodge of utilties that dont really fit anywhere else.

B::JVM::Jasmin::Utils Package Variables

$VERSION

Version number of B::JVM::Utils. For now, it should always match the version of B::JVM::Jasmin

@EXPORT_OK

All the methods that one can grab from B::JVM::Utils.

@EXPORT

We dont export anything by default.

Modules used by B::JVM::Utils

Carp

Used for error reporting

Methods in B::JVM::Utils

B::JVM::ExtractMethodData

usage: B::JVM::ExtractMethodData(METHOD_STRING)

Takes a string that is believed to a valid method string for a JVM method, and if it is a valid method string, returns a hash reference that looks like: { methodName => NAME_OF_THE_METHOD, returnType => TYPE_ID_OF_RETURN_TYPE, argumentTypes => [ ARGUMENT_1_RETURN_TYPE_ID, ARGUMENT_1_RETURN_TYPE_ID, ... ] } An undefined value is returned if the method string is not valid.

B::JVM::Utils::IsValidMethodString

usage: B::JVM::Utils::IsValidMethodString(METHOD_STRING)

Takes a string that is believed to a valid method name for a JVM method, and returns a true iff. the METHOD_STRING is a valid JVM method name

B::JVM::Utils

usage: B::JVM::Utils:IsValidTypeIdentifier(TYPE_ID)

Takes a string that is believed to a valid type identifitier name on the JVM, and returns a true iff. the TYPE_ID is a valid JVM type identifier

Gtk2::Ex::Utils is a Perl module with extra Gtk2 Utilities for working with Gnome2/Gtk2 in Perl.

SYNOPSIS

use Gtk2::Ex::Utils qw( :main );

# do stuff
...

# Update the UI and react to pending events
process_pending_events();

# do more stuff
...

# Exit the program with a value of 255 for some reason
process_main_exit( 255 );

This module provides simple utility functions useful for Gnome2/Gtk2 Perl programming.

InstallUtils is a small script which provides installation methods to be used in the Install.py script for Plone products.
This is a tiny Plone product that provides some often used methods for an Install.py script. The bundle takes the complexity out of your Install script, into separate, well tested methods.
InstallUtils provides installation methods to be used in the Install.py script for Plone products. The bundle takes the complexity out of your installation script, into separately reused and tested installer methods. This greatly enhances the stability of your installation procedures and simplifies your Install.py script.
The bundle provides numerous methods often used in an installation procedure, like installing external methods, new portal roles, workflows, properties on new or existing property sheets, and installing complete content structures during installation.
All methods are coded in separate files, and are imported from the utils.py
file.
If you wish to add your own methods, please be so kind as to obey the following
rules, then send us the method:
- add python doc;
- add code comments;
- add print statements when starting your method, and when ending your install, and in between whatever youre installing;
- have a beer.
Enhancements:
- installWorkflows doesnt automatically update the rolemappings, unless
- overridden with (extra) parameter.