Free spot software for linux

Cspot is a semantic annotator designed only for the C programming language. It is quite similar to cscope, but some more functionality.

Cspot project can be used to find the declarations, definitions, and usages of functions, variables, macros, typedefs, and structs.

It can also find visible identifiers at some position in the source, functions called by a function, global variables used by a function, usages of local variable declarations, unused global variables, unused function definitions, and more. Because it uses sparse, cspot knows more about semantics than cscope.

cspot usage ( cspot -h )
cspot -db spot.db -regexp reg ;; prints all identifiers of project matching reg (extended regexp)
cspot -db spot.db -fc printf ;; prints all declarations of function printf
cspot -db spot.db -fu printf ;; prints all usages of function printf
cspot -db spot.db -vu stdout ;; prints all usages of variable stdout
cspot -db spot.db -sc my_sruct ;; prints places of forward declaration of struct my_struct
cspot -db spot.db -sf my_sruct ;; prints places of definition of struct my_struct
cspot -db spot.db -su my_sruct ;; prints places of usage of struct my_struct
cspot -db spot.db -si my_sruct ;; prints places of definition and variables in struct my_struct
etc.

cspot -va source.c 254 21 ;; prints all visible identifiers at source.c line 254 pos 21
cspot -vla source.c 254 21 ;; prints all visible identifiers (declared in file source.c) at source.c line 254 pos 21

commands for visible functions, macros, variable, called functions by function, global variables used by function ...

cspot -db spot.db -fu printf
printfs all usages of function printf in project (usage = call, assigning to variable)

printf at `base/cmd/commands.h 249:7
printf at `base/cmd/commands.h 327:8
printf at `base/cmd/commands.h 337:8
printf at `base/cmd.c 313:3
printf at `base/cmd.c 318:7
printf at `base/cmd.c 319:36
printf at `base/cmd.c 321:36
printf at `base/cmd.c 322:36
printf at `base/cmd.c 323:36

Digg.com Comment Spotlight is an extension which does exactly what its name hints, it spots Digg comments.

Digg Comment Spotlight does exactly what its name hints, it spots comments that other readers have taken the time to Digg, allowing you to easily wade through 100s of comments in an article.

Gtk2::Ex::MindMapView::HotSpot::Grip is a Perl module to manage a grip type "hot spot" on a view item.

SYNOPSIS

use base Gtk2::Ex::MindMapView::HotSpot::Grip;

The Gtk2::Ex::MindMapView::HotSpot::Grip defined grip type hotspots. This kind of hot spot is used to resize Gtk2::Ex::MindMapView::Items.

INTERFACE

Properties

x (double)

The x-coordinate of the mouse location when resizing an item.

y (double)

The y-coordinate of the mouse location when resizing an item.

x_prime (double)

The x-coordinate of the previous mouse location when resizing an item.

y_prime (double)

The y-coordinate of the previous mouse location when resizing an item.

Methods

new (item=>$item)

Instantiates a grip type hotspot.

hotspot_button_press

Overrides method defined in Gtk2::Ex::MindMapView::HotSpot. This method records the position of the cursor when the mouse is first pressed.

hotspot_button_release

Overrides method defined in Gtk2::Ex::MindMapView::HotSpot. This method signals that the mind map should be redrawn.

hotspot_motion_notify

Overrides method defined in Gtk2::Ex::MindMapView::HotSpot. This method actually resizes the Gtk2::Ex::MindMapView::Item.

Gtk2::Ex::MindMapView::HotSpot::Grip::Lentil is a Perl module to manage a lentil shaped grip "hot spot" on a view item.

SYNOPSIS

use Gtk2::Ex::MindMapView::HotSpot::Grip::Lentil;

A LentilGrip hotspot may be used to resize a Gtk2::Ex::MindMapView::Item. Normally, this grip will be used with an Gtk2::Ex::MindMapView::Border:RoundedRect.

INTERFACE

Properties

item (Gtk2::Ex::MindMapView::Item)

The item this grip is attached to.

enabled (boolean)

If enabled, this grip is ready for action.

side (string)

The side of the item on which to attach the grip. May be left or right.

fill_color_gdk (Gtk2::Gdk::Color)

The color with which to fill in the hotspot.

outline_color_gdk (Gtk2::Gdk::Color)

The color with which to fill in the hotspot outline. Grips usually have the outline set to the same color as the item fill color.

hotspot_color_gdk (Gtk2::Gdk::Color)

The color of the hotspot once it is engaged. A hotspot becomes engaged when the mouse is placed close to it.

Methods

new (item=>$item, side=>left)

Instantiates a hotspot. The following properties may be passed: item, side, visible, enabled, fill_color_gdk, outline_color_gdk, hotspot_color_gdk.

hotspot_adjust_event_handler

Positions the grip at the lower left or right corner of the rectangle defined by the insets. This will change for the next release.

hotspot_get_image

Returns a right triangle shaped grip image.

gprof2dot.py script can convert the output from gprof into a dot graph. It can correctly parse C++ template function names, allows you to prune nodes and edges below a certain threshold, can parse the special notation gprof uses for mutually recursive functions, uses color efficiently to draw attention to hot-spots, and works on any platform where GNU gprof, graphviz, and Python are available, i.e. virtually anywhere.
Main features:
- can correctly parse C++ template function names;
- allows to prune nodes and edges below a certain threshold;
- can parse the special notation gprof uses for mutually recursive functions;
- uses color efficiently to draw attention to hot-spots;
- works on any platform where GNU gprof, graphviz, and Python is available, i.e, virtually anywhere.
Usage:
gprof2dot.py [options] [file]
Options:
--version show programs version number and exit
-h, --help show this help message and exit
-o FILE, --output=FILE
output filename [stdout]
-n PERCENTAGE, --node-thres=PERCENTAGE
eliminate nodes below this threshold [default: 0.05]
-e PERCENTAGE, --edge-thres=PERCENTAGE
eliminate edges below this threshold [default: 0.01]
-c COLORMAP, --colormap=COLORMAP
color map: color, pink or gray [default: color]
-s, --strip strip function parameters, template parameters, and
const modifiers from demangled C++ function names
-w, --wrap wrap function names
Enhancements:
- The output produced by gprof with the static call graph option is now handled.
- The ability to read output generated by the Python profilers was added.

polyBSD is a "multi"-purpose (hence "poly") framework for building embedded systems based on NetBSD.

Of the three major *BSD flavors, FreeBSD and OpenBSD are often in the spotlight.
FreeBSD is touted for its stability, while OpenBSD usually claims the title of
the most secure operatin system available.

However, the third flavor (NetBSD) is what many consider to be the unsung hero - it has features that rival those of both FreeBSD and OpenBSD however is not often seen in the news. NetBSD has arguably the cleanest code base of all open source operating systems this fact has unforseen effect on its overall features. The reason for
NetBSDs clean code is the its stated goal to run on as many hardware architecture
as possible. In order to do that, the team behind NetBSD has been forced to write
code that is portable and easy to debug.

Portable code is achieved by using mostly libraries and functions that are likely to compile and run well on most platforms. In addition, in order to be able to reliably port the code to over 40 different architecture, the code has to be well written so that a large group of people can look at and understand it well so they can modify it easily and port it to a new architecture. But how does that translate into stability and security touted by FreeBSD and OpenBSD respectively. Well, clean code usually translates directly into stability - one cant expect a messy code to perform well or be easy to debug.

Clean code also leads to improved security - security bugs are easy to spot and
correct. Also the portability of the code ensures that only standard libraries
and functions are used. However, those standard libarries and functions are the
ones that have been around longer, which means they have been well tested and are
likely to contain the fewest number of security bugs.

The one feature that FreeBSD had long been able to claim exclusively is that in
terms of performance it blows all other *BSD flavors out of the water when it
comes to the i386 architecture.

However, this crown was recently captured by NetBSD thanks to an extensive performance benchmarking, the results of which are referenced on the section "NetBSD tools" on this site. So to sum it all up, NetBSD is no longer simply the portability prodigy on the block. It is a fast, rock-solid and secure operating system that can successfully meet the demands of the modern enterprise. Thats the reason for it being used by the people behind this project to build some tools that will hopefully be useful.

Quantum::Superpositions package contains QM-like superpositions in Perl.

SYNOPSIS

use Quantum::Superpositions;

if ($x == any($a, $b, $c)) { ... }

while ($nextval < all(@thresholds)) { ... }

$max = any(@value) < all(@values);


use Quantum::Superpositions BINARY => [ CORE::index ];

print index( any("opts","tops","spot"), "o" );
print index( "stop", any("p","s") );

BACKGROUND

Under the standard interpretation of quantum mechanics, until they are observed, particles exist only as a discontinuous probability function. Under the Cophenhagen Interpretation, this situation is often visualized by imagining the state of an unobserved particle to be a ghostly overlay of all its possible observable states simultaneously. For example, a particle that might be observed in state A, B, or C may be considered to be in a pseudo-state where it is simultaneously in states A, B, and C. Such a particle is said to be in a superposition of states.

Research into applying particle superposition in construction of computer hardware is already well advanced. The aim of such research is to develop reliable quantum memories, in which an individual bit is stored as some measurable property of a quantised particle (a qubit). Because the particle can be physically coerced into a superposition of states, it can store bits that are simultaneously 1 and 0.

Specific processes based on the interactions of one or more qubits (such as interference, entanglement, or additional superposition) are then be used to construct quantum logic gates. Such gates can in turn be employed to perform logical operations on qubits, allowing logical and mathematical operations to be executed in parallel.

Unfortunately, the math required to design and use quantum algorithms on quantum computers is painfully hard. The Quantum::Superpositions module offers another approach, based on the superposition of entire scalar values (rather than individual qubits).