Free find the best software for linux

FindEmAll is another graphical find-and-grep tool.
Find Em All is inspired by XFCE-3s XFglob and Efinder which is part of the Equinox desktop environment.
Unfortunately XFglob is no longer included in XFCE and Efinder does not seem to work (at least for me), because it uses XFCEs glob command which is no longer available.
Main features:
- optional Perl-style regular expression syntax (grep -P)
- search for files owned by non-system user / group (find -nouser -nogroup)
- search files where the search pattern does not match
- exclude binary files from search
Files may be opened in your favorite editor by a double-click on an entry in the list of results. Right-clicking a file opens a context menu that allows to choose an arbitrary application to open this file.

Felidae ist a collection of modules for Fvwm, written in Perl. Currently it contains:

FvwmStorage
FvwmStorage is a fvwm module written in Perl. It lets you define variables, load and store then from/to files and execute any fvwm command using this variables. It is especialy useful to interactively change the fvwm configuration.

FvwmWallpaper
FvwmWallpaper is a fvwm module written in Perl. It lets you change your X wallpaper from within Fvwm. FvwmWallpaper tries to find the best way to display your picture and resizes it if necessary. Resized pictures are cached. FvwmWallpaper can display a menu with thumbnails where you can select your wallpaper. Thumbnails are cached too.

FvwmXMMS
FvwmXMMS is a fvwm module written in Perl. It lets you control XMMS by sending commands to this module.

FvwmOsd
FvwmOsd is a fvwm module written in Perl. It lets you display an on-screen display (like the one on many TVs) on your X display. FvwmOsd is organized in different "channels" each of which you can configure and use independently of the others.

MP3::Find is a Perl module to search and sort MP3 files based on their ID3 tags.

SYNOPSIS

# select with backend you want
use MP3::Find qw(Filesystem);

print "$_n" foreach find_mp3s(
dir => /home/peter/cds,
query => {
artist => ilyaimy,
title => deep in the am,
},
ignore_case => 1,
exact_match => 1,
sort => [qw(year album tracknum)],
printf => %2n. %a - %t (%b: %y),
);

This module allows you to search for MP3 files by their ID3 tags. You can ask for the results to be sorted by one or more of those tags, and return either the list of filenames (the deault), a printf-style formatted string for each file using its ID3 tags, or the actual Perl data structure representing the results.

There are currently two backends to this module: MP3::Find::Filesystem and MP3::Find::DB. You choose which one you want by passing its name as the argument to you use statement; MP3::Find will look for a MP3::Find::$BACKEND module. If no backend name is given, it will default to using MP3::Find::Filesystem.
Note: Im still working out some kinks in the DB backend, so it is currently not as stable as the Filesystem backend.

Note the second: This whole project is still in the alpha stage, so I can make no guarentees that there wont be significant interface changes in the next few versions or so. Also, comments about what about the API rocks (or sucks!) are appreciated.

MP3::Find::Filesystem is a File::Find-based backend to MP3::Find.

SYNOPSIS

use MP3::Find::Filesystem;
my $finder = MP3::Find::Filesystem->new;

my @mp3s = $finder->find_mp3s(
dir => /home/peter/music,
query => {
artist => ilyaimy,
album => myxomatosis,
},
ignore_case => 1,
);

Email::Find allows you to find RFC 822 email addresses in plain text.

Email::Find is a module for finding a subset of RFC 822 email addresses in arbitrary text (see "CAVEATS"). The addresses it finds are not guaranteed to exist or even actually be email addresses at all (see "CAVEATS"), but they will be valid RFC 822 syntax.

Email::Find will perform some heuristics to avoid some of the more obvious red herrings and false addresses, but theres only so much which can be done without a human.

Finds email addresses in the text and executes callback registered.

The callback is given two arguments. The first is a Mail::Address object representing the address found. The second is the actual original email as found in the text. Whatever the callback returns will replace the original text.

File::Find::Rule::XPath is a Perl module that contains rule to match on XPath expressions.

SYNOPSIS

use File::Find::Rule::XPath;

my @files = File::Find::Rule->file
->name(*.dkb)
->xpath( //section/title[contains(., "Crustacean")] )
->in($root);

This module extends File::Find::Rule to provide the ability to locate XML files which match a given XPath expression.

METHODS

xpath( $xpath_expression )

Matches XML files which contain one or more nodes matching the given XPath expression. Files which are not well formed XML are silently skipped.

If no XPath expression is supplied, the value / is used. This will match all files which are well formed XML.

NASM is an 80x86 assembler designed for portability and modularity. The project supports a range of object file formats including Linux a.out and ELF, COFF, Microsoft 16-bit OBJ and Win32. It will also output plain binary files.
Its syntax is designed to be simple and easy to understand, similar to Intels but less complex. It supports Pentium, P6, MMX, 3DNow! and SSE opcodes, and has macro capability. It includes a disassembler as well.
The Netwide Assembler grew out of an idea on comp.lang.asm.x86 (or possibly alt.lang.asm - I forget which), which was essentially that there didnt seem to be a good free x86-series assembler around, and that maybe someone ought to write one.
- a86 is good, but not free, and in particular you dont get any 32-bit capability until you pay. Its DOS only, too.
- gas is free, and ports over DOS and Unix, but its not very good, since its designed to be a back end to gcc, which always feeds it correct code. So its error checking is minimal. Also, its syntax is horrible, from the point of view of anyone trying to actually write anything in it. Plus you cant write 16-bit code in it (properly).
- as86 is Minix- and Linux-specific, and (my version at least) doesnt seem to have much (or any) documentation.
- MASM isnt very good, and its (was) expensive, and it runs only under DOS.
- TASM is better, but still strives for MASM compatibility, which means millions of directives and tons of red tape. And its syntax is essentially MASMs, with the contradictions and quirks that entails (although it sorts out some of those by means of Ideal mode). Its expensive too. And its DOS-only.
So here, for your coding pleasure, is NASM. At present its still in prototype stage - we dont promise that it can outperform any of these assemblers. But please, please send us bug reports, fixes, helpful information, and anything else you can get your hands on (and thanks to the many people whove done this already! You all know who you are), and well improve it out of all recognition. Again.
Installing NASM under Unix
Once youve obtained the Unix source archive for NASM, nasm-X.XX.tar.gz (where X.XX denotes the version number of NASM contained in the archive), unpack it into a directory such as /usr/local/src. The archive, when unpacked, will create its own subdirectory nasm-X.XX.
NASM is an auto-configuring package: once youve unpacked it, cd to the directory its been unpacked into and type ./configure. This shell script will find the best C compiler to use for building NASM and set up Makefiles accordingly.
Once NASM has auto-configured, you can type make to build the nasm and ndisasm binaries, and then make install to install them in /usr/local/bin and install the man pages nasm.1 and ndisasm.1 in /usr/local/man/man1. Alternatively, you can give options such as --prefix to the configure script (see the file INSTALL for more details), or install the programs yourself.
NASM also comes with a set of utilities for handling the RDOFF custom object-file format, which are in the rdoff subdirectory of the NASM archive. You can build these with make rdf and install them with make rdf_install, if you want them.
If NASM fails to auto-configure, you may still be able to make it compile by using the fall-back Unix makefile Makefile.unx. Copy or rename that file to Makefile and try typing make. There is also a Makefile.unx file in the rdoff subdirectory.
Enhancements:
- adds 64-bit support "-f macho" output format "265th extern" bug in "-f obj" fixed(?)