Free ops software for linux

PDL::Ops Perl module contains fundamental mathematical operators.

This module provides the functions used by PDL to overload the basic mathematical operators (+ - / * etc.) and functions (sin sqrt etc.)

It also includes the function log10, which should be a perl function so that we can overload it!

Matrix multiplication (the operator x) is handled by the module PDL::Primitive.

$doc
$c = $name $a, $b, 0; # explicit call with trailing 0
$c = $a $op $b; # overloaded call
$a->inplace->$name($b,0); # modify $a inplace

It can be made to work inplace with the $a->inplace syntax. This function is used to overload the binary $optxt operator. Note that when calling this function explicitly you need to supply a third argument that should generally be zero (see first example). This restriction is expected to go away in future releases. EOD } # sub: biop()

#simple binary functions sub bifunc { my ($name,$func,$swap,$doc,%extra) = @_; my $funcov = ref $func eq ARRAY ? $func->[1] : $func; my $isop=0; if ($funcov =~ s/^op//) { $isop = 1; } my $funcovp = protect_chars $funcov; $func = $func->[0] if ref $func eq ARRAY; if ($swap) { $extra{HdrCode} .= 1, NoBadifNaN => 1, Pars => a(); b(); [o]c();, OtherPars => int swap, Inplace => [ a ], # quick and dirty solution to get ->inplace do its job Code => "$c() = $func($a(),$b());", BadCode => if ( $ISBAD(a()) || $ISBAD(b()) ) $SETBAD(c()); else . "n $c() = $func($a(),$b());n", CopyBadStatusCode => if ( $BADFLAGCACHE() ) { if ( a == c && $ISPDLSTATEGOOD(a) ) { PDL->propogate_badflag( c, 1 ); /* have inplace op AND badflag has changed */ } $SETPDLSTATEBAD(c); }, %extra, Doc => $name($b,0); # explicit function call
$ovcall
$a->inplace->$name($b,0); # modify $a inplace

It can be made to work inplace with the $a->inplace syntax. This function is used to overload the binary $funcovp function. Note that when calling this function explicitly you need to supply a third argument that should generally be zero (see first example). This restriction is expected to go away in future releases. EOD } # sub: bifunc()

# simple unary functions and operators sub ufunc { my ($name,$func,$doc,%extra) = @_; my $funcov = ref $func eq ARRAY ? $func->[1] : $func; my $funcovp = protect_chars $funcov; $func = $func->[0] if ref $func eq ARRAY;
# handle exceptions

my $badcode = $ISBAD(a());
if ( exists $extra{Exception} ) {
# $badcode .= " || $extra{Exception}";
# print "Warning: ignored exception for $namen";
delete $exists{Exception};
}

# do not have to worry about propogation of the badflag when
# inplace since only input piddle is a, hence its badflag
# wont change
# UNLESS an exception occurs...
pp_def($name,
Pars => a(); [o]b(),
HandleBad => 1,
NoBadifNaN => 1,
Inplace => 1,
Code =>
"$b() = $func($a());",
BadCode =>
if ( . $badcode . )
$SETBAD(b());
else . "n $b() = $func($a());n",
%extra,
Doc => inplace->$name; # modify $a inplace

It can be made to work inplace with the $a->inplace syntax. This function is used to overload the unary $funcovp operator/function. EOD } # sub: ufunc()
######################################################################
# we trap some illegal operations here -- see the Exception option # note, for the ufunc()s, the checks do not work too well # for unsigned integer types (ie < 0) # # XXX needs thinking about # - have to integrate into Code section as well (so # 12/pdl(2,4,0,3) is trapped and flagged bad) # --> complicated # - perhaps could use type %{ %} ? # # ==> currently have commented out the exception code, since # want to see if can use NaN/Inf for bad values # (would solve many problems for F,D types) # # there is an issue over how we handle comparison operators # - see Primitive/primitive.pd/zcover() for more discussion #
## arithmetic ops # no swap biop(plus,+,0,add two piddles); biop(mult,*,0,multiply two piddles);

# all those need swapping biop(minus,-,1,subtract two piddles); biop(divide,/,1,divide two piddles, Exception => $b() == 0 );
## note: divide should perhaps trap division by zero as well
## comparison ops # need swapping biop(gt,>,1,the binary > (greater than) operation); biop(lt,,1,leftshift a$ by $b,GenericTypes => $T); biop(or2,|,0,binary or of two piddles,GenericTypes => $T); biop(and2,&,0,binary and of two piddles,GenericTypes => $T); biop(xor,^,0,binary exclusive or of two piddles,GenericTypes => $T);
# really an ufunc ufunc(bitnot,~,unary bit negation,GenericTypes => $T);
# some standard binary functions bifunc(power,[pow,op**],1,raise piddle $a to the power b,GenericTypes => [D]); bifunc(atan2,atan2,1,elementwise atan2 of two piddles,GenericTypes => [D]); bifunc(modulo,[MOD,op%],1,elementwise modulo operation); bifunc(spaceship,[SPACE,op],1,elementwise ~ operation);

# some standard unary functions ufunc(sqrt,sqrt,elementwise square root, Exception => $a() < 0 ); ufunc(abs,[ABS,abs],elementwise absolute value,GenericTypes => [D,F,S,L]); ufunc(sin,sin,the sin function); ufunc(cos,cos,the cos function); ufunc(not,!,the elementwise not operation); ufunc(exp,exp,the exponential function,GenericTypes => [D]); ufunc(log,log,the natural logarithm,GenericTypes => [D], Exception => $a() [D], Exception => $a() sub PDL::log10 { my $x = shift; if ( ! UNIVERSAL::isa($x,"PDL") ) { return log($x) / log(10); } my $y; if ( $x->is_inplace ) { $x->set_inplace(0); $y = $x; } elsif( ref($x) eq "PDL"){ #PDL Objects, use nullcreate: $y = PDL->nullcreate($x); }else{ #PDL-Derived Object, use copy: (Consistent with # Auto-creation docs in Objects.pod) $y = $x->copy; } &PDL::_log10_int( $x, $y ); return $y; }; );

# note: the extra code that adding HandleBad => 1 creates is # unneeded here. Things could be made clever enough to work this out, # but its very low priority. # It does add doc information though, and lets people know its been # looked at for bad value support # DJB adds: not completely sure about this now that I have added code # to avoid a valgrind-reported error (see the CacheBadFlagInit rule # in PP.pm) # # Cant this be handled in Core.pm when .= is overloaded ? # pp_def( assgn, # HandleBad => 1, Pars => a(); [o]b();, Code => $b() = $a();, # BadCode => # if ( $ISBAD(a()) ) { $SETBAD(b()); } else { $b() = $a(); }, Doc => Plain numerical assignment. This is used to implement the ".=" operator, ); # pp_def assgn

#pp_export_nothing();

pp_done();

op tool provides a flexible means for system administrators to grant access to certain root operations without having to give them full superuser privileges.
Different sets of users may access different operations, and the security-related aspects of each operation can be carefully controlled.
It was originally written around 1990 by Tom Christiansen and Dave Koblas. Further updates and porting were performed by Howard Owen. The last version of this vintage is available here. The current version is maintained by Alec Thomas.
I first came into contact with op whilst working at Access Gaming Systems, where op was used extensively to control developer and administrator access to resources.
Enhancements:
- rpl_malloc/rpl_realloc was added so that systems with dodgy implementations will link.
- This fixes compilation on HP-UX.
- If a help parameter does not exist, the actual command to be run for the help is used.
- Detection for openlog() returning void was added.

Parrot::OpTrans is a Perl module that can transform Ops to C Code.

Parrot::OpTrans is the abstract superclass for the Parrot op to C transforms. Each transform contains various bits of information needed to generate the C code, and creates a different type of run loop. The methods defined here supply various default values and behaviour common to all transforms.

The subclass hierarchy is as follows:

OpTrans
|_________________________
| | |
C CGoto Compiled
| |
CPrederef |
| | |
| |_________|
| |
CSwitch CGP

Class Methods

new()

Returns a new instance.

Instance Methods

prefix()

Returns the default Parrot_ prefix.

Used by Parrot::Ops func_name() to individuate op function names.

suffix()

Implemented in subclasses to return a suffix with which to individuate variable names. This default implementation returns an empty string.

defines()

Implemented in subclasses to return the C #define macros required.

opsarraytype()

Returns the type for the array of opcodes. By default here its an array opcode_t, but the prederef runops core uses an array of void* to do its clever tricks.

core_type()

Implemented in subclasses to return the type of core created by the transform. This default implementation raises an exception indicating that the core type is missing. See the Parrot_Run_core_t enum in include/parrot/interpreter.h for a list of the core types.

core_prefix()

Implemented in subclasses to return a short prefix indicating the core type used to individuate core function names.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the name of the main ops file minus the .ops extension.

ops_addr_decl($base_suffix)

Optionally implemented in subclasses to return the C code for the ops address declaration. $base_suffix is the name of the main ops file minus the .ops extension with suffix() and an underscore appended.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the same as for run_core_func_decl().

run_core_func_start()

Implemented in subclasses, if run_core_func_decl() is implemented, to return the C code prior to the run core function.

run_core_after_addr_table($base_suffix)

Optionally implemented in subclasses to return the run core C code for section after the address table. $base_suffix is the same as for ops_addr_decl().

run_core_finish($base)

Implemented in subclasses to return the C code following the run core function. $base is the same as for run_core_func_decl().

init_func_init1($base)

Optionally implemented in subclasses to return the C code for the cores init function. $base is the same as for run_core_func_decl().

init_set_dispatch($base_suffix)

Optionally implemented in subclasses to return the C code for initializing the dispatch mechanism within the cores init function. $base_suffix is the same as for ops_addr_decl().

Macro Substitutions

The following methods are called by Parrot::OpFile to perform ops file macro substitutions.

access_arg($type, $value, $op)

Implemented in subclasses to return the C code for the specified op argument type and value. $op is an instance of Parrot::Op.

gen_goto($where)

The various goto_X methods below call this method with the return value of an expr_X method (implemented in subclass).

restart_address($address)

Implemented in subclasses to return the C code for restart ADDRESS($address).

restart_offset($offset)

Implemented in subclasses to return the C code for restart OFFSET($offset).

goto_address($address)

Transforms the goto ADDRESS($address) macro in an ops file into the relevant C code.

goto_offset($offset)

Transforms the goto OFFSET($offset) macro in an ops file into the relevant C code.

goto_pop()

Transforms the goto POP($address) macro in an ops file into the relevant C code.

expr_offset($offset)

Implemented in subclasses to return the C code for OFFSET($offset). Called by goto_offset().

expr_address($address)

Implemented in subclasses to return the C code for ADDRESS($address). Called by goto_address().

OSSP var is a flexible, full-featured and fast variable construct expansion library. It supports a configurable variable construct syntax very similar to the style found in many scripting languages (like @name, ${name}, , etc.) and provides both simple scalar (${name}) and array (${name[index]}) expansion, plus optionally one or more post-operations on the expanded value (${name:op:op...}).
The supported post-operations are length determination, case conversion, defaults, postive and negative alternatives, sub-strings, regular expression based substitutions, character translations, and padding.
Additionally, a meta-construct plus arithmetic expressions for index and range calculations allow (even nested) iterations over array variable expansions (..[..${name[#+1]}..]..). The actual variable value lookup is performed through a callback function, so OSSP var can expand arbitrary values.
Hint: There is also an ISO C++ derivative of the OSSP var library, named libvarexp. It is based on a development version of OSSP var and hence does not provide exactly the same amount of functionality. But it provides an ISO C++ API and so can be of interest to you if you are programming in ISO C++ (where OSSP vars ISO C API might be too boring for you).
Enhancements:
- Fix some sprintf(3) parameter passing. [Ralf S. Engelschall]
- Upgraded build environment to GNU libtool 1.5.20 and GNU shtool 2.0.3. [Ralf S. Engelschall]
- Bumped year in copyright messages for new year 2005. [Ralf S. Engelschall]

Parrot::OpTrans::C is a Perl module for Ops to C Code Generation.

DESCRIPTION

Parrot::OpTrans::C inherits from Parrot::OpTrans to provide a function-based (slow or fast core) run loop.

Instance Methods

core_type()

Returns PARROT_FUNCTION_CORE.

core_prefix()

Returns an empty string.

defines()

Returns the C #define macros for register access etc.

gen_goto($where)

Reimplements the superclass method so that $where is suitably cast.

expr_address($address)

Returns the C code for ADDRESS($address). Called by goto_address().

expr_offset($offset)

Returns the C code for OFFSET($offset). Called by goto_offset().

expr_pop()

Returns the C code for POP(). Called by goto_offset().

access_arg($type, $value, $op)

Returns the C code for the specified op argument type (see Parrot::OpTrans) and value. $op is an instance of Parrot::Op.

restart_offset($offset)

Returns the C code for restart OFFSET($offset).

restart_address($address)

Returns the C code for restart ADDRESS($address).

B::Concise is a Perl syntax tree, printing concise info about ops.

SYNOPSIS

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

use B::Concise qw(set_style add_callback);

This compiler backend prints the internal OPs of a Perl programs syntax tree in one of several space-efficient text formats suitable for debugging the inner workings of perl or other compiler backends. It can print OPs in the order they appear in the OP tree, in the order they will execute, or in a text approximation to their tree structure, and the format of the information displayed is customizable. Its function is similar to that of perls -Dx debugging flag or the B::Terse module, but it is more sophisticated and flexible.

EXAMPLE

Heres an example of 2 outputs (aka renderings), using the -exec and -basic (i.e. default) formatting conventions on the same code snippet.

% perl -MO=Concise,-exec -e $a = $b + 42
1 enter
2 nextstate(main 1 -e:1) v
3 gvsv[*b] s
4 const[IV 42] s
* 5 add[t3] sK/2
6 gvsv[*a] s
7 sassign vKS/2
8 leave[1 ref] vKP/REFC

Each line corresponds to an opcode. The opcode marked with * is used in a few examples below.

The 1st column is the ops sequence number, starting at 1, and is displayed in base 36 by default. This rendering is in -exec (i.e. execution) order.

The symbol between angle brackets indicates the ops type, for example; < 2 > is a BINOP, < @ > a LISTOP, and < # > is a PADOP, which is used in threaded perls. (see "OP class abbreviations").

The opname, as in add[t1], which may be followed by op-specific information in parentheses or brackets (ex [t1]).

The op-flags (ex sK/2) follow, and are described in ("OP flags abbreviations").

% perl -MO=Concise -e $a = $b + 42
8 leave[1 ref] vKP/REFC ->(end)
1 enter ->2
2 nextstate(main 1 -e:1) v ->3
7 sassign vKS/2 ->8
* 5 add[t1] sK/2 ->6
- ex-rv2sv sK/1 ->4
3 gvsv(*b) s ->4
4 const(IV 42) s ->5
- ex-rv2sv sKRM*/1 ->7
6 gvsv(*a) s ->7

The default rendering is top-down, so theyre not in execution order. This form reflects the way the stack is used to parse and evaluate expressions; the add operates on the two terms below it in the tree.

Nullops appear as ex-opname, where opname is an op that has been optimized away by perl. Theyre displayed with a sequence-number of -, because they are not executed (they dont appear in previous example), theyre printed here because they reflect the parse.

The arrow points to the sequence number of the next op; theyre not displayed in -exec mode, for obvious reasons.

Note that because this rendering was done on a non-threaded perl, the PADOPs in the previous examples are now SVOPs, and some (but not all) of the square brackets have been replaced by round ones. This is a subtle feature to provide some visual distinction between renderings on threaded and un-threaded perls.

IO::InSitu is a Perl module to avoid clobbering files opened for both input and output.

SYNOPSIS

use IO::InSitu;

my ($in, $out) = open_rw($infile_name, $outfile_name);

for my $line () {
$line =~ s/foo/bar/g;
print {$out} $line;
}

When users want to do in-situ processing on a file, they often specify it as both the input and output file:

> myapp -i sample_data -o sample_data -op=normalize

But, if the -i and -o flags are processed independently, the program will usually open the file for input, open it again for output (at which point the file will be truncated to zero length), and then attempt to read in the first line of the now-empty file:

# Open both filehandles...
use Fatal qw( open );
open my $src, , $destination_file;

# Read, process, and output data, line-by-line...
while (my $line = < $src >) {
print {$dest} transform($line);
}

Not only does this not perform the requested transformation on the file, it also destroys the original data. Fortunately, this problem is extremely easy to avoid: just make sure that you unlink the output file before you open it:

# Open both filehandles...
use Fatal qw( open );
open my $src, , $destination_file;

# Read, process, and output data, line-by-line...
while (my $line = ) {
print {$dest} transform($line);
}

If the input and output files are different, unlinking the output file merely removes a file that was about to be rewritten anyway. Then the second open simply recreates the output file, ready for writing.

If the two filenames actually refer to a single in-situ file, unlinking the output filename removes that filename from its directory, but doesnt remove the file itself from the filesystem. The file is already open through the filehandle in $input, so the filesystem will preserve the unlinked file until that input filehandle is closed. The second open then creates a new version of the in-situ file, ready for writing.

The only limitation of this technique is that it changes the inode of any in-situ file . That can be a problem if the file has any hard-linked aliases, or if other applications are identifying the file by its inode number. If either of those situations is possible, you can preserve the in-situ files inode by using the open_rw() subroutine that is exported from this module:

# Open both filehandles...
use IO::InSitu;
my ($src, $dest) = open_rw($source_file, $destination_file);

# Read, process, and output data, line-by-line...
while (my $line = ) {
print {$dest} transform($line);
}

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.