/* This file is part of dvi2bitmap; see README for copyrights and licence */
// FIXME: at several points in the option processing below, I've noted
// sensible changes to the behaviour. These, and the corresponding
// documentation, should be changed come the next minor version update
// (but not between bugfix releases). At the same time, check that
// the documentation (SGML and roff), and the usage message at the
// bottom of this file, are consistent with the new options.
#include <config.h>
#include <vector>
#include <iostream>
#include <string>
#ifdef HAVE_CSTD_INCLUDE
# include <cstdio>
# include <cstdlib>
# include <cstdarg>
# include <cassert>
# include <cstring>
#else
# include <stdio.h> // for vsprintf
# include <stdlib.h>
# include <stdarg.h>
# include <assert.h>
# include <string.h>
#endif
#include <bitset>
#include <unistd.h> // for getsubopt
#include "getopt_long.h"
using STD::cout; // these are used multiple times
using STD::cerr;
using STD::endl;
using STD::strcmp;
using STD::exit;
#include "DviFile.h"
#include "PkFont.h"
#include "Bitmap.h"
#include "BitmapImage.h"
#include "verbosity.h"
#include "PageRange.h"
#include "Util.h"
#include "stringstream.h"
#include "version.h"
#ifdef ENABLE_KPATHSEA
#include "KarlPathSearcher.h"
#endif
#ifdef ENABLE_PNG
#include "PNGBitmap.h" // for PNGBitmap::libpng_version
#endif
#define DVI2BITMAPURL "http://www.astro.gla.ac.uk/users/norman/star/dvi2bitmap/"
// bitmap_info keeps together all the detailed information about the
// bitmap to be written.
struct bitmap_info {
bitmap_info()
: blur_bitmap(false), crop_bitmap(true),
make_transparent(true), bitmap_scale_factor(1),
ofile_pattern(""), ofile_name(""), ofile_type("") { }
bool blur_bitmap;
bool crop_bitmap;
bool make_transparent;
int bitmap_scale_factor;
string ofile_pattern;
string ofile_name;
string ofile_type;
};
static void process_dvi_file (DviFile *, bitmap_info&, int resolution,
PageRange&);
static bool process_special (DviFile *, string specialString,
Bitmap*, bitmap_info&);
static string substitute_ofn_pattern(string pattern, int pagenum);
static string get_ofn_pattern (string dviname);
static bool valid_ofile_pattern (string& patt);
static bool parse_boolean_string(char *s, bool *ok=0);
static void Usage (const char*);
//static void Usage (string msg);
static void Usage (bool);
static void show_help();
static char *progname;
/* Declare the getsubopt function. Do not attempt to check the
* HAVE_DECL_GETSUBOPT macro, as this will have been tested with a C
* compiler, and so we could incorrectly omit this declaration.
* [XXX is this bogus? It appears to work, but when was that ever a
* good argument.]
*/
extern "C" int getsubopt(char** options, char*const* tokens, char** value);
verbosities verbosity = normal;
int bitmapH = -1;
int bitmapW = -1;
// Make resolution global --
// several functions in here might reasonably want to see this.
int resolution = PkFont::dpiBase();// in pixels-per-inch
int oneInch = resolution; // one inch, including magnification
int main (int argc, char **argv)
{
string dviname;
bool dviname_is_seekable = true;
double magmag = 1.0; // magnification of file magnification factor
enum { font_show, font_incfound, font_cmds, font_long_display };
STD::bitset<8> show_font_info; // all zero
bitmap_info bm;
// Which elements of the DVI file should we process. process_dvi
// indicates that we should process the body of the DVI file, and
// process_preamble and process_postamble indicate that we should
// process the corresponding element.
enum { process_dvi, process_preamble, process_postamble };
STD::bitset<8> processing_;
processing_.set(process_dvi);
processing_.set(process_preamble);
processing_.set(process_postamble);
PageRange PR;
#define MM oneInch * 0.03937
struct {
char *name; double w; double h;
} papersizes[] = {
// Do these calculations in terms of the unit oneInch
// Defn of inch: 1m=39.37in => 1mm=0.03937in
{ (char*)"a4", 210 * MM, 297 * MM }, // 210x297mm
{ (char*)"a4l", 297 * MM, 210 * MM, }, // 297x210mm
{ (char*)"a5", 148 * MM, 210 * MM, }, // 148x210mm
{ (char*)"a5l", 210 * MM, 148 * MM, }, // 210x148mm
{ (char*)"usletter", 8.5*oneInch, 8.5*oneInch, }, // 8.5x11in
};
int npapersizes = sizeof(papersizes)/sizeof(papersizes[0]);
// option parsing with getopt_long
int optch;
extern char *optarg;
struct option long_options[] = {
{ (char*)"crop", 1, 0, 'c' },
{ (char*)"font-search", 1, 0, 'F' },
{ (char*)"debug", 1, 0, 'g' },
{ (char*)"font-gen", 1, 0, 'G' },
{ (char*)"height", 1, 0, 'h' },
{ (char*)"help", 0, 0, '?' },
{ (char*)"end-page", 1, 0, 'l' },
{ (char*)"magnification", 1, 0, 'm' },
{ (char*)"font-mode", 1, 0, 'M' },
{ (char*)"nodvi", 0, 0, 'n' },
{ (char*)"output", 1, 0, 'o' },
{ (char*)"start-page", 1, 0, 'p' },
{ (char*)"page-range", 1, 0, 'P' },
{ (char*)"query", 1, 0, 'Q' },
{ (char*)"resolution", 1, 0, 'r' },
{ (char*)"colours", 1, 0, 'R' },
{ (char*)"colors", 1, 0, 'R' }, // synonym
{ (char*)"scaledown", 1, 0, 's' },
{ (char*)"paper-size", 1, 0, 't' },
#define OPT_PIPE 1
{ (char*)"pipe", 0, 0, OPT_PIPE },
{ (char*)"output-type", 1, 0, 'T' },
{ (char*)"verbose", 1, 0, 'v' },
{ (char*)"version", 0, 0, 'V' },
{ (char*)"width", 1, 0, 'w' },
{ (char*)"process", 1, 0, 'X' },
{ 0, 0, 0, 0 }
};
// should generate this from long_options
char *short_options = (char*)"c:F:g:G:h:l:M:no:p:P:Q:r:R:s:t:T:v:Vw:X:";
progname = argv[0];
#ifdef ENABLE_KPATHSEA
KarlPathSearcher::setProgramName(progname);
#endif
BitmapImage::setInfo (BitmapImage::SOFTWAREVERSION,
new string(version_string));
BitmapImage::setInfo (BitmapImage::FURTHERINFO,
new string (DVI2BITMAPURL));
while ((optch = getopt_long(argc, argv, short_options, long_options, 0))
!= -1) {
switch (optch) {
case OPT_PIPE: // --pipe
dviname_is_seekable = false;
break;
case 'c': // --crop
{
// get dimension, and convert points to pixels.
// Note that the functionality here will vary
// depending on whether the magmag is set before
// or after this option, and it'll take no
// account of variations of the magnification
// within the DVI file.
char *options = optarg;
char *value;
char *tokens[] = {
(char*)"left", (char*)"right",
(char*)"top", (char*)"bottom", (char*)"all",
(char*)"absolute", (char*)"relative",
NULL
};
bool absCrop = false;
bool haveValue;
int cropmargin;
while (*options) {
int suboptch = ::getsubopt(&options, tokens, &value);
if (!value) // no option value: should be absolute/relative
haveValue = false;
else {
cropmargin
= static_cast<int>(magmag*STD::atof(value)/72.0
*resolution);
haveValue = true;
}
switch(suboptch) {
case 0: // left
if (!haveValue) Usage("no value for --crop=left");
Bitmap::cropDefault
(Bitmap::Left, cropmargin, absCrop);
break;
case 1: // right
if (!haveValue) Usage("no value for --crop=right");
Bitmap::cropDefault
(Bitmap::Right, cropmargin, absCrop);
break;
case 2: // top
if (!haveValue) Usage("no value for --crop=top");
Bitmap::cropDefault
(Bitmap::Top, cropmargin, absCrop);
break;
case 3: // bottom
if (!haveValue) Usage("no value for --crop=bottom");
Bitmap::cropDefault
(Bitmap::Bottom, cropmargin, absCrop);
break;
case 4: // all
if (!haveValue) Usage("no value for --crop=all");
if (absCrop) // don't want this!
Usage("can't have absolute crop for --crop=all");
Bitmap::cropDefault
(Bitmap::All, cropmargin, false);
break;
case 5: // absolute
if (haveValue) Usage("--crop=absolute takes no value");
absCrop = true;
break;
case 6: // relative
if (haveValue) Usage("--crop=relative takes no value");
absCrop = false;
break;
case -1:
Usage("unrecognised keyword for --crop");
break;
default:
throw DviBug("Impossible crop suboption %c", suboptch);
}
}
}
break;
case 'F': // --font-search
{
char *options = optarg;
char *value;
char *tokens[] = {
(char*)"path", (char*)"nopath",
(char*)"command", (char*)"nocommand",
(char*)"kpathsea", (char*)"nokpathsea",
(char*)"none",
NULL,
};
while (*options) {
int suboptch = getsubopt(&options, tokens, &value);
switch (suboptch) {
case 0: // path
PkFont::setFontSearchPath(value); // value may be 0
break;
case 1: // nopath
PkFont::setFontSearchPath(false);
break;
case 2: // command
PkFont::setFontSearchCommand(value); // value may be 0
break;
case 3: // nocommand
PkFont::setFontSearchCommand(false);
break;
case 4: // kpathsea
// any argument is permitted but ignored
PkFont::setFontSearchKpse(true);
break;
case 5: // nokpathsea
PkFont::setFontSearchKpse(false);
break;
case 6: // none
PkFont::setFontSearchPath(false);
PkFont::setFontSearchKpse(false);
PkFont::setFontSearchCommand(false);
break;
default:
Usage("bad keyword for --font-search");
}
}
}
break;
case 'G': // --font-gen
{
// Parse option:
// --font-gen=command[=blah]
// --font-gen=[boolean]
// Can't use getsubopt() since blah will contain spaces
bool boolok;
if (parse_boolean_string(optarg, &boolok)) {
PkFont::setFontgen(true);
} else if (boolok) {
// parse_boolean_string returned false,
// because it did find a valid boolean
PkFont::setFontgen(false);
} else if (STD::strncmp(optarg, "command", 7) == 0) {
char* cmd;
for (cmd=optarg; *cmd!='=' && *cmd!='\0'; cmd++)
; // find equals sign or eos
// cerr << "G: optarg=" << optarg << ", cmd="
// << (cmd==0 ? "<NULL>" : cmd) << endl;
if (*cmd == '\0') { // no cmd
// simply enable it, with default cmd
PkFont::setFontgen(true);
} else {
cmd++; // was pointing at '='
PkFont::setFontgenCommand(cmd);
}
} else {
Usage("Unrecognised argument to --font-gen");
}
}
break;
case 'g': // --debug
{
// !!! Additions/changes here should be mirrored
// in show_help() below
char *o = optarg;
verbosities debuglevel = debug;
for (; *o != '\0'; ++o) {
switch (*o)
{
case 'b': // debug bitmap
Bitmap::verbosity(debuglevel);
BitmapImage::verbosity(debuglevel);
// following is used only within Bitmap.cc
DviFilePosition::verbosity(debuglevel);
break;
case 'd': // debug DVI file
DviFile::verbosity(debuglevel);
break;
case 'g':
if (debuglevel == debug)
debuglevel = everything;
break;
case 'i': // debug input
InputByteStream::verbosity(debuglevel);
break;
case 'm': // debug main program
verbosity = debuglevel;
break;
case 'p': // debug PK file (and kpathsea)
PkFont::verbosity(debuglevel);
break;
case 'r': // debug rasterdata parsing
PkRasterdata::verbosity(debuglevel);
break;
case 'u': // debug utility functions
Util::verbosity(debuglevel);
break;
default:
{
char fmt[] = "bad flag (%c) for --debug";
char buf[sizeof(fmt)];
STD::sprintf(buf, fmt, *o);
Usage(buf);
break;
}
}
}
}
break;
case 'h': // --height
bitmapH = STD::atoi(optarg);
break;
case 'l': // --end-page
case 'p': // --start-page
case 'P': // --page-range
if (! PR.addSpec(optch, optarg))
Usage("improper page spec");
break;
case 'M': // --font-mode
PkFont::setMissingFontMode (optarg);
break;
case 'm': // --magnification
magmag = STD::atof (optarg);
break;
case 'n': // --nodvi
// don't actually process the DVI file
processing_.reset(process_dvi);
PkFont::setFontgen(false);
break;
case 'o': // --output
{
string a = optarg;
if (a.find('%') == string::npos)
bm.ofile_name = a;
else
bm.ofile_pattern = a;
break;
}
// case 'p', 'P': see 'l'
case 'Q': // --query
{
char *options = optarg;
char *value;
char *tokens[] = {
(char*)"missing-fonts", (char*)"f",
(char*)"all-fonts", (char*)"F",
(char*)"missing-fontgen", (char*)"g",
(char*)"all-fontgen", (char*)"G",
(char*)"bitmaps",
(char*)"paper",
(char*)"types",
NULL
};
while (*options) {
int suboptch = getsubopt(&options, tokens, &value);
if (value) // no values
Usage("--query keywords do not take values");
switch (suboptch)
{
case 0: // missing-fonts
show_font_info.set(font_show);
show_font_info.set(font_long_display);
PkFont::setFontgen(false);
break;
case 1: // f
show_font_info.set(font_show);
PkFont::setFontgen(false);
break;
case 2: // all-fonts
show_font_info.set(font_show);
show_font_info.set(font_incfound);
show_font_info.set(font_long_display);
PkFont::setFontgen(false);
break;
case 3: // F
show_font_info.set(font_show);
show_font_info.set(font_incfound);
PkFont::setFontgen(false);
break;
case 4: // missing-fontgen
show_font_info.set(font_show);
show_font_info.set(font_cmds);
show_font_info.set(font_long_display);
PkFont::setFontgen(false);
break;
case 5: // g
show_font_info.set(font_show);
show_font_info.set(font_cmds);
PkFont::setFontgen(false);
break;
case 6: // all-fontgen
show_font_info.set(font_show);
show_font_info.set(font_incfound);
show_font_info.set(font_cmds);
show_font_info.set(font_long_display);
PkFont::setFontgen(false);
break;
case 7: // G
show_font_info.set(font_show);
show_font_info.set(font_incfound);
show_font_info.set(font_cmds);
PkFont::setFontgen(false);
break;
case 8: // bitmaps
Bitmap::logBitmapInfo ("Qbitmaps ");
break;
case 9: // paper
cout << "Qpaper";
for (int i=0; i<npapersizes; i++)
cout << ' ' << papersizes[i].name;
cout << endl;
break;
case 10: // types
{
cout << "Qtypes ";
const char *ft
= BitmapImage::firstBitmapImageFormat();
cout << ft;
ft = BitmapImage::nextBitmapImageFormat();
while (ft != 0)
{
cout << ' ' << ft;
ft = BitmapImage::nextBitmapImageFormat();
}
cout << endl;
}
break;
case -1:
Usage("unknown query type");
break;
default:
throw DviBug("Impossible query suboption %c", suboptch);
}
}
}
break;
case 'r': // --resolution
PkFont::setResolution (STD::atoi(optarg));
resolution = PkFont::dpiBase();
break;
case 'R': // --colours, --colors
{
char *options = optarg;
char *value;
char *tokens[] = {
(char*)"foreground", (char*)"background", NULL
};
while (*options) {
int fb = getsubopt(&options, tokens, &value);
Bitmap::BitmapColour rgb;
if (!value)
Usage("no value given for --colours keyword");
if (Util::parseRGB(rgb, value))
Bitmap::setDefaultRGB (fb==0, &rgb);
else
Usage("bad colour spec");
}
}
break;
case 's': // --scaledown
bm.bitmap_scale_factor = STD::atoi (optarg);
break;
case 't': // --paper-size
// Note that the functionality here will vary
// depending on whether the magmag is set before
// or after this option, and it'll take no
// account of variations of the magnification
// within the DVI file.
int i;
for (i = 0; i<npapersizes; i++)
if (strcmp (optarg, papersizes[i].name) == 0)
{
bitmapH
= static_cast<int>(magmag*papersizes[i].h+0.5);
bitmapW
= static_cast<int>(magmag*papersizes[i].w+0.5);
break;
}
if (i == npapersizes)
cerr << "--paper-size=" << optarg
<< " not recognised. See --query=paper" << endl;
else
if (verbosity > normal)
cerr << "Papersize " << optarg
<< ": H=" << bitmapH
<< " W=" << bitmapW
<< endl;
break;
case 'T': // --output-type
bm.ofile_type = optarg;
if (! BitmapImage::supportedBitmapImage (bm.ofile_type))
{
bm.ofile_type
= BitmapImage::firstBitmapImageFormat();
cerr << "Unsupported image type "
<< optarg
<< ": using "
<< bm.ofile_type
<< " instead" << endl;
}
break;
case 'V': // --version
cout << version_string << endl << "Options:" << endl;
cout << "ENABLE_GIF " <<
#ifdef ENABLE_GIF
"yes"
#else
"no"
#endif
<< endl;
cout << "ENABLE_PNG " <<
#ifdef ENABLE_PNG
"yes" << endl << " libpng: " << PNGBitmap::version_string()
#else
"no"
#endif
<< endl;
cout << "ENABLE_KPATHSEA " <<
#ifdef ENABLE_KPATHSEA
"yes" << endl << " libkpathsea: " << KarlPathSearcher::version_string()
#else
"no"
#endif
<< endl;
#ifdef DEFAULT_TEXMFCNF
cout << " DEFAULT_TEXMFCNF=" << DEFAULT_TEXMFCNF << endl;
#endif
#ifdef FAKE_PROGNAME
cout << " FAKE_PROGNAME=" << FAKE_PROGNAME << endl;
#endif
#ifdef FONT_SEARCH_SCRIPT
cout << "FONT_SEARCH_SCRIPT " << FONT_SEARCH_SCRIPT << endl;
#endif
#ifdef FONT_GEN_TEMPLATE
cout << "FONT_GEN_TEMPLATE " << FONT_GEN_TEMPLATE << endl;
#else
cout << "Font generation disabled" << endl;
#endif
#ifdef DEFAULT_MFMODE
cout << " DEFAULT_MFMODE=" << DEFAULT_MFMODE << endl;
#endif
#ifdef DEFAULT_RESOLUTION
cout << " DEFAULT_RESOLUTION=" << DEFAULT_RESOLUTION << endl;
#endif
cout << version_string << endl;
processing_.reset(); // do no further processing
break;
case 'v': // --verbose
if (strcmp(optarg, "quiet") == 0)
verbosity = quiet;
else if (strcmp(optarg, "silent") == 0)
verbosity = silent;
else if (strcmp(optarg, "normal") == 0)
verbosity = normal;
else
Usage("bad verbosity keyword");
DviFile::verbosity(verbosity);
PkFont::verbosity(verbosity);
PkRasterdata::verbosity(verbosity);
InputByteStream::verbosity(verbosity);
Bitmap::verbosity(verbosity);
BitmapImage::verbosity(verbosity);
Util::verbosity(verbosity);
break;
case 'w': // --width
bitmapW = STD::atoi(optarg);
break;
case 'X': // --process
{
char *options = optarg;
char *value;
// There is no reason why the user should switch off
// process_preamble, so it is not (documented as)
// possible to do this below.
char *tokens[] = {
(char*)"dvi", // 0
(char*)"nodvi", // 1
(char*)"XXXpreamble", // 2
(char*)"XXXnopreamble", // 3
(char*)"postamble", // 4
(char*)"nopostamble", // 5
(char*)"blur", // 6
(char*)"noblur", // 7
(char*)"transparent", // 8
(char*)"notransparent", // 9
(char*)"crop", // 10
(char*)"nocrop", // 11
(char*)"options", // 12
NULL
};
while (*options) {
int suboptch = getsubopt(&options, tokens, &value);
if (value) // no values
Usage("--process keywords do not take values");
switch (suboptch)
{
case 0: // dvi
processing_.set(process_dvi);
break;
case 1: // nodvi
processing_.reset(process_dvi);
break;
case 2: // preamble
processing_.set(process_preamble);
break;
case 3: // nopreamble
processing_.reset(process_preamble);
break;
case 4: // postamble
processing_.set(process_postamble);
break;
case 5: // nopostamble
processing_.reset(process_postamble);
break;
case 12: // options-only
processing_.reset(); // reset everything
break;
case 6: // blur
bm.blur_bitmap = true;
break;
case 7: // noblur
bm.blur_bitmap = false;
break;
case 8: // transparent
bm.make_transparent = true;
break;
case 9: // notransparent
bm.make_transparent = false;
break;
case 10: // crop
bm.crop_bitmap = true;
break;
case 11: // nocrop
bm.crop_bitmap = false;
break;
case -1:
Usage("bad process keyword");
break;
default: // eh?
throw DviBug("Impossible process suboption %c", suboptch);
}
}
}
break;
case '?': // --help
show_help();
processing_.reset(); // clear all
break;
default:
Usage("unrecognised option");
}
}
if (processing_.none())
exit(0);
argc -= optind;
argv += optind;
if (argc != 1)
Usage("no DVI file specified");
dviname = *argv;
// Insist we have a DVI file specified.
if (dviname.length() == 0)
Usage("DVI filename has zero length!");
if (verbosity >= normal)
// Banner
cout << "This is " << version_string << endl;
if (bm.ofile_pattern.length() == 0)
bm.ofile_pattern = get_ofn_pattern(dviname == "-" ? "stdin" : dviname);
if (bm.ofile_pattern.length() == 0)
{
if (verbosity > silent)
cerr << "Error: Can't make output filename pattern from "
<< dviname << endl;
exit(1);
}
bool fonts_ok = true; // are there accumulated font errors?
try
{
DviFile *dvif = new DviFile(dviname, resolution, magmag,
processing_.test(process_postamble),
dviname_is_seekable);
if (dvif->eof())
{
if (verbosity > silent)
cerr << "Error: Can't open file " << dviname
<< " to read" << endl;
exit(1);
}
bool all_fonts_present = true; // are all expected fonts found?
if (dvif->haveReadPostamble()) {
all_fonts_present = true;
bool no_font_present = true; // are no expected fonts found?
const DviFile::FontSet* fontset = dvif->getFontSet();
for (DviFile::FontSet::const_iterator ci = fontset->begin();
ci != fontset->end();
++ci)
{
const PkFont *f = *ci;
if (f->loaded()) {
no_font_present = false;
if (verbosity > normal)
cerr << "dvi2bitmap: loaded font " << f->name()
<< endl;
}
else // flag at least one missing
all_fonts_present = false;
if (show_font_info.test(font_show)) {
bool fld = show_font_info.test(font_long_display);
if (show_font_info.test(font_cmds)) {
if (show_font_info.test(font_incfound)
|| !f->loaded()) {
// If f->loaded() is true, then we're here
// because FONT_INCFOUND was set, so indicate
// this in the output.
string cmd = f->fontgenCommand();
if (cmd.length() == 0)
throw DviError
("configuration problem: "
"I can't create a font-generation command");
cout << (f->loaded()
? (fld ? "Qall-fontgen " : "Qg ")
: (fld ? "Qmissing-fontgen " : "Qg "))
<< cmd
<< endl;
}
} else {
if (show_font_info.test(font_incfound)
|| !f->loaded()) {
// If f->loaded() is true, then we're here
// because FONT_INCFOUND was set, so indicate
// this in the output.
cout << (f->loaded()
? (fld ? "Qall-fonts " : "QF ")
: (fld ? "Qmissing-fonts " : "Qf "));
// write out font name, dpi, base-dpi, mag, MF mode
cout << f->name() << ' '
<< f->dpiBase() << ' '
<< f->dpiScaled() << ' '
<< f->magnification()
<< " localfont";
if (f->loaded())
{
string fn = f->fontFilename();
string unk = "unknown";
cout << ' ' << (fn.length() > 0 ? fn : unk);
}
cout << endl;
}
}
}
}
// Font loading is deemed `successful' if either all the
// fonts are loaded, or failing that, if it's not the case
// that _no_ fonts were loaded. Note that if there were
// _no_ fonts listed in the postamble (an odd DVI file,
// but not impossible), then both all_fonts_present and
// no_font_present are true, and this expression evaluates
// to true.
fonts_ok = all_fonts_present || !no_font_present;
} else {
// haven't read postamble
if (show_font_info.any()) {
cerr << "Font information requested, "
<< "but DVI postamble suppressed" << endl;
fonts_ok = false; // deem this an error
} else {
fonts_ok = true; // don't know any better
}
}
if (processing_.test(process_dvi)) {
if (fonts_ok) {
process_dvi_file(dvif, bm, resolution, PR);
} else {
// something's gone wrong -- we'll exit with an error below
if (verbosity > silent)
cerr << progname << ": no fonts found! Giving up" << endl;
}
} else {
// We were not processing the DVI file, just (presumably)
// the preamble and postamble. In this case, require that
// _all_ the fonts are present, but if fonts_ok was false
// for some other reason, keep it false.
fonts_ok = fonts_ok && all_fonts_present;
}
}
catch (DviBug& e)
{
if (verbosity > silent)
e.print();
}
catch (DviError& e)
{
if (verbosity > silent)
e.print();
}
// Exit status depends on the final value of fonts_ok. The
// result of the above logic is (should be) that we
// exit zero/success if (a) we were processing the DVI
// file normally and we found at least one font, or (b) we were
// just checking the preamble and we found _all_ the fonts.
exit(fonts_ok ? 0 : 1);
}
void process_dvi_file (DviFile *dvif, bitmap_info& b, int fileResolution,
PageRange& PR)
{
DviFileEvent *ev;
const PkFont *curr_font = 0;
int pagenum = 0;
Bitmap *bitmap = 0;
bool end_of_file = false;
size_t outcount = 0; // characters written to output current line
bool initialisedInch = false;
bool skipPage = false;
while (! end_of_file) {
if (skipPage)
ev = dvif->getEndOfPage();
else
ev = dvif->getEvent();
if (verbosity > debug)
ev->debug();
if (! initialisedInch)
{
// can't do this any earlier, as it's set in the preamble
oneInch = static_cast<int>(fileResolution * dvif->magnification());
initialisedInch = true;
}
if (DviFilePage *test = dynamic_cast<DviFilePage*>(ev))
{
DviFilePage &page = *test;
if (page.isStart)
{
pagenum++;
// Are we to print this page?
if (! PR.isSelected(pagenum, page.count))
skipPage = true;
else
{
// Request a big-enough bitmap; this bitmap is the `page'
// on which we `print' below. hSize and vSize are the
// width and height of the widest and tallest pages,
// as reported by the DVI file; however, the file doesn't
// report the offsets of these pages. Add a
// couple of inches to both and hope for the best.
// If we haven't read the postamble, then hSize()
// and vSize() return negative, so make a rough guess.
if (bitmap == 0) {
int bmw, bmh;
if (bitmapW > 0)
bmw = bitmapW;
else if (dvif->hSize() < 0)
bmw = 4*oneInch;
else
bmw = dvif->hSize() + 2*oneInch;
if (bitmapH > 0)
bmh = bitmapH;
else if (dvif->vSize() < 0)
bmh = 2*oneInch;
else
bmh = dvif->vSize() + oneInch;
bitmap = new Bitmap(bmw, bmh);
} else {
bitmap->clear();
}
if (verbosity > quiet)
{
int last, i;
// find last non-zero count
for (last=9; last>=0; last--)
if (page.count[last] != 0)
break;
SSTREAM pageind;
pageind << '[' << page.count[0];
for (i=1; i<=last; i++)
pageind << '.' << page.count[i];
pageind << '\0';
string ostr = SS_STRING(pageind);
if (outcount + ostr.length() > 78)
{
cout << endl;
outcount = 0;
}
cout << ostr;
outcount += ostr.length();
}
}
} else {
// end of page
if (skipPage) {
// nothing to do in this case except reset it
skipPage = false;
if (bitmap != 0 && !bitmap->empty())
// shouldn't happen, but just in case
bitmap->clear();
} else {
if (bitmap == 0)
throw DviBug ("bitmap uninitialised at page end");
else if (bitmap->empty()) {
if (verbosity > quiet)
cerr << "Warning: page " << pagenum
<< " empty: nothing written" << endl;
} else {
if (bitmap->overlaps() && verbosity > quiet) {
int *bb = bitmap->boundingBox();
cerr << "Warning: p." << pagenum
<< ": bitmap too big: occupies (" << bb[0] << ','
<< bb[1] << ")...(" << bb[2] << ','
<< bb[3] << "). Requested "
<< (bitmapW > 0 ? bitmapW : dvif->hSize()+oneInch)
<< 'x'
<< (bitmapH > 0 ? bitmapH : dvif->vSize()+oneInch)
<< endl;
}
if (b.crop_bitmap)
bitmap->crop();
if (b.blur_bitmap)
bitmap->blur();
if (b.make_transparent)
bitmap->setTransparent(true);
if (b.bitmap_scale_factor != 1)
bitmap->scaleDown (b.bitmap_scale_factor);
const string *fn = dvif->filename();
if (fn->length() != 0)
BitmapImage::setInfo (BitmapImage::INPUTFILENAME,
fn);
if (b.ofile_type.length() == 0)
{
b.ofile_type
= BitmapImage::firstBitmapImageFormat();
/* Keep this warning? If not, why not?
cerr << "Warning: unspecified image format. Selecting default ("
<< b.ofile_type << ")" << endl;
*/
}
if (b.ofile_name.length() == 0)
{
string output_filename
= substitute_ofn_pattern(b.ofile_pattern,
pagenum);
bitmap->write (output_filename, b.ofile_type);
}
else
bitmap->write (b.ofile_name, b.ofile_type);
}
b.ofile_name = "";
bitmap->clear();
if (verbosity > quiet)
{
cout << "] ";
outcount += 2;
}
}
}
}
else if (DviFileSetChar *test = dynamic_cast<DviFileSetChar*>(ev))
{
if (curr_font == 0 || bitmap == 0)
throw DviBug ("font or bitmap not initialised setting char");
DviFileSetChar& sc = *test;
PkGlyph& glyph = *curr_font->glyph(sc.charno());
if (verbosity > normal)
{
cerr << "glyph `" << glyph.characterChar()
<< "\' (" << glyph.characterCode() << ')';
if (verbosity > debug)
cerr << " size " << glyph.w() << 'x' << glyph.h()
<< " at position ("
<< dvif->currH() << ',' << dvif->currV()
<< ") plus oneInch=" << oneInch;
cerr << endl;
}
// calculate glyph positions, taking into account the
// offsets for the bitmaps, and the (1in,1in)=(72pt,72pt)
// = (resolution px,resolution px) offset of the TeX origin.
int x = dvif->currH(DviFile::unit_pixels) + glyph.hoff() + oneInch;
int y = dvif->currV(DviFile::unit_pixels) + glyph.voff() + oneInch;
bitmap->paint (x, y,
glyph.w(), glyph.h(),
glyph.bitmap());
}
else if (DviFileSetRule *test = dynamic_cast<DviFileSetRule*>(ev))
{
DviFileSetRule& sr = *test;
int x = dvif->currH() + oneInch;
int y = dvif->currV() + oneInch;
bitmap->rule (x,y,sr.w, sr.h);
}
else if (DviFileFontChange *test =
dynamic_cast<DviFileFontChange*>(ev))
{
DviFileFontChange& fc = *test;
const PkFont *f = fc.font;
if (f->loaded())
curr_font = f;
else {
f = dvif->getFallbackFont(f);
if (f != 0)
curr_font = f;
}
// curr_font unchanged if font-change was unsuccessful
} else if (DviFileSpecial* test =
dynamic_cast<DviFileSpecial*>(ev)) {
DviFileSpecial& special = *test;
if (!process_special (dvif,
special.specialString,
bitmap, b))
if (verbosity > quiet)
cerr << "Warning: unrecognised special: "
<< special.specialString
<< endl;
} else if (DviFilePostamble *post
= dynamic_cast<DviFilePostamble*>(ev)) {
if (verbosity >= debug)
post->debug();
end_of_file = true;
}
ev->release();
}
if (verbosity > quiet)
cout << endl;
}
// Process the special string, returning true on success.
bool process_special (DviFile *dvif, string specialString,
Bitmap* bitmap, bitmap_info& b)
{
string_list l = Util::tokenise_string (specialString);
string_list::const_iterator s = l.begin();
bool stringOK = false;
bool setDefault = false;
bool absolute = false;
// Define units used within specials. special_unit is used in the
// file, but if it's set with `default', then
// default_special_unit is set, too.
static DviFile::DviUnits default_special_unit = DviFile::unit_pt;
DviFile::DviUnits special_unit = default_special_unit;
if (verbosity > normal)
cerr << "dvi2bitmap: special default unit="
<< DviFile::unitString(special_unit) << endl;
if (*s == "dvi2bitmap") { // OK
stringOK = true;
s++;
while (s != l.end() && stringOK) {
if (*s == "default")
setDefault = true;
else if (*s == "absolute")
absolute = true;
else if (*s == "outputfile") {
s++;
if (s == l.end())
stringOK = false;
else {
if (setDefault) {
// Build up the ofile_pattern, making sure that
// we end up with precisely one %d in the result.
bool seenPageCount = false; // seen %d or #
b.ofile_pattern = "";
int imax = s->length()-1;
for (int i=0; i<=imax; i++) {
char c = (*s)[i];
if (seenPageCount) {
if (c == '%')
b.ofile_pattern += '%';
b.ofile_pattern += c;
} else {
// Support "#" for the page number,
// rather than just "%d", since it's
// tricky to get an unadorned percent
// into a TeX special, unless you play
// catcode tricks. Since it's also
// tricky to get just one "#" into the
// string, allow any number of them.
if (c == '#') {
b.ofile_pattern += '%';
b.ofile_pattern += 'd';
seenPageCount = true;
// absorb any number of # characters
while (i+1 <= imax && (*s)[i+1] == '#')
i++;
} else if (c == '%') {
i++;
if (i > imax && verbosity >= normal) {
cerr << "Warning: found descriptor %"
" at end of output string -- "
"replaced by %d" << endl;
} else if ((*s)[i] != 'd'
&& verbosity >= normal) {
cerr << "Warning: found descriptor %"
<< (*s)[i]
<< " in output string: "
"replaced by %d"
<< endl;
}
b.ofile_pattern += '%';
b.ofile_pattern += 'd';
seenPageCount = true;
} else {
b.ofile_pattern += c;
}
}
}
if (!seenPageCount) {
b.ofile_pattern += '%';
b.ofile_pattern += 'd';
}
assert(valid_ofile_pattern(b.ofile_pattern));
if (verbosity > normal)
cerr << "special: ofile_pattern="
<< b.ofile_pattern << endl;
} else {
b.ofile_name = *s;
}
}
} else if (*s == "crop") {
s++;
if (s == l.end()) { stringOK = false; break; }
string side_s = *s;
Bitmap::Margin side = Bitmap::All;
s++;
if (s == l.end()) { stringOK = false; break; }
int dimen = STD::atoi (s->c_str());
// scale from points to pixels
double npixels = DviFile::convertUnits(dimen,
special_unit,
DviFile::unit_pixels,
dvif);
// double npixels = dimen/72.0 // to inches
// * oneInch;
if (absolute)
{
// these dimensions are given w.r.t. an origin one inch
// from the left and top of the `paper'. Add this inch:
npixels += oneInch;
}
dimen = static_cast<int>(npixels);
if (side_s == "left")
side = Bitmap::Left;
else if (side_s == "right")
side = Bitmap::Right;
else if (side_s == "top")
side = Bitmap::Top;
else if (side_s == "bottom")
side = Bitmap::Bottom;
else if (side_s == "all")
side = Bitmap::All;
else
stringOK = false;
if (verbosity > normal)
cerr << "Crop " << side_s << '=' << dimen
<< (setDefault ? " default" : "")
<< (absolute ? " absolute" : "")
<< endl;
if (stringOK) {
if (side == Bitmap::All) {
if (setDefault)
for (int tside=0; tside<4; tside++)
Bitmap::cropDefault
(static_cast<Bitmap::Margin>(tside),
dimen, absolute);
for (int tside=0; tside<4; tside++)
bitmap->crop
(static_cast<Bitmap::Margin>(tside),
dimen, absolute);
} else {
if (setDefault)
Bitmap::cropDefault (side, dimen, absolute);
bitmap->crop (side, dimen, absolute);
}
}
} else if (*s == "imageformat") {
s++;
if (s == l.end())
stringOK = false;
else
{
if (BitmapImage::supportedBitmapImage (*s))
b.ofile_type = *s;
else
{
b.ofile_type = BitmapImage::firstBitmapImageFormat();
cerr << "Warning: imageformat " << *s
<< " not supported. Using " << b.ofile_type
<< " instead." << endl;
}
if (!setDefault && verbosity > quiet)
cerr << "Warning: imageformat special "
<< "should be prefixed with `default'" << endl;
}
} else if (*s == "foreground" || *s == "background") {
bool isfg = (*s == "foreground");
//Byte r, g, b;
Bitmap::BitmapColour rgb;
s++;
if (s == l.end()) { stringOK = false; break; }
rgb.red = static_cast<Byte>(STD::strtol (s->c_str(), 0, 0));
s++;
if (s == l.end()) { stringOK = false; break; }
rgb.green = static_cast<Byte>(STD::strtol (s->c_str(), 0, 0));
s++;
if (s == l.end()) { stringOK = false; break; }
rgb.blue = static_cast<Byte>(STD::strtol (s->c_str(), 0, 0));
if (stringOK)
{
if (verbosity > normal)
cerr << "Set "
<< (setDefault ? "(default) " : "")
<< (isfg ? "foreground" : "background")
<< " to "
<< static_cast<int>(rgb.red) << ','
<< static_cast<int>(rgb.green) << ','
<< static_cast<int>(rgb.blue) << endl;
if (setDefault)
Bitmap::setDefaultRGB (isfg, &rgb);
else
bitmap->setRGB (isfg, &rgb);
}
} else if (*s == "strut") {
int x = dvif->currH() + oneInch;
int y = dvif->currV() + oneInch;
int strut_lrtb[4];
for (int i=0; i<4; i++) {
s++;
if (s == l.end()) {
stringOK = false;
break;
}
strut_lrtb[i] = static_cast<int>
(DviFile::convertUnits(STD::strtod(s->c_str(),0),
special_unit,
DviFile::unit_pixels,
dvif)
+ 0.5); // round to nearest pixel
if (verbosity > normal)
cerr << "dvi2bitmap: strut "
<< *s << DviFile::unitString(special_unit)
<< " = " << strut_lrtb[i] << "px"
<< endl;
if (strut_lrtb[i] < 0) {
if (verbosity > silent)
cerr << "Strut must have positive dimensions"
<< endl;
stringOK = false;
}
}
if (stringOK) {
if (verbosity > normal)
cerr << "Strut: (" << x << ',' << y
<< ") (lrtb)=("
<< strut_lrtb[0] << ',' << strut_lrtb[1] << ','
<< strut_lrtb[2] << ',' << strut_lrtb[3]
<< ")px" << endl;
bitmap->strut (x, y,
strut_lrtb[0],
strut_lrtb[1],
strut_lrtb[2],
strut_lrtb[3]);
}
} else if (*s == "unit") {
s++;
if (s == l.end()) {
stringOK = false;
break; // JUMP OUT of special-processing loop
}
special_unit = DviFile::unitType(*s);
if (setDefault)
default_special_unit = special_unit;
} else if (*s == "mark") {
// Set the mark at the current position. This must
// match the offset calculations we make when setting
// characters while handling DviFileSetChar event above.
bitmap->mark
(new DviFilePosition
(dvif,
dvif->currH(DviFile::unit_pixels) + oneInch,
dvif->currV(DviFile::unit_pixels) + oneInch,
DviFile::unit_pixels));
} else
stringOK = false;
s++;
}
}
if (!stringOK && verbosity > quiet)
cerr << "Warning: unrecognised special: " << specialString << endl;
return stringOK;
}
/* The C++ <cstdio> definition does _not_ list snprintf as one of
* the members, though it is listed in the definition of <stdio.h>
* in the C standard. So different compilers seem to have different
* ideas of where it should be.
*/
#if HAVE_SNPRINTF
# if SNPRINTF_NAMESPACE == 3
# define SNPRINTF std::snprintf
# elif SNPRINTF_NAMESPACE == 2
# define SNPRINTF ::snprintf
# elif SNPRINTF_NAMESPACE == 1
# define SNPRINTF snprintf
# else
/* this case shouldn't really happen! */
# define SNPRINTF snprintf
extern "C" int snprintf(char *, int, const char*, ...);
# endif
#endif
string substitute_ofn_pattern(string pattern, int pagenum)
{
static char *buf = 0;
static int buflen = 50;
assert (valid_ofile_pattern(pattern));
if (buf == 0)
buf = new char[buflen];
#if HAVE_SNPRINTF
int wanted = SNPRINTF(buf, buflen, pattern.c_str(), pagenum);
if (wanted >= buflen) {
delete[] buf;
buflen = wanted+1; // include space for trailing null
buf = new char[buflen];
SNPRINTF(buf, buflen, pattern.c_str(), pagenum);
}
# undef SNPRINTF
#else
if (pattern.length() + 12 > buflen) {
// 12 is longer than the longest integer
delete[] buf;
buflen = pattern.length() + 20; // be generous
buf = new char[buflen];
}
STD::sprintf(buf, pattern.c_str(), pagenum);
#endif
return buf;
}
string get_ofn_pattern (string dviname)
{
// strip path and extension from filename
size_t string_index = dviname.rfind(FSPATH_SEP);
string dvirootname;
if (string_index == string::npos)
dvirootname = dviname;
else
dvirootname = dviname.substr(string_index+1);
string_index = dvirootname.rfind('.');
if (string_index != string::npos) // there is an extension -- skip it
dvirootname = dvirootname.substr(0,string_index);
return dvirootname + "-page%d";
}
// Validate an ofile_pattern, returning true if there is precisely one
// %-format in the string, and it is "%d" (format %% is harmless,
// so allow that, too). We're paranoid here, because this is input
// obtained from the user.
static bool valid_ofile_pattern (string& patt)
{
int nd = 0;
if (verbosity > normal)
cerr << "valid_ofile_pattern: examining :" << patt << endl;
for (string::const_iterator ci = patt.begin();
ci != patt.end();
++ci) {
char c = *ci;
if (c == '%') {
++ci;
if (ci == patt.end()) // unexpected
return false;
c = *ci;
switch (c) {
case '%': // OK, allow that
break;
case 'd': // the one we're after
nd++;
break;
default: // oops
return false;
}
}
}
return (nd == 1);
}
// Return true if the string is "yes", "true", "on",
// false if "no", "false", "off".
// Return false if it doesn't match anything.
// If ok is non-zero, then set it to true if one of the values did match,
// and false if none die
bool parse_boolean_string(char *s, bool *ok)
{
if (ok != 0) *ok = true;
if (strcmp(s, "yes") == 0) return true;
if (strcmp(s, "no") == 0) return false;
if (strcmp(s, "true") == 0) return true;
if (strcmp(s, "false") == 0) return false;
if (strcmp(s, "on") == 0) return true;
if (strcmp(s, "off") == 0) return false;
if (ok != 0) *ok = false;
return false;
}
void show_help()
{
Usage(false);
cerr << "Options:" << endl;
string helpstrings[] = {
" --colours, --colors=[foreground|background]=spec",
" RGB spec, as red/blue/green or #rrggbb",
" --crop=[left|right|top|bottom|all]=n Specify margin round output bitmap",
" --crop=[absolute|relative] Specify cropping of bitmap",
" --debug=[flags] Trace execution (see below)",
" --font-search=[path|command|kpathsea]=value",
" --font-search=[nopath|nocommand|nokpathsea|none]",
" Control font-searching",
" --font-gen=[boolean|command[=cmd]] Generate missing fonts?",
" --font-mode=mode MetaFont mode used when generating fonts",
" --height=size, --width=size Size of output bitmap",
" --help Show this help",
" --magnification=n Magnification parameter for DVI file",
" -n, --preamble-only Read only the DVI pre- and postamble",
" --output=filename-pattern Specify pattern for output bitmaps",
" --output-type=type Type of output bitmap, cf --query=types",
" --paper-size=string Preset bitmap size, cf --query=paper",
" --process=[no][dvi,postamble,blur,transparent,crop]|options",
" Processing to do",
" --query=[missing-fonts|missing-fontgen|all-fonts|all-fontgen|f|F|g|G]",
" Display missing/present fonts",
" --query=bitmaps Log bitmaps generated",
" --query=paper Show predefiend `paper' sizes",
" --query=types Show available bitmap formats",
" --resolution=n Output resolution, pixels-per-inch",
" --start-page=n, --end-page=n, --page-range=spec",
" Control which pages are processed",
" --scaledown=n Scale output bitmap down by n",
" --verbose=[normal|quiet|silent] Suppress chatter",
" -V, --version Show version and configuration info",
" (debug flags: b=bitmap, d=DVI file, g=everything, i=input, m=main",
" p=fonts and kpse, r=rasterdata, u=utilities)",
};
int nstrings = sizeof(helpstrings)/sizeof(helpstrings[0]);
for (int i=0; i<nstrings; i++)
cerr << helpstrings[i] << endl;
}
// void Usage (string msg)
// {
// cerr << "Error: " << msg << endl;
// Usage(true);
// }
void Usage (const char* msg)
{
cerr << "Error: " << msg << endl;
Usage(true);
}
void Usage (bool andExit)
{
cerr << "Usage: " << progname << " [flags...] filename" << endl;
#if 0
cerr << "Usage: " << progname << " [-b(h|w) size] [-bp a4|a4l|usletter...]" << endl <<
" [-[Cc][lrtb] size] [-fp PKpath ] [-fm mfmode] [-fg] [-fG]" << endl <<
" [-g[dpribmg]] [-l num] [-m magmag ] [-n[n]] [-o outfile-pattern]" << endl <<
" [-p num] [-pp ranges] [-P[bBtTcC]] [-q[q]] [-Q[FfGgtbp]]" << endl <<
" [-r resolution] [-R[fb] int,int,int] [-s scale-factor]" << endl <<
" [-t xbm"
#ifdef ENABLE_GIF
<< "|gif"
#endif
#ifdef ENABLE_PNG
<< "|png"
#endif
<< "] [-V]" << endl <<
" dvifile" << endl << endl <<
" -bh, -bw page height and width in pixels -bp bitmap <-- papersize" << endl <<
" -c crop margins left, right, top, bottom -C crop absolute" << endl <<
" -fp set font-path (DVI2BITMAP_PK_PATH) -fg switch off (-fG=on) fontgen" << endl <<
" -fm Metafont mode (must match -r) -r Metafont resolution" << endl <<
" -m DVI file magnification -s scale-down of bitmap" << endl <<
" -o set output file pattern, including %d -g debugging of sections" << endl <<
" -n only process DVI file preamble -nn only process-options" << endl <<
" -q switch off chatter and warnings -qq switch off errors, too" << endl <<
" -R set foreground/background colour (RGB) -V version+features then exit" << endl <<
" -l num, -p num, -pp ranges select pages to process (l--p, or ranges pp)" << endl <<
" -Q query: f=missing fonts, g=missing font commands (F, G=all fonts)" << endl <<
" t=supported output types, b=output bitmap names, p=paper sizes in -bp" << endl <<
" -P Processing: b=blur bitmap, t=set transparent, c=do cropping (BTC->off)" << endl;
#endif
if (andExit)
exit(1);
}