Free pointer software for linux

Devel::Pointer is a Perl module that can fiddle around with pointers.

SYNOPSIS

use Devel::Pointer;
$a = address_of($b); # a = &b;
$b = deref($a); # b = *a;

$a = unsmash_sv(0+$scalar_ref);
@a = unsmash_av(0+$array_ref);
%a = unsmash_hv(0+$hash_ref);
&a = unsmash_cv(0+$code_ref);
# OK, you cant do that, but you get the idea

$c = deref(-1); # *(-1), and the resulting segfault.

The primary purpose of this is to turn a smashed reference address back into a value. Once a reference is treated as a numeric value, you cant dereference it normally; although with this module, you can.

Be careful, though, to avoid dereferencing things that dont want to be dereferenced.

PDL::Internals is a Perl module that contains a description of some aspects of the current internals.

Intro

This document explains various aspects of the current implementation of PDL. If you just want to use PDL for something, you definitely do not need to read this. Even if you want to interface your C routines to PDL or create new PDL::PP functions, you do not need to read this man page (though it may be informative). This document is primarily intended for people interested in debugging or changing the internals of PDL. To read this, a good understanding of the C language and programming and data structures in general is required, as well as some Perl understanding. If you read through this document and understand all of it and are able to point what any part of this document refers to in the PDL core sources and additionally struggle to understand PDL::PP, you will be awarded the title "PDL Guru" (of course, the current version of this document is so incomplete that this is next to impossible from just these notes).

Warning: If it seems that this document has gotten out of date, please inform the PDL porters email list (pdl-porters@jach.hawaii.edu). This may well happen.

Piddles

The pdl data object is generally an opaque scalar reference into a pdl structure in memory. Alternatively, it may be a hash reference with the PDL field containing the scalar reference (this makes overloading piddles easy, see PDL::Objects). You can easily find out at the Perl level which type of piddle you are dealing with. The example code below demonstrates how to do it:

# check if this a piddle
die "not a piddle" unless UNIVERSAL::isa($pdl, PDL);
# is it a scalar ref or a hash ref?
if (UNIVERSAL::isa($pdl, "HASH")) {
die "not a valid PDL" unless exists $pdl->{PDL} &&
UNIVERSAL::isa($pdl->{PDL},PDL);
print "This is a hash reference,",
" the PDL field contains the scalar refn";
} else {
print "This is a scalar ref that points to address $$pdl in memoryn";
}

The scalar reference points to the numeric address of a C structure of type pdl which is defined in pdl.h. The mapping between the object at the Perl level and the C structure containing the actual data and structural that makes up a piddle is done by the PDL typemap. The functions used in the PDL typemap are defined pretty much at the top of the file pdlcore.h. So what does the structure look like:

struct pdl {
unsigned long magicno; /* Always stores PDL_MAGICNO as a sanity check */
/* This is first so most pointer accesses to wrong type are caught */
int state; /* Whats in this pdl */

pdl_trans *trans; /* Opaque pointer to internals of transformation from
parent */

pdl_vaffine *vafftrans;

void* sv; /* (optional) pointer back to original sv.
ALWAYS check for non-null before use.
We cannot inc refcnt on this one or wed
never get destroyed */

void *datasv; /* Pointer to SV containing data. Refcnt inced */
void *data; /* Null: no data alloced for this one */
int nvals; /* How many values allocated */
int datatype;
PDL_Long *dims; /* Array of data dimensions */
PDL_Long *dimincs; /* Array of data default increments */
short ndims; /* Number of data dimensions */

unsigned char *threadids; /* Starting index of the thread index set n */
unsigned char nthreadids;

pdl *progenitor; /* Im in a mutated family. make_physical_now must
copy me to the new generation. */
pdl *future_me; /* Im the "then" pdl and this is my "now" (or more modern
version, anyway */

pdl_children children;

short living_for; /* perl side not referenced; delete me when */

PDL_Long def_dims[PDL_NDIMS]; /* Preallocated space for efficiency */
PDL_Long def_dimincs[PDL_NDIMS]; /* Preallocated space for efficiency */
unsigned char def_threadids[PDL_NTHREADIDS];

struct pdl_magic *magic;

void *hdrsv; /* "header", settable from outside */
};

This is quite a structure for just storing some data in - what is going on?

OpenInput project is a cross-platform, easy-to-use, portable input handler library, written in C.
The primary goal of OpenInput is to make it easier for application programmers to write portable code that deals with input from mice, keyboards, joysticks and other devices.
In other words, OpenInput will allow you to write a single piece of code that handles input for your application for all platforms, for example GNU/Linux, Windows and MacOS X.
This is achieved by abstracting the low-level platform-specific input device handling into a stable, intuitive, platform-independent API: OpenInput.
Main features:
- Total platform independence
- Easy to use, sane and simple API
- Fully documented functions and data structures
- Automatic configuration of available devices
- Generic event handling
- Keyboard state managment (eg. up/down/lock)
- Mouse motion and state managment (eg. movement, buttons up/down)
- Joystick motion and state handling for axes, hats and trackballs
- Can "hook" into existing windows
- Provides resize, iconify, close and expose events for the application window
- Action mapping, so events can be handled without any knowledge of the underlying device
- Pointer (mouse) grabbing inside window
- Show/hide pointer inside window
- Keyboard focus grabbing
Enhancements:
- This version contains major documentation updates, both big and small bugfixes, and minor feature enhancements which dont break the API.

Yasper (Yet Another Smart Pointer) is a sweet and simple single-header smart pointer for C++.

Why write another C++ smart pointer?

There are two high quality libraries that include smart pointers: Loki and Boost. Alexandrescus Loki SmartPtr is customizable to a fault. I find policy templates unspeakably ugly and dont need the extra options. Boosts shared_ptr is quite nice, but is too restrictive and introduces undesirable dependency on the massive Boost library. What I need is a small, simple smart pointer: yasper.

Philosophy

small (contained in single header)
simple (nothing fancy in the code, easy to understand)
maximum compatibility (drop in replacement for dumb pointers)

The last point can be dangerous, since yasper permits risky (yet useful) actions (such as assignment to raw pointers and manual release) disallowed by other implementations. Be careful, only use those features if you know what youre doing!

PDL::Indexing Perl module contains a tutorial on how to index piddles.

This manpage should serve as a first tutorial on the indexing and threading features of PDL.

This manpage is still in alpha development and not yet complete. "Meta" comments that point out deficiencies/omissions of this document will be surrounded by square brackets ([]), e.g. [ Hopefully I will be able to remove this paragraph at some time in the future ]. Furthermore, it is possible that there are errors in the code examples. Please report any errors to Christian Soeller (c.soeller@auckland.ac.nz).

Still to be done are (please bear with us and/or ask on the mailing list, see PDL::FAQ):

document perl level threading
threadids
update and correct description of slice
new functions in slice.pd (affine, lag, splitdim)
reworking of paragraph on explicit threading

Indexing and threading with PDL

A lot of the flexibility and power of PDL relies on the indexing and looping features of the perl extension. Indexing allows access to the data of a pdl object in a very flexible way. Threading provides efficient implicit looping functionality (since the loops are implemented as optimized C code).

Pdl objects (later often called "pdls") are perl objects that represent multidimensional arrays and operations on those. In contrast to simple perl @x style lists the array data is compactly stored in a single block of memory thus taking up a lot less memory and enabling use of fast C code to implement operations (e.g. addition, etc) on pdls.

pdls can have children

Central to many of the indexing capabilities of PDL are the relation of "parent" and "child" between pdls. Many of the indexing commands create a new pdl from an existing pdl. The new pdl is the "child" and the old one is the "parent". The data of the new pdl is defined by a transformation that specifies how to generate (compute) its data from the parents data. The relation between the child pdl and its parent are often bidirectional, meaning that changes in the childs data are propagated back to the parent. (Note: You see, we are aiming in our terminology already towards the new dataflow features. The kind of dataflow that is used by the indexing commands (about which you will learn in a minute) is always in operation, not only when you have explicitly switched on dataflow in your pdl by saying $a->doflow. For further information about data flow check the dataflow manpage.)

Another way to interpret the pdls created by our indexing commands is to view them as a kind of intelligent pointer that points back to some portion or all of its parents data. Therefore, it is not surprising that the parents data (or a portion of it) changes when manipulated through this "pointer". After these introductory remarks that hopefully prepared you for what is coming (rather than confuse you too much) we are going to dive right in and start with a description of the indexing commands and some typical examples how they might be used in PDL programs. We will further illustrate the pointer/dataflow analogies in the context of some of the examples later on.

There are two different implementations of this ``smart pointer relationship: the first one, which is a little slower but works for any transformation is simply to do the transformation forwards and backwards as necessary. The other is to consider the child piddle a ``virtual piddle, which only stores a pointer to the parent and access information so that routines which use the child piddle actually directly access the data in the parent. If the virtual piddle is given to a routine which cannot use it, PDL transparently physicalizes the virtual piddle before letting the routine use it.

Currently (1.94_01) all transformations which are ``affine, i.e. the indices of the data item in the parent piddle are determined by a linear transformation (+ constant) from the indices of the child piddle result in virtual piddles. All other indexing routines (e.g. ->index(...)) result in physical piddles. All routines compiled by PP can accept affine piddles (except those routines that pass pointers to external library functions).

Note that whether something is affine or not does not affect the semantics of what you do in any way: both

$a->index(...) .= 5;
$a->slice(...) .= 5;

change the data in $a. The affinity does, however, have a significant impact on memory usage and performance.

LinkPreview displays a thumbnail image of a link by moving the mouse pointer over the link.

View a thumbnail image of a link by moving the mouse pointer over the link or in the right-click context menu.

Powerbox for Gtk is a patch to Gtk which replaces its GtkFileChooserDialog
Powerbox is a normal file chooser dialog box, except that it dynamically grants the application the right to access the file that the user picks.
This helps provide security because the application can be run without needing access to all the users files. Powerbox-for-Gtk patches Gtk to replace GtkFileChooserDialog with a powerbox.
It is based on Plash, which provides a restricted execution environment on Linux.
Enhancements:
- Add gtk-powerbox.c: an LD_PRELOADed patch to Gtk to replace the GtkFileChooserDialog interface so that it calls Plashs powerbox.
- Rename "plash" executable to "pola-shell".
- fs-operations.c: Add log method. Add an "end" log message when the fs_op object is dropped.
- gettextization
- make.sh: Add "-Wl,-z,relro" when linking ld.so. Fixes obscure problem when dlopen()ing libraries that might require an executable stack.
- Intercept getsockname() so that it returns the correct pathname for Unix domain sockets. Extended the g_fds array in libc so that it can contain these pathnames. It is now an array of "struct libc_fd"s, rather than an array of "cap_t"s. libc-fds.h: New file. libc-misc.c: Introduced fds_resize(), fds_slot_clear(). Changed open(), close(), dup2(), etc. libc-connect.c: Add getsockname() and change connect() and bind().
- Reason: I discovered that gconfd2 (or possibly Orbit) was relying on getsockname() returning the pathname that it earlier passed to bind(). This meant that Gnumeric was unable to spawn a gconf process itself, and it produced loads of errors.
- fs-operations.c, libc-misc.c: Fixed fstat() to return the correct information on directory FDs. Added the fsop_dir_fstat method to implement this.
- build-fs-dynamic.c: Implement link() and rename() methods. This is needed for when GNOME and KDE apps hard link files inside $HOME.
- filesysobj-real.c: Changes to allow rename and hard link calls of the form rename("dir/foo1", "dir/foo2") to work.
- The problem: The real_dir_rename and real_dir_link methods only work in the same-directory case; their test was a pointer comparison on real_dir objects. However, resolving a directory pathname like "dir" always returns a new real_dir object. This meant that the rename() call wouldnt work when you use full pathnames.
- This was causing some failures. eg. Konqueror wouldnt start: some code relied on creating "$HOME/.ICEauthority-l" as a hard link to "$HOME/.ICEauthority-c".
- The partial solution: Change the same-directory check to compare inode and device number of directory, after trying a pointer comparison.

xtermcontrol enables dynamic control of XFree86 xterm properties. xtermcontrol project makes it easy to change colors, titles, fonts, and the geometry of a running xterm, as well as to report the current settings of the properties.
Window manipulations such as (de)iconify, raise and lower, maximize and restore, and reset are also supported. It also lets advanced users issue any xterm control sequence.
Options:
--fg=COLOR
Set foreground color to COLOR.
--bg=COLOR
Set background color to COLOR.
--colorN=COLOR
Set Nth [0-15] color to COLOR.
--highlight=COLOR
Set highlight color to COLOR.
--cursor=COLOR
Set cursor color to COLOR.
--mouse-fg=COLOR
Set mouse pointer foreground color to COLOR.
--mouse-fg=COLOR
Set mouse pointer background color to COLOR.
--font=FONT
Set font name to FONT. Alternatively it is possible to specify a fontmenu index as #[0-6] or navigate the fontmenu by relative sizes as #+N or #-N, where N is an optional integer.
--title=STRING
Set window title. Note that mechanisms like the Bash PROMPT_COMMAND may overwrite the title. Se also How to change the title of an xterm.
--geometry=WIDTHxHEIGHT+XOFF+YOFF
Set size and/or position. Through its control sequences the xterm only recognize positive XOFF and YOFF offsets, which are pixels relative to the upper left hand corner of the display. xtermcontrol is therefore unable to handle negative offsets as described in the X Geometry Specifications and therefore truncates negative values to zero.
--get-fg
Report foreground color.
--get-bg
Report background color.
--get-colorN
Report Nth [0-15] color.
--get-highlight
Report highlight color.
--get-cursor
Report cursor color.
--get-mouse-fg
Report mouse pointer foreground color.
--get-mouse-bg
Report mouse pointer background color.
--get-font
Report font.
--get-title
Report window title.
--get-geometry
Report size and position. The size of the text area is reported in characters and the position is reported in pixels relative to the upper left hand corner of the display.
--maximize
Maximize window.
--restore
Restore maximized window.
--iconify
Iconify window.
--de-iconify
De-iconify window.
--raise
Raise window.
--lower
Lower window.
--reset
Full reset.
--raw=CTLSEQS
Issue the raw control sequences CTLSEQS.
--file=FILE
Force xtermcontrol to read configurations from FILE instead of the standard personal initialization file ~/.xtermcontrol.
--force, -f
Skip TERM environment variable check.
--verbose, -v
Print verbose reports.
--help, -h
Print help and exit.
--version
Print the version number and exit.
Enhancements:
- src/configuration.c: Fix regexp, so the #rrggbb way to specify a color works in configuration file. Reported by Olle Mulmo.
- doc/xtermcontrol.roff: add BUGS section describing how install needs to setuid root on some broken systems.