void setTextCoords ( int width, int height )
{
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
gluOrtho2D( 0.0f, SINGLE(width), 0.0f, SINGLE(height) );
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
glLoadIdentity();
glPixelStorei( GL_UNPACK_ROW_LENGTH, 1 );
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 );
glPushAttrib( GL_LIGHTING_BIT );
glDisable( GL_LIGHTING );
}
int
FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
const unsigned char **inptrp, const unsigned char *inend,
unsigned char **outbufstart, size_t *irreversible, int do_flush,
int consume_incomplete)
{
struct __gconv_step *next_step = step + 1;
struct __gconv_step_data *next_data = data + 1;
__gconv_fct fct = NULL;
int status;
if ((data->__flags & __GCONV_IS_LAST) == 0)
{
fct = next_step->__fct;
#ifdef PTR_DEMANGLE
if (next_step->__shlib_handle != NULL)
PTR_DEMANGLE (fct);
#endif
}
/* If the function is called with no input this means we have to reset
to the initial state. The possibly partly converted input is
dropped. */
if (__builtin_expect (do_flush, 0))
{
/* This should never happen during error handling. */
assert (outbufstart == NULL);
status = __GCONV_OK;
#ifdef EMIT_SHIFT_TO_INIT
if (do_flush == 1)
{
/* We preserve the initial values of the pointer variables. */
unsigned char *outbuf = data->__outbuf;
unsigned char *outstart = outbuf;
unsigned char *outend = data->__outbufend;
# ifdef PREPARE_LOOP
PREPARE_LOOP
# endif
# ifdef SAVE_RESET_STATE
SAVE_RESET_STATE (1);
# endif
/* Emit the escape sequence to reset the state. */
EMIT_SHIFT_TO_INIT;
/* Call the steps down the chain if there are any but only if we
successfully emitted the escape sequence. This should only
fail if the output buffer is full. If the input is invalid
it should be discarded since the user wants to start from a
clean state. */
if (status == __GCONV_OK)
{
if (data->__flags & __GCONV_IS_LAST)
/* Store information about how many bytes are available. */
data->__outbuf = outbuf;
else
{
/* Write out all output which was produced. */
if (outbuf > outstart)
{
const unsigned char *outerr = outstart;
int result;
result = DL_CALL_FCT (fct, (next_step, next_data,
&outerr, outbuf, NULL,
irreversible, 0,
consume_incomplete));
if (result != __GCONV_EMPTY_INPUT)
{
if (__builtin_expect (outerr != outbuf, 0))
{
/* We have a problem. Undo the conversion. */
outbuf = outstart;
/* Restore the state. */
# ifdef SAVE_RESET_STATE
SAVE_RESET_STATE (0);
# endif
}
/* Change the status. */
status = result;
}
}
if (status == __GCONV_OK)
/* Now flush the remaining steps. */
status = DL_CALL_FCT (fct, (next_step, next_data, NULL,
NULL, NULL, irreversible, 1,
consume_incomplete));
}
}
}
else
#endif
{
/* Clear the state object. There might be bytes in there from
previous calls with CONSUME_INCOMPLETE == 1. But don't emit
escape sequences. */
memset (data->__statep, '\0', sizeof (*data->__statep));
if (! (data->__flags & __GCONV_IS_LAST))
/* Now flush the remaining steps. */
status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
NULL, irreversible, do_flush,
consume_incomplete));
}
}
else
{
/* We preserve the initial values of the pointer variables. */
const unsigned char *inptr = *inptrp;
unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
? data->__outbuf : *outbufstart);
unsigned char *outend = data->__outbufend;
unsigned char *outstart;
/* This variable is used to count the number of characters we
actually converted. */
size_t lirreversible = 0;
size_t *lirreversiblep = irreversible ? &lirreversible : NULL;
/* The following assumes that encodings, which have a variable length
what might unalign a buffer even though it is a aligned in the
beginning, either don't have the minimal number of bytes as a divisor
of the maximum length or have a minimum length of 1. This is true
for all known and supported encodings.
We use && instead of || to combine the subexpression for the FROM
encoding and for the TO encoding, because usually one of them is
INTERNAL, for which the subexpression evaluates to 1, but INTERNAL
buffers are always aligned correctly. */
#define POSSIBLY_UNALIGNED \
(!defined _STRING_ARCH_unaligned \
&& (((FROM_LOOP_MIN_NEEDED_FROM != 1 \
&& FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0) \
&& (FROM_LOOP_MIN_NEEDED_TO != 1 \
&& FROM_LOOP_MAX_NEEDED_TO % FROM_LOOP_MIN_NEEDED_TO == 0)) \
|| ((TO_LOOP_MIN_NEEDED_FROM != 1 \
&& TO_LOOP_MAX_NEEDED_FROM % TO_LOOP_MIN_NEEDED_FROM == 0) \
&& (TO_LOOP_MIN_NEEDED_TO != 1 \
&& TO_LOOP_MAX_NEEDED_TO % TO_LOOP_MIN_NEEDED_TO == 0))))
#if POSSIBLY_UNALIGNED
int unaligned;
# define GEN_unaligned(name) GEN_unaligned2 (name)
# define GEN_unaligned2(name) name##_unaligned
#else
# define unaligned 0
#endif
#ifdef PREPARE_LOOP
PREPARE_LOOP
#endif
#if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
/* If the function is used to implement the mb*towc*() or wc*tomb*()
functions we must test whether any bytes from the last call are
stored in the `state' object. */
if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
|| (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
|| (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
&& consume_incomplete && (data->__statep->__count & 7) != 0)
{
/* Yep, we have some bytes left over. Process them now.
But this must not happen while we are called from an
error handler. */
assert (outbufstart == NULL);
# if FROM_LOOP_MAX_NEEDED_FROM > 1
if (TO_LOOP_MAX_NEEDED_FROM == 1 || FROM_DIRECTION)
status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
outend, lirreversiblep
EXTRA_LOOP_ARGS);
# endif
# if !ONE_DIRECTION
# if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
else
# endif
# if TO_LOOP_MAX_NEEDED_FROM > 1
status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
outend, lirreversiblep EXTRA_LOOP_ARGS);
# endif
# endif
if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
return status;
}
#endif
#if POSSIBLY_UNALIGNED
unaligned =
((FROM_DIRECTION
&& ((uintptr_t) inptr % FROM_LOOP_MIN_NEEDED_FROM != 0
|| ((data->__flags & __GCONV_IS_LAST)
&& (uintptr_t) outbuf % FROM_LOOP_MIN_NEEDED_TO != 0)))
|| (!FROM_DIRECTION
&& (((data->__flags & __GCONV_IS_LAST)
&& (uintptr_t) outbuf % TO_LOOP_MIN_NEEDED_TO != 0)
|| (uintptr_t) inptr % TO_LOOP_MIN_NEEDED_FROM != 0)));
#endif
while (1)
{
struct __gconv_trans_data *trans;
/* Remember the start value for this round. */
inptr = *inptrp;
/* The outbuf buffer is empty. */
outstart = outbuf;
#ifdef SAVE_RESET_STATE
SAVE_RESET_STATE (1);
#endif
if (__builtin_expect (!unaligned, 1))
{
if (FROM_DIRECTION)
/* Run the conversion loop. */
status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
lirreversiblep EXTRA_LOOP_ARGS);
else
/* Run the conversion loop. */
status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
lirreversiblep EXTRA_LOOP_ARGS);
}
#if POSSIBLY_UNALIGNED
else
{
if (FROM_DIRECTION)
/* Run the conversion loop. */
status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
&outbuf, outend,
lirreversiblep
EXTRA_LOOP_ARGS);
else
/* Run the conversion loop. */
status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
&outbuf, outend,
lirreversiblep
EXTRA_LOOP_ARGS);
}
#endif
/* If we were called as part of an error handling module we
don't do anything else here. */
if (__builtin_expect (outbufstart != NULL, 0))
{
*outbufstart = outbuf;
return status;
}
/* Give the transliteration module the chance to store the
original text and the result in case it needs a context. */
for (trans = data->__trans; trans != NULL; trans = trans->__next)
if (trans->__trans_context_fct != NULL)
DL_CALL_FCT (trans->__trans_context_fct,
(trans->__data, inptr, *inptrp, outstart, outbuf));
/* We finished one use of the loops. */
++data->__invocation_counter;
/* If this is the last step leave the loop, there is nothing
we can do. */
if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))
{
/* Store information about how many bytes are available. */
data->__outbuf = outbuf;
/* Remember how many non-identical characters we
converted in a irreversible way. */
*irreversible += lirreversible;
break;
}
/* Write out all output which was produced. */
if (__builtin_expect (outbuf > outstart, 1))
{
const unsigned char *outerr = data->__outbuf;
int result;
result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
outbuf, NULL, irreversible, 0,
consume_incomplete));
if (result != __GCONV_EMPTY_INPUT)
{
if (__builtin_expect (outerr != outbuf, 0))
{
#ifdef RESET_INPUT_BUFFER
RESET_INPUT_BUFFER;
#else
/* We have a problem in one of the functions below.
Undo the conversion upto the error point. */
size_t nstatus;
/* Reload the pointers. */
*inptrp = inptr;
outbuf = outstart;
/* Restore the state. */
# ifdef SAVE_RESET_STATE
SAVE_RESET_STATE (0);
# endif
if (__builtin_expect (!unaligned, 1))
{
if (FROM_DIRECTION)
/* Run the conversion loop. */
nstatus = FROM_LOOP (step, data, inptrp, inend,
&outbuf, outerr,
lirreversiblep
EXTRA_LOOP_ARGS);
else
/* Run the conversion loop. */
nstatus = TO_LOOP (step, data, inptrp, inend,
&outbuf, outerr,
lirreversiblep
EXTRA_LOOP_ARGS);
}
# if POSSIBLY_UNALIGNED
else
{
if (FROM_DIRECTION)
/* Run the conversion loop. */
nstatus = GEN_unaligned (FROM_LOOP) (step, data,
inptrp, inend,
&outbuf,
outerr,
lirreversiblep
EXTRA_LOOP_ARGS);
else
/* Run the conversion loop. */
nstatus = GEN_unaligned (TO_LOOP) (step, data,
inptrp, inend,
&outbuf, outerr,
lirreversiblep
EXTRA_LOOP_ARGS);
}
# endif
/* We must run out of output buffer space in this
rerun. */
assert (outbuf == outerr);
assert (nstatus == __GCONV_FULL_OUTPUT);
/* If we haven't consumed a single byte decrement
the invocation counter. */
if (__builtin_expect (outbuf == outstart, 0))
--data->__invocation_counter;
#endif /* reset input buffer */
}
/* Change the status. */
status = result;
}
else
/* All the output is consumed, we can make another run
if everything was ok. */
if (status == __GCONV_FULL_OUTPUT)
{
status = __GCONV_OK;
outbuf = data->__outbuf;
}
}
if (status != __GCONV_OK)
break;
/* Reset the output buffer pointer for the next round. */
outbuf = data->__outbuf;
}
#ifdef END_LOOP
END_LOOP
#endif
/* If we are supposed to consume all character store now all of the
remaining characters in the `state' object. */
#if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
|| (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
|| (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
&& __builtin_expect (consume_incomplete, 0)
&& status == __GCONV_INCOMPLETE_INPUT)
{
# ifdef STORE_REST
mbstate_t *state = data->__statep;
STORE_REST
# else
/* Make sure the remaining bytes fit into the state objects
buffer. */
assert (inend - *inptrp < 4);
size_t cnt;
for (cnt = 0; *inptrp < inend; ++cnt)
data->__statep->__value.__wchb[cnt] = *(*inptrp)++;
data->__statep->__count &= ~7;
data->__statep->__count |= cnt;
# endif
}
#endif
#undef unaligned
#undef POSSIBLY_UNALIGNED
}
return status;
}
/*{{{ main*/
int main(int argc, char *argv[])
{
/*{{{ variables*/
int x,y,f,size,err=0,usage=0,verbose=0,page,newpage,firstpage=1,c;
# ifdef MGR
int mgr=0;
# endif
int xres=DEFAULT_XRES,yres=DEFAULT_YRES,xinch=DEFAULT_XINCH,yinch=DEFAULT_YINCH,wide,high;
char ln[256],*s,*cmd=(char*)0;
FILE *fp;
/*}}} */
/*{{{ parse arguments*/
/*{{{ parse arguments*/
while ((c=getopt(argc,argv,
# ifdef MGR
"m"
# endif
"c:x:y:w:l:v"))!=EOF)
{
switch (c)
{
# ifdef MGR
/*{{{ m*/
case 'm':
{
mgr=1;
break;
}
/*}}} */
# endif
/*{{{ x*/
case 'x':
{
xres=atoi(optarg);
break;
}
/*}}} */
/*{{{ y*/
case 'y':
{
yres=atoi(optarg);
break;
}
/*}}} */
/*{{{ w*/
case 'w':
{
xinch=atoi(optarg);
break;
}
/*}}} */
/*{{{ l*/
case 'l':
{
yinch=atoi(optarg);
break;
}
/*}}} */
/*{{{ v*/
case 'v': verbose=1; break;
/*}}} */
/*{{{ c*/
case 'c':
{
cmd=optarg;
break;
}
/*}}} */
/*{{{ default*/
default: usage=1; break;
/*}}} */
}
}
if (optind!=argc) usage=1;
wide=xres*xinch;
high=yres*yinch;
/*}}} */
/*{{{ exit if err or usage*/
if (usage)
{
fprintf(stderr,"Usage: %s [-x dpi-x][-y dpi-y][-w inch-wide][-l inch-long][-c command][-v][-m]\n",argv[0]);
}
if (usage || err) exit(1);
/*}}} */
/*}}} */
bitmalloc(wide,high);
do
{
/*{{{ process one page*/
bitclear();
newpage=0;
while (fgets(ln,sizeof(ln),stdin)!=(char*)0 && !newpage)
{
s=ln; if (*s) *(s+strlen(s)-1)='\0';
do
{
switch (*s)
{
/*{{{ hn*/
case 'h': s++; x+=PRECISION(atoi(s)*xres)/BASIC_XRES; while (isdigit(*s)) s++; break;
/*}}} */
/*{{{ vn*/
case 'v': s++; y+=PRECISION(atoi(s)*yres)/BASIC_YRES; while (isdigit(*s)) s++; break;
/*}}} */
/*{{{ fn*/
case 'f':
{
s++;
f=atoi(s)-1;
if (mounted_font[f].raw==(hfont_raw*)0) mounted_font[f].raw=hfont_open(mounted_font[f].name);
while (isdigit(*s)) s++;
break;
}
/*}}} */
/*{{{ sn*/
case 's':
{
s++;
size=atoi(s);
while (isdigit(*s)) s++;
break;
}
/*}}} */
/*{{{ Hn*/
case 'H': s++; x=PRECISION(atoi(s)*xres)/BASIC_XRES; while (isdigit(*s)) s++; break;
/*}}} */
/*{{{ Vn*/
case 'V': s++; y=PRECISION(atoi(s)*yres)/BASIC_YRES; while (isdigit(*s)) s++; break;
/*}}} */
/*{{{ tstr*/
case 't':
{
if (mounted_font[f].size!=size)
{
if (mounted_font[f].scaled!=(hfont_scaled*)0) free(mounted_font[f].scaled);
mounted_font[f].scaled=(hfont_scaled*)0;
}
if (mounted_font[f].scaled==(hfont_scaled*)0)
{
mounted_font[f].scaled=hfont_scale(mounted_font[f].raw,xres,yres,size);
mounted_font[f].size=size;
}
hfont_print(mounted_font[f].scaled,&x,&y,0,s+1);
*s='\0';
break;
}
/*}}} */
/*{{{ un str*/
case 'u':
{
int add_width;
char r[2]=" ";
if (mounted_font[f].size!=size)
{
if (mounted_font[f].scaled!=(hfont_scaled*)0) free(mounted_font[f].scaled);
mounted_font[f].scaled=(hfont_scaled*)0;
}
if (mounted_font[f].scaled==(hfont_scaled*)0)
{
mounted_font[f].scaled=hfont_scale(mounted_font[f].raw,xres,yres,size);
mounted_font[f].size=size;
}
s++;
add_width=PRECISION(atoi(s)*xres)/BASIC_XRES; if (*s=='-') s++; while(isdigit(*s)) s++; s++;
while (*s && *s!='\n')
{
r[0]=*s;
hfont_print(mounted_font[f].scaled,&x,&y,0,r);
x+=add_width;
s++;
}
*s='\0';
break;
}
/*}}} */
/*{{{ Cxy*/
case 'C':
{
# define INT(x,y) ((x)<<8|(y))
int fixed_x=x,fixed_y=y;
char r[2]="?";
s++;
if (mounted_font[f].size!=size)
{
if (mounted_font[f].scaled!=(hfont_scaled*)0) free(mounted_font[f].scaled);
mounted_font[f].scaled=(hfont_scaled*)0;
}
if (mounted_font[f].scaled==(hfont_scaled*)0)
{
mounted_font[f].scaled=hfont_scale(mounted_font[f].raw,xres,yres,size);
mounted_font[f].size=size;
}
switch (INT(*s,*(s+1)))
{
case INT(':','A'): r[0]='\200'; break;
case INT(':','a'): r[0]='\201'; break;
case INT(':','O'): r[0]='\202'; break;
case INT(':','o'): r[0]='\203'; break;
case INT(':','U'): r[0]='\204'; break;
case INT(':','u'): r[0]='\205'; break;
case INT('s','s'): r[0]='\206'; break;
# include "special.c"
default: fprintf(stderr,"gropbm: Unknown special character \\(%c%c.\n",*s,*(s+1)); break;
}
hfont_print(mounted_font[f].scaled,&fixed_x,&fixed_y,0,r);
s+=2;
break;
# undef INT
}
/*}}} */
/*{{{ cx*/
case 'c':
{
char str[2];
int fixed_x=x,fixed_y=y;
s++;
str[0]=*s;
str[1]='\0';
s++;
hfont_print(mounted_font[f].scaled,&fixed_x,&fixed_y,0,str);
break;
}
/*}}} */
/*{{{ pn*/
case 'p':
{
s++;
y=0;
page=atoi(s);
if (!firstpage) newpage=1;
else
{
firstpage=0;
if (verbose) { fprintf(stderr,"[%d] ",page); fflush(stderr); }
}
while (isdigit(*s)) s++;
break;
}
/*}}} */
/*{{{ D?*/
case 'D':
{
s++;
switch (*s)
{
/*{{{ e*/
case 'e':
{
int dx,dy,rx,ry;
sscanf(s+1,"%d %d",&dx,&dy);
rx=PRECISION(dx*xres)/(2*BASIC_XRES);
ry=PRECISION(dy*yres)/(2*BASIC_YRES);
bitellipse(SINGLE(x+rx),SINGLE(y),SINGLE(rx),SINGLE(ry));
break;
}
/*}}} */
/*{{{ c*/
case 'c':
{
int d,rx,ry;
sscanf(s+1,"%d",&d);
rx=PRECISION(d*xres)/(2*BASIC_XRES);
ry=PRECISION(d*yres)/(2*BASIC_YRES);
bitellipse(SINGLE(x+rx),SINGLE(y),SINGLE(rx),SINGLE(ry));
break;
}
/*}}} */
/*{{{ l*/
case 'l':
{
int nx,ny;
sscanf(s+1,"%d %d",&nx,&ny);
nx=PRECISION(nx*xres)/BASIC_XRES;
ny=PRECISION(ny*yres)/BASIC_YRES;
bitline(SINGLE(x),SINGLE(y),SINGLE(x+nx),SINGLE(y+ny));
x+=nx;
y+=ny;
break;
}
/*}}} */
/*{{{ p*/
case 'p':
{
int nx,ny,ox=x,oy=y;
s++; while (isblank(*s)) s++;
do
{
nx=PRECISION(atoi(s)*xres)/BASIC_XRES; while (isdigit(*s) || *s=='-') s++; while (isblank(*s)) s++;
ny=PRECISION(atoi(s)*yres)/BASIC_YRES; while (isdigit(*s) || *s=='-') s++; while (isblank(*s)) s++;
bitline(SINGLE(ox),SINGLE(oy),SINGLE(ox+nx),SINGLE(oy+ny));
ox+=nx;
oy+=ny;
} while (*s);
bitline(SINGLE(ox),SINGLE(oy),SINGLE(x),SINGLE(y));
x+=nx;
y+=ny;
break;
}
/*}}} */
/*{{{ a*/
case 'a':
{
int dh1,dv1,dh2,dv2,a,b;
sscanf(s+1,"%d %d %d %d",&dh1,&dv1,&dh2,&dv2);
/* radius in troff units */
a=isqrt(PRECISION(dh2)*PRECISION(dh2)+PRECISION(dv2)*PRECISION(dv2));
/* y half axis in pixels */
b=(a*yres)/BASIC_YRES;
/* x half axis in pixels */
a=(a*xres)/BASIC_XRES;
dh1=PRECISION(dh1*xres)/BASIC_XRES;
dv1=PRECISION(dv1*yres)/BASIC_YRES;
dh2=PRECISION(dh2*xres)/BASIC_XRES;
dv2=PRECISION(dv2*yres)/BASIC_YRES;
bitarc(SINGLE(x+dh1),SINGLE(y+dv1),SINGLE(a),SINGLE(b),SINGLE(x),SINGLE(y),SINGLE(x+dh1+dh2),SINGLE(y+dv1+dv2));
x=x+dh1+dh2;
y=y+dv1+dv2;
break;
}
/*}}} */
}
*s='\0';
break;
}
/*}}} */
/*{{{ w*/
case 'w': s++; break;
/*}}} */
/*{{{ [0-9]*/
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
char str[2];
int fixed_x,fixed_y;
x+=PRECISION(((*s-'0')*10+(*(s+1))-'0')*xres)/BASIC_XRES; s+=2;
fixed_x=x; fixed_y=y;
str[0]=*s;
str[1]='\0';
s++;
hfont_print(mounted_font[f].scaled,&fixed_x,&fixed_y,0,str);
break;
}
/*}}} */
/*{{{ default*/
default: *s='\0';
/*}}} */
}
} while (*s);
}
/*{{{ output page*/
if (cmd!=(char*)0)
{
if ((fp=popen(cmd,"w"))==(FILE*)0)
{
fprintf(stderr,"%s: Can't execute %s: %s\n",argv[0],cmd,strerror(errno));
exit(1);
}
}
else fp=stdout;
# ifdef MGR
if (mgr) bitmgrwrite(fp); else
# endif
bitpbmwrite(fp);
if (cmd!=(char*)0) pclose(fp);
/*}}} */
if (newpage && !firstpage && verbose) { fprintf(stderr,"[%d] ",page); fflush(stderr); }
/*}}} */
} while (newpage);
bitfree();
exit(0);
}
