Free kitco spot gold software for linux

Kitco Spot Gold Price Watcher is an extension which fetches the Bid and Ask price of Spot Gold from Kitcos website.

This extension retrieve the Bid and Ask price of Spot Gold from Kitcos website.

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.

Vector Linux is a small, fast, Linux operating system for Intel, AMD and x86 compatible systems, based on one of the original Linux distributions, Slackware.
The Vector development team is proud to announce SOHO 5.1.2-live. We started with SOHO 5.1 added all the recent bugfix patches, and rolled it into a livecd. This is what I believe to be the most feature packed livecd available. It comes with two complete desktops kde-3.4.2, and xfce4.
Built upon the great heritage that is slackware. this release features the 2.6.15.1 kernel, OpenOffice 2.0, Firefox-1.5, Scribus, the Gimp, Mplayer, multimedia pluggins, printer support, scanner support and everything a complete desktop/work station should have.
Plus all of Vectors own administration utilities, and just look at this list of wireless modules
If youve ever wanted to try Vector, or just wanted to show your friends, without having to partition hard drives then here is your chance.
Enhancements:
- The VectorLinux team is proud to announce the release of VectorLinux 5.8 Live CD and the first SOHO 5.8 alpha live CD and DVD. This is the final release for 5.8 standard GOLD live. The hard drive installer that has been problematic is fixed and should work well. The SOHO 5.8 alpha live comes in either CD or DVD editions. The DVD edition includes all that is in the SOHO 5.8 install release plus 62 additional language packs for KDE. The CD version has lost some functionality due to size constraints. The development tool chain and OpenOffice.org were removed.

Filter::decrypt Perl module contains a template for a decrypt source filter.

SYNOPSIS

use Filter::decrypt ;

This is a sample decrypting source filter.

Although this is a fully functional source filter and it does implement a very simple decrypt algorithm, it is not intended to be used as it is supplied. Consider it to be a template which you can combine with a proper decryption algorithm to develop your own decryption filter.

WARNING

It is important to note that a decryption filter can never provide complete security against attack. At some point the parser within Perl needs to be able to scan the original decrypted source. That means that at some stage fragments of the source will exist in a memory buffer.

Also, with the introduction of the Perl Compiler backend modules, and the B::Deparse module in particular, using a Source Filter to hide source code is becoming an increasingly futile exercise.

The best you can hope to achieve by decrypting your Perl source using a source filter is to make it unavailable to the casual user.

Given that proviso, there are a number of things you can do to make life more difficult for the prospective cracker.

Strip the Perl binary to remove all symbols.

Build the decrypt extension using static linking. If the extension is provided as a dynamic module, there is nothing to stop someone from linking it at run time with a modified Perl binary.

Do not build Perl with -DDEBUGGING. If you do then your source can be retrieved with the -Dp command line option.

The sample filter contains logic to detect the DEBUGGING option.

Do not build Perl with C debugging support enabled.

Do not implement the decryption filter as a sub-process (like the cpp source filter). It is possible to peek into the pipe that connects to the sub-process.

Check that the Perl Compiler isnt being used.

There is code in the BOOT: section of decrypt.xs that shows how to detect the presence of the Compiler. Make sure you include it in your module.

Assuming you havent taken any steps to spot when the compiler is in use and you have an encrypted Perl script called "myscript.pl", you can get access the source code inside it using the perl Compiler backend, like this

perl -MO=Deparse myscript.pl

Note that even if you have included the BOOT: test, it is still possible to use the Deparse module to get the source code for individual subroutines.

Do not use the decrypt filter as-is. The algorithm used in this filter has been purposefully left simple.

If you feel that the source filtering mechanism is not secure enough you could try using the unexec/undump method. See the Perl FAQ for further details.

The Revisionist is a tool for extracting and indexing hidden metadata (such as deleted or modified text) from large collections of MS Word files.
It can operate whole Web sites or SMB or NFS directories. The Revisionist project is handy for pen-testing, or it can be used just to spot embarrassing secrets.
My primary goal is to provide pen-testers and content administrators with a handy tool to detect hidden data in all documents available at a specific location (be it a locally mounted network share, a HTTP site, or whatnot), and easily review it all.
Right now, the tool only detects and indexes deleted text in documents with "change tracking" enabled, and can also index usernames and hardware addresses embedded in documents (to facilitate external assessment of company structure); future versions should be able to recover other goodies, too.
Usage:
To run the tool against a local directory, a mounted SMB or NFS directory, or such, simply issue the following command (after doing make, that is):
./therev @/path/to/directory
After the tool completes, you should be able to view master.html in current directory using your favourite browser (Lynx, Netscape, etc). Cached copies of documents would be placed in subdirectories named document.XXXXXX, where X is a random digit; hence, it is recommended to run the tool in a separate directory.
Note that you may also instruct the tool to look for specific substring and only choose those documents that contain it (strict checking, no regexp available):
./therev linux @/path/to/directory
To run the program against a specific site or top-level domain, do the following:
./therev site.com
Note that com, gov, gov.pl, www.microsoft.com are all a valid site name. The first parameter works similar to the previous case:
./therev homeland security gov
As a special bonus, when running the script against multilinguinal sites, you might want to specify a third parameter - desired language (using a two-letter code: en, pl, etc). NOTE: DO NOT USE LANGUAGE QUALIFIER UNLESS NECESSARY:
./therev linux microsoft.com en
The HTTP search mode uses Google.com to locate all matching Word documents on a specific site. For a document to be found, it must be indexable (that is, not excluded in robots.txt) and be in the first 1000 of results for a specific site. If there are more than 1000 documents at some website, consider sub-searches with keywords.
Enhancements:
- This release was fixed to work with the new Google page layout.
- Some other minor fixes were made.

Gtk2::Ex::MindMapView::ItemHotSpot is a Perl module to manage a "hot spot" on a view item.

SYNOPSIS

use Gtk2::Ex::MindMapView::ItemHotSpot;

Four Gtk2::Ex::MindMapView::ItemHotSpots are created for each Gtk2::Ex::MindMapView::Item. The hotspots are areas on the mind map, that when clicked, cause an action to be performed on an item. These hotspots allow the user to expand/collapse the items in the mind map, or to resize an item.

INTERFACE

Properties

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

The item that this hotspot belongs to.

enabled

If true, the toggle is receiving events and may act on them. Otherwise it is not receiving events.

fill_color_gdk (Gtk2::Gdk::Color)

The color with which to fill the toggle.

outline_color_gdk (Gtk2::Gdk::Color)

The color with which to fill in the hotspot outline. Toggles normally have a visible outline, while 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)

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

hotspot_adjust_event_handler

Overrides method defined in Gtk2::Ex::MindMapView::HotSpot. This method sets the proper state of the toggle when a "hotspot_adjust" event occurs.

hotspot_get_image

Overrides method defined in Gtk2::Ex::MindMapView::HotSpot. Returns a circle (Gnome2::Canvas::Ellipse) image.

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).