Free recursive software for linux

File::Copy::Recursive is a Perl extension for recursively copying files and directories.

SYNOPSIS

use File::Copy::Recursive qw(fcopy rcopy dircopy fmove rmove dirmove);

fcopy($orig,$new[,$buf]) or die $!;
rcopy($orig,$new[,$buf]) or die $!;
dircopy($orig,$new[,$buf]) or die $!;

fmove($orig,$new[,$buf]) or die $!;
rmove($orig,$new[,$buf]) or die $!;
dirmove($orig,$new[,$buf]) or die $!;

This module copies and moves directories recursively (or single files, well... singley) to an optional depth and attempts to preserve each file or directorys mode.

File::Attributes::Recursive module contains inherit file attributes from parent directories.
SYNOPSIS
Works like File::Attributes, but will recurse up the directory tree until a matching attribute is found.
EXPORT
None, by default. Specify the functions youd like to use as arguments to the module. :all means export everything.
FUNCTIONS
get_attribute_recursively($file, [$top], $attribute)
Returns the value of attribute $attribute. If $top is specified, then the search will terminate when the path no longer contains $top. (i.e. if $file is /foo/bar/baz/quux and $top is
get_attributes_recursively($file, [$top])
Returns a hash of key value pairs for all attributes that apply to $file. Only the closest attributes are returned. Given:
/a (a = yes, foo = bar)
/a/b (b = yes, foo = baz)
/a/b/c (c = yes)
get_attributes_recursively(/a/b/c, /a) will return:
(a => yes, b => yes, c => yes, foo => baz).
The foo => bar is masked by the "closer" foo => baz.
list_attributes_recursively($file, [$top])
Returns a list of attributes that are defined and apply to $file. Like keys get_attributes_recursively($file, [$top]), but faster.
NOTABLY ABSENT FUNCTIONS
unset_attribute_recursively
There are two possible ways for this function to behave -- either recurse until the attribute is removed, or recurse to top, removing the attribute at each level. The first doesnt make sense, and the second is dangerous. If you need this function, write it for the specific needs of your application; I think thats the safest thing to do.
(Note that rm refuses to rm .., so I think theres some precedent here.)
Enhancements:
- Perl

recls (recursive ls) is a platform-independent recursive search library.
This library came about as the first exemplar for my C/C++ Users Journal column, Positive Integration, which deals with issues of language integration between C/C++ and a host of other languages.
The library itself is implemented in C/C++, but presents a pure C API. It is compatible with UNIX and Win32 operating systems (though the FTP recursive searching is currently Win32-only), and is compatible with most popular C/C++ compilers, including:
- Borland (v5.51+)
- Comeau (v4.3.0.1+)
- Metrowerks CodeWarrior (v8.x+)
- Digital Mars (v8.40+)
- GCC (v3.2+)
- Intel (v7.0+)
- Microsoft Visual C++ (v6.0+)
Note that the base library requires components from the STLSoft libraries (which is another open-source library Im involved with).
In addition to the base library, there are mappings to several other languages/technologies. Currently these are
"regular" C++
- D
- COM
- .NET (C# and Managed C++)
- Perl
- Python
- Ruby
- STL
Enhancements:
- In the core, Recls_SearchFeedback() (and, hence, Recls_Search()) was fixed for the case when both searchRoot and pattern are NULL; general fixes were made for Unicode compilation.
- In recls/C++, fixes were made to namespace-exports for shims for Recls::Entry class.
- In recls/STL, general fixes were made for Unicode compilation.

import_checker checks Python programs for circular (or recursive) imports.

Python is a fine programming language. There is one horrendous thing with it though, that bites even the most experienced python programmers every now and then: the scope of variables.

Weve been taught to use the keyword global, and heartily do so. Still, problems occur when running into a "recursive import" problem.

Example:

### program A ###

import B

var = 0

if __name__ == __main__:
var = 10
B.doit()

### module B ###

import A

def doit():
print A.var

### end of example ###

Module B will see A.var having value 0, even though in program A we assigned it a value of 10. Python is right and it is not a python bug, but it is $#@! confusing and it is being caused by the recursive import; A imports B, and B imports A.

The import_checker.py is a tool that detects recursive imports.

This problem only occurs for global variables in modules.

The best way of solving the problem is to put var into a new module C,
and import C from both A and B.

myXTree provides an interface to an SQL tree.
myXTree is an interface to a SQL-tree. It is more about SQL-trees can learn in article SQL for Smarties and Relational Data Structures for Extensible Thesauri. This class allows to save the DOM-document in a SQL-tree and vice versa. For a choice of the data from a SQL-tree are used XPath expressions. Data reading of a SQL-tree can be carried out by two ways: by one SQL-query and recursive way.
The myXTree class use object PEAR::DB and object Document from package myDOM, which goes into package myXML.
Attached to realization of this class used a database mySQL and object PEAR::DB, but this, to regretting, does not do a class lightly bearable on other databases, because in class are used the specialized features mySQL. Because supposed, in the main, use of this class for little renewed data, then was select a tables type MyISAM (unsupported transaction).
A class does not support full features of XPath language. So far does not support an objects selection on namespace prefix; in base saved only the elements, text, CDATA and attributes; use of operator ??? (union) impossible only in recursive method; the XPath functions not implemented.
Enhancements:
- Error handling is completely advanced. PEAR style of error handling is extended with a new class "Error" (see file Error.php for details).
- The code became easier for understanding and for debugging.

regexxer project is a nifty search/replace tool featuring Perl-style regular expressions.

It features recursive search through directory trees and Perl-style regular expressions (using libpcre). The user interface is similar to the project-wide search/replace dialog in the Sniff+ IDE, but regexxer aims to surpass it.

The calltree command parses a collection of input files (assuming C syntax) and builds a graph that represents the static call structure of these files.

Calltree is similar to cflow(1) but unlike cflow(1), calltree is not based on lint(1).Calltree implements some more functions than cflow(1), but does not list the return types of the functions. This is because calltree includes an own C parser and thus may be used even on systems that dont have lint(1).

The disadvantage is that the C parser that is used by calltree is not completely correct and may not find all calls of a function. This is mainly true for calls that are done via function pointers.

Calltree is able to detect recursive function calls (e.g. functions that call themselves). Recursive function calls are marked with an ellipsis in the output.

DParser project is an simple but powerful tool for parsing. You can specify the form of the text to be parsed using a combination of regular expressions and grammar productions.
Because of the parsing technique (technically a scannerless GLR parser based on the Tomita algorithm) there are no restrictions.
The grammar can be ambiguous, right or left recursive, have any number of null productions, and because there is no seperate tokenizer, can include whitespace in terminals and have terminals which are prefixes of other terminals.
DParser handles not just well formed computer languages and data files, but just about any wacky situation that occurs in the real world.
Main features:
- Powerful GLR parsing
- Simple EBNF-style grammars and regular expression terminals
- Priorities and associativities for token and rules
- Built-in error recovery
- Speculative actions (for semantic disambiguation)
- Auto-building of parse tree (optionally)
- Final actions as you go, or on the complete parse tree
- Tree walkers and default actions (multi-pass compilation support)
- Symbol table built for ambiguous parsing
- Partial parses, recursive parsing, parsing starting with any non-terminal
- Whitespace can be specified as a subgrammar
- External (C call interface) tokenizers and external terminal scanners
- Good asymptotically efficiency
- Comes with ANSI-C, Python and Verilog grammars
- Comes with full source
- Portable C for easy compilation and linking
- BSD licence, so you can included it in your application without worrying about licensing
Enhancements:
- Removed call to exec in python interface (Brian Sabbey)
- Fix binary_op_left in python interface (Brian Sabbey)