Free file maker 0.05 software for linux

File::SmartNL is a slurp text files no matter the New Line (NL) sequence.

SYNOPSIS

#####
# Subroutine Interface
#
use File::SmartNL qw(config fin fout smartnl);

$old_value = config( $option );
$old_value = config( $option => $new_value);
(@all_options) = config( );

$data = smart_nl($data);
$data = fin( $file_name, @options );
$char_count = fout($file_name, $data, @options);

######
# Object Interface
#
use File::SmartNL;

$default_options = File::SmartNL->default(@options);

$old_value = $default_options->config( $option );
$old_value = $default_options->config( $option => $new_value);
(@all_options) = $default_options->config( );

$data = File::SmartNL->smart_nl($data);
$data = File::SmartNL->fin( $file_name, @options );
$char_count = File::SmartNL->fout($file_name, $data, @options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

Different operating systems have different sequences for new-lines. Historically when computers where first being born, one of the mainstays was the teletype. The teletype understood ASCII. The teletype was an automated typewriter that would perform a carriage return when it received an ASCII Carriage Return (CR), 15, character and a new line when it received a Line Feed (LF), 12 character.

After some time came Unix. Unix had a tty driver that had a raw mode that sent data unprocessed to a teletype and a cooked mode that performed all kinds of translations and manipulations. Unix stored data internally using a single NL character at the ends of lines. The tty driver in the cooked mode would translate the New Line (NL) character to a CR,LF sequence. When driving a teletype, the physicall action of performing a carriage return took some time. By always putting the CR before the LF, the teletype would actually still be performing a carriage return when it received the LF and started a line feed.

After some time came DOS. Since the tty driver is actually one of the largest peices of code for UNIX and DOS needed to run in very cramp space, the DOS designers decided, that instead of writing a tailored down tty driver, they would stored a CR,LF in the internal memory. Data internally would be either text data or binary data.

Needless to say, after many years and many operating systems about every conceivable method of storing new lines may be found amoung the various operating systems. This greatly complicates moving files from one operating system to another operating system.

The smart NL methods in this package are designed to take any combination of CR and NL and translate it into the special NL seqeunce used on the site operating system. Thus, by using these methods, the messy problem of moving files between operating systems is mostly hidden in these methods. By using the fin and fout methods, text files may be freely exchanged between operating systems without any other processing.

The one thing not hidden is that the methods need to know if the data is text data or binary data. Normally, the assume the data is text and are overriden by setting the binary option.

Perl 5.6 introduced a built-in smart nl functionality as an IO discipline :crlf. See Programming Perl by Larry Wall, Tom Christiansen and Jon Orwant, page 754, Chapter 29: Functions, open function. For Perl 5.6 or above, the :crlf IO discipline my be preferable over the smart_nl method of this program module.

File::Where is a Perl module to find the absolute file for a program module; absolute dir for a repository.

SYNOPSIS

#######
# Subroutine interface
#
use File::Where qw(pm2require where where_dir where_file where_pm where_repository);

$program_module = is_module(@program_modules);
@program_modules = dir_pms( $dir );
@program_modules = program_modules( $dir, file_flag, @dirs);
$file = pm2require($pm);
@program_modules = repository_pms($repository);

$abs_file = where($relative_file);
$abs_file = where($relative_file, @path);

($abs_file, $inc_path, $rel_fle) = where($relative_file)
($abs_file, $inc_path, $rel_fle) = where($relative_file, @path);

$abs_dir = where($relative_dir, , nofile);
$abs_dir = where($relative_dir, @path, nofile);

($abs_dir, $inc_path, $rel_dir) = where($relative_dir, , nofile);
($abs_dir, $inc_path, $rel_dir) = where($relative_dir, @path, nofile);

$abs_dir = where_dir($relative_dir);
$abs_dir = where_dir($relative_dir, @path;
$abs_dir = where_dir($relative_dir, @path;

($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir);
($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir, @path);
($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir, @path);

$abs_file = where_file($relative_file);
$abs_file = where_file($relative_file, @path);
$abs_file = where_file($relative_file, @path);

($abs_file, $inc_path, $rel_fle) = where_file($relative_file)
($abs_file, $inc_path, $rel_fle) = where_file($relative_file, @path)
($abs_file, $inc_path, $rel_fle) = where_file($relative_file, @path)

$abs_file = where_pm($pm);
$abs_file = where_pm($pm, @path);
$abs_file = where_pm($pm, @path);

($abs_file, $inc_path, $require) = where_pm($pm);
($abs_file, $inc_path, $require) = where_pm($pm, @path);
($abs_file, $inc_path, $require) = where_pm($pm, @path);

$abs_dir = where_repository($repository);
$abs_dir = where_repository($repository, @path);
$abs_dir = where_repository($repository, @path);

($abs_dir, $inc_path, $rel_dir) = where_repository($repository);
($abs_dir, $inc_path, $rel_dir) = where_repository($repository, @path);
($abs_dir, $inc_path, $rel_dir) = where_repository($repository, @path);

#######
# Class interface
#
$program_module = File::Where->is_module(@program_modules);
@program_modules = File::Where->dir_pms( $dir );
@program_modules = File::Where->program_modules( $dir, file_flag, @dirs);
$file = File::Where->pm2require($pm);
@program_modules = File::Where->repository_pms($repository);


$abs_file = File::Where->where($relative_file);
$abs_file = File::Where->where($relative_file, @path);
$abs_dir = File::Where->where($relative_dir, , nofile);
$abs_dir = File::Where->where($relative_dir, @path, nofile);

($abs_file, $inc_path, $require) = File::Where->where($relative_file)
($abs_file, $inc_path, $require) = File::Where->where($relative_file, @path)
($abs_dir, $inc_path, $rel_dir) = File::Where->where($relative_dir, , nofile);
($abs_dir, $inc_path, $rel_dir) = File::Where->where($relative_dir, @path, nofile);

$abs_dir = File::Where->where_dir($relative_dir);
$abs_dir = File::Where->where_dir($relative_dir, @path;
$abs_dir = File::Where->where_dir($relative_dir, @path;

($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir, @path);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir, @path);

$abs_file = File::Where->where_file($relative_file);
$abs_file = File::Where->where_file($relative_file, @path);
$abs_file = File::Where->where_file($relative_file, @path);

($abs_file, $inc_path, $require) = File::Where->where_file($relative_file)
($abs_file, $inc_path, $require) = File::Where->where_file($relative_file, @path)
($abs_file, $inc_path, $require) = File::Where->where_file($relative_file, @path)

$abs_file = File::Where->where_pm($pm);
$abs_file = File::Where->where_pm($pm, @path);
$abs_file = File::Where->where_pm($pm, @path);

($abs_file, $inc_path, $require) = File::Where->where_pm($pm);
($abs_file, $inc_path, $require) = File::Where->where_pm($pm, @path);
($abs_file, $inc_path, $require) = File::Where->where_pm($pm, @path);

$abs_dir = File::Where->where_repository($repository);
$abs_dir = File::Where->where_repository($repository, @path);
$abs_dir = File::Where->where_repository($repository, @path);

($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository, @path);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository, @path);

From time to time, an program needs to know the abolute file for a program module that has not been loaded. The File::Where module provides methods to find this information. For loaded files, using the hash %INC may perform better than using the methods in this module.

Linux Video Maker is useful for DVD/(S)VCD structure generating, ready for record on CD/DVD. Its in fact graphics interface (GUI) for transcode, mplex, DVDAuthor and few other programs...

Using of these programs for this purpose is uncomfortable and sometimes difficult especially for beginners because it involves a lot of knowledge about DVD/(S)VCD technology and video converting.

Linux Video Maker binds funcionality of 8 exterior programs and prevents from making many mistakes mainly in conversion process which can take a lot of time as AVI files uses complicated video algorithms (DIVX).

Program doesnt contain yet too many advanced options but it allow generate a standard DVD/(S)VCD structure without any problems.

Program in 2 GUI languages: english and polish !

FaxRouter is a efax based application which converts a received fax to jpeg and sends it to you by email.

It will also keep your fax spool clean for you and can easily be configured to run from inittab and receive all faxes for you.

Patch Maker helps you manage multiple in-progress source code patches to software. Patch Maker remembers which files are part of which patch, and keeps them disentangled during the development process.
It speeds up common operations and housekeeping tasks, allowing you to focus on writing code. It is a command-line tool written in Perl, and so is usable on (at least) Windows, Linux and Mac OS X.
Enhancements:
- Initial SVN support was added to go with CVS.
- The configuration was moved to the .pmrc file in the home directory.
- Message and error printing were tidied up and standardized.

Aften project is a simple, open-source, A/52 (AC-3) audio encoder.
Main features:
- Implemented my own wav reader
- Converted the fixed-point algorithms to floating-point
- Rearranged the methods and structures
- Added stereo rematrixing (mid/side)
- Added short block MDCT and block switching
- Added VBR encoding mode
- Added variable bandwidth
- Added more complete WAV format support
- Added support for using the alternate bit stream syntax
- Created separate library and frontend
- Added input filters
Enhancements:
- Bit allocation speedups, a compile-time choice of using floats or doubles internally, an internal restructuring of MDCT functions, and bugfixes. quality=0 is now a valid setting.

Devel::LeakTrace is a Perl module to indicate where leaked variables are coming from.

SYNOPSIS

perl -MDevel::LeakTrace -e { my $foo; $foo = $foo }
leaked SV(0x528d0) from -e line 1
leaked SV(0x116a10) from -e line 1

Based heavily on Devel::Leak, Devel::LeakTrace uses the pluggable runops feature found in perl 5.6 and later in order to trace SV allocations of a running program.

At END time Devel::LeakTrace identifies any remaining variables, and reports on the lines in which the came into existence.

Note that by default state is first recorded during the INIT phase. As such the module will not pay attention to any scalars created during BEGIN time. This is intentional as symbol table aliasing is never released before the END times and this is most common in the implicit BEGIN blocks of use statements.