Free eps format software for linux

Time::Format is a Perl module for easy-to-use date/time formatting.

SYNOPSIS

use Time::Format qw(%time %strftime %manip);

$time{$format}
$time{$format, $unixtime}

print "Today is $time{yyyy/mm/dd}n";
print "Yesterday was $time{yyyy/mm/dd, time-24*60*60}n";
print "The time is $time{hh:mm:ss}n";
print "Another time is $time{H:mm am tz, $another_time}n";
print "Timestamp: $time{yyyymmdd.hhmmss.mmm}n";
%time also accepts Date::Manip strings and DateTime objects:
$dm = Date::Manip::ParseDate(last monday);
print "Last monday was $time{Month d, yyyy, $dm}";
$dt = DateTime->new (....);
print "Heres another date: $time{m/d/yy, $dt}";
It also accepts most ISO-8601 date/time strings:
$t = 2005/10/31T17:11:09; # date separator: / or - or .
$t = 2005-10-31 17.11.09; # in-between separator: T or _ or space
$t = 20051031_171109; # time separator: : or .
$t = 20051031171109; # separators may be omitted
$t = 2005/10/31; # date-only is okay
$t = 17:11:09; # time-only is okay
# But not:
$t = 20051031; # date-only without separators
$t = 171109; # time-only without separators
# ...because those look like epoch time numbers.
%strftime works like POSIXs strftime, if you like those %-formats.
$strftime{$format}
$strftime{$format, $unixtime}
$strftime{$format, $sec,$min,$hour, $mday,$mon,$year, $wday,$yday,$isdst}

print "POSIXish: $strftime{%A, %B %d, %Y, 0,0,0,12,11,95,2}n";
print "POSIXish: $strftime{%A, %B %d, %Y, 1054866251}n";
print "POSIXish: $strftime{%A, %B %d, %Y}n"; # current time
%manip works like Date::Manips UnixDate function.
$manip{$format};
$manip{$format, $when};

print "Date::Manip: $manip{%m/%d/%Y}n"; # current time
print "Date::Manip: $manip{%m/%d/%Y,last Tuesday}n";
These can also be used as standalone functions:
use Time::Format qw(time_format time_strftime time_manip);

print "Today is ", time_format(yyyy/mm/dd, $some_time), "n";
print "POSIXish: ", time_strftime(%A %B %d, %Y,$some_time), "n";
print "Date::Manip: ", time_manip(%m/%d/%Y,$some_time), "n";

This module creates global pseudovariables which format dates and times, according to formatting codes you pass to them in strings.

The %time formatting codes are designed to be easy to remember and use, and to take up just as many characters as the output time value whenever possible. For example, the four-digit year code is "yyyy", the three-letter month abbreviation is "Mon".

The nice thing about having a variable-like interface instead of function calls is that the values can be used inside of strings (as well as outside of strings in ordinary expressions). Dates are frequently used within strings (log messages, output, data records, etc.), so having the ability to interpolate them directly is handy.

Perl allows arbitrary expressions within curly braces of a hash, even when that hash is being interpolated into a string. This allows you to do computations on the fly while formatting times and inserting them into strings. See the "yesterday" example above.

The format strings are designed with programmers in mind. What do you need most frequently? 4-digit year, month, day, 24-based hour, minute, second -- usually with leading zeroes. These six are the easiest formats to use and remember in Time::Format: yyyy, mm, dd, hh, mm, ss. Variants on these formats follow a simple and consistent formula. This module is for everyone who is weary of trying to remember strftime(3)s arcane codes, or of endlessly writing $t[4]++; $t[5]+=1900 as you manually format times or dates.

Note that mm (and related codes) are used both for months and minutes. This is a feature. %time resolves the ambiguity by examining other nearby formatting codes. If its in the context of a year or a day, "month" is assumed. If in the context of an hour or a second, "minute" is assumed.

The format strings are not meant to encompass every date/time need ever conceived. But how often do you need the day of the year (strftimes %j) or the week number (strftimes %W)?

For capabilities that %time does not provide, %strftime provides an interface to POSIXs strftime, and %manip provides an interface to the Date::Manip modules UnixDate function.

If the companion module Time::Format_XS is also installed, Time::Format will detect and use it. This will result in a significant speed increase for %time and time_format.

AudioFormat is a simple, unobtrusive audio format converter for your GNOME desktop. The project integrates with Nautilus and the desktop-wide audio profile settings.

AudioFormat is available under the terms of the BSD License.

IFF Format Library provides header structures and utility functions for reading and writing data files in the Interchange Files.
The Interchange File Format is a simple structured binary file format consisting of sized and typed chunks of data, selectively readable without having to know the format of each chunk.
This functionality is similar to what XML provides for text documents, and the IFF format can indeed be viewed as a sort of a binary XML. IFFs extensibility is an excellent way of not breaking old applications when the file format changes, making it an excellent choice for your next applications data files.
The IFF is also the simplest and the smallest such data format, ensuring that your files consist of real data rather than overhead and that your code spends more time on real work than on parsing the data file. This library defines the IFF header structures and provides simple algorithms for directly writing many of your objects as chunks and containers.
Installation:
This library can be downloaded from SourceForge, as can its sole prerequisite:
libiff - The library source package.
uSTL - An STL implementation, required.
First, unpack and install uSTL, as described in its documentation. Unpack libiff and run ./configure; make install, which will install the library to /usr/local/lib and headers to /usr/local/include. ./configure --help lists available configuration options, in the usual autoconf fashion. The one thing to be aware of is that by default the library will not be completely conforming to EA85 specification. Why that is so, and why you should take the default options anyway, is discussed in detail in the next section. If you really want to use the original EA85 format, you can to pass --with-bigendian --with-2grain to configure.
Usage:
If you are using C++, chances are you already have an object-oriented design of some kind. You have a collection of objects, related to each other in some way, and you want to write them all to a file in some way. It is, of course, possible to just write them all to the file, one after the other, but that approach makes things difficult if you ever decide to change the structure of those objects, write more or fewer of them, or explain to other people how to read your format. Hence, it is desirable to create some kind of structure in the file, to be able to determine where each objects begins and ends, and what kind of object is where. When using an IFF format, youll make simple objects into chunks, and objects containing other objects into FORMs, LISTs, or CATs.
The first task is to make each of your objects readable and writable through uSTL streams. To do that youll need to define three methods, read, write, and stream_size, and create flow operator overrides with a STD_STREAMABLE macro. Here is a typical example:
#include < iff.h > // iff header includes ustl.h, but doesnt use the namespace.
using namespace ustl; // it is recommended to leave iff:: namespace on.
/// Stores players vital statistics.
class CPlayerStats {
public:
void read (istream& is);
void write (ostream& os) const;
size_t stream_size (void) const;
private:
uint16_t m_HP;
uint16_t m_MaxHP;
uint16_t m_Mana;
uint16_t m_MaxMana;
};
// Since the object is simple, and contains no other objects,
// well make it a simple chunk.
enum { // Define a chunk format for writing this object.
fmt_PlayerStats = IFF_FMT(S,T,A,T)
}; // In a hex editor youll see STAT at the beginning of the object
// making it easy to find when you want to hack something in it.
/// Reads the object from stream p is
void CPlayerStats::read (istream& is)
{
is >> m_HP >> m_MaxHP >> m_Mana >> m_MaxMana;
}
/// Writes the object to stream p os.
void CPlayerStats::write (ostream& os) const
{
os<<less