#define banner "\nThis is hbf2gf (CJK Ver. 2.5)  (c) 1995 by Werner Lemberg\n\n" \
 \

#define TRUE 1
#define FALSE 0 \

#define STRING_LENGTH 255 \

#define FILE_NAME_LENGTH 1024 \
 \

#define GF_ID 131
#define PRE 247 \

#define header " hbf2gf output " \

#define BOC 67
#define BOC1 68
#define EOC 69 \

#define _2_16 65536.0
#define _2_20 1048576.0 \

#define XXX1 239
#define XXX2 240
#define XXX3 241
#define XXX4 242 \

#define YYY 243 \

#define POST 248 \

#define CHAR_LOC 245
#define CHAR_LOC0 246 \

#define POSTPOST 249
#define POSTPOST_ID 223 \

#define BLACK 1
#define WHITE 0 \

#define PIXEL_MAXVAL 255
#define SCALE 4096
#define HALFSCALE 2048 \

#define MAX_CHAR_SIZE 255 \

#define PAINT_(x)(x)
#define PAINT1 64
#define PAINT2 65
#define PAINT3 66 \

#define SKIP0 70
#define SKIP1 71
#define SKIP2 72
#define SKIP3 73 \

#define NEW_ROW_(x)((x)+74) \

#define NOOP 244 \

#define EXTENSION_LENGTH 8 \

#define GFTOPK_NAME "gftopk"
#define PLTOTF_NAME "pltotf" \

#define PRINTER_MIN_RES_X 50
#define PRINTER_MIN_RES_Y 50 \

#define VALID_SUBCODE 1 \

/*4:*/
#line 146 "hbf2gf.w"

/*6:*/
#line 205 "hbf2gf.w"

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "hbf.h"


/*:6*/
#line 147 "hbf2gf.w"
;
/*7:*/
#line 219 "hbf2gf.w"

void write_file(int);


/*:7*//*9:*/
#line 263 "hbf2gf.w"

void write_pre(void);


/*:9*//*12:*/
#line 340 "hbf2gf.w"

void write_data(void);


/*:12*//*16:*/
#line 448 "hbf2gf.w"

void write_post(void);


/*:16*//*21:*/
#line 591 "hbf2gf.w"

void fputl(long,FILE*);


/*:21*//*25:*/
#line 675 "hbf2gf.w"

void make_pixel_array(void);


/*:25*//*32:*/
#line 878 "hbf2gf.w"

#ifdef __GNUC__
inline
#endif
void read_row(unsigned char*);


/*:32*//*35:*/
#line 920 "hbf2gf.w"

#ifdef __GNUC__
inline
#endif
void write_row(unsigned char*);


/*:35*//*37:*/
#line 975 "hbf2gf.w"

void write_coding(void);


/*:37*//*41:*/
#line 1090 "hbf2gf.w"

void write_pl(void);


/*:41*//*44:*/
#line 1167 "hbf2gf.w"

void write_job(void);


/*:44*//*48:*/
#line 1375 "hbf2gf.w"

void read_config(void);


/*:48*//*56:*/
#line 1632 "hbf2gf.w"

int fsearch(char*);


/*:56*//*58:*/
#line 1695 "hbf2gf.w"

void config_error(char*);


/*:58*/
#line 148 "hbf2gf.w"
;
/*2:*/
#line 104 "hbf2gf.w"

int nmb_files= -1;
int unicode= FALSE;

char config_file[FILE_NAME_LENGTH+1];
char hbf_header[STRING_LENGTH+1];
char output_name[STRING_LENGTH+1];

FILE*config,*out;
HBF*hbf;

#ifdef msdos 
#define WRITE_BIN   "wb"
#define WRITE_TXT   "wt"
#define READ_BIN    "rb"
#define READ_TXT    "rt"
#else
#define WRITE_BIN   "w"
#define WRITE_TXT   "w"
#define READ_BIN    "r"
#define READ_TXT    "r"
#endif

int end_of_file= FALSE;


/*:2*//*11:*/
#line 305 "hbf2gf.w"

long char_adr[256];
long*char_adr_p;

int pk_offset_x;


double tfm_offset_x;
int pk_offset_y;

double tfm_offset_y;

int input_size_x;
int input_size_y;
int pk_output_size_x;

double tfm_output_size_x;
int pk_output_size_y;
double tfm_output_size_y;

double design_size= 10.0;
double target_size;
double magstep;

double mag_x;
double mag_y;

int empty_char;
int last_char;

int dot_count;



/*:11*//*15:*/
#line 425 "hbf2gf.w"

char coding[STRING_LENGTH+1];
char comment[STRING_LENGTH+1];

unsigned long checksum;

long pk_total_min_x;
long pk_total_max_x;
long pk_total_min_y;
long pk_total_max_y;

int dpi_x= 300;
int dpi_y= 300;
double ppp_x;
double ppp_y;


/*:15*//*23:*/
#line 631 "hbf2gf.w"

HBF_CHAR code;
const unsigned char*bitmap;

unsigned char*bP;

unsigned char out_char[MAX_CHAR_SIZE*MAX_CHAR_SIZE+1];

unsigned char*out_char_p;

unsigned char pixelrow[MAX_CHAR_SIZE];
unsigned char temp_pixelrow[MAX_CHAR_SIZE];
unsigned char new_pixelrow[MAX_CHAR_SIZE];

long grayrow[MAX_CHAR_SIZE];

long s_mag_x,s_mag_y;


/*:23*//*34:*/
#line 915 "hbf2gf.w"

int threshold= 128;


/*:34*//*43:*/
#line 1155 "hbf2gf.w"

char job_extension[EXTENSION_LENGTH+1];
char rm_command[STRING_LENGTH+1];
char cp_command[STRING_LENGTH+1];
char pk_directory[STRING_LENGTH+1];
char tfm_directory[STRING_LENGTH+1];

int long_extension= TRUE;
int tfm_files= TRUE;


/*:43*//*47:*/
#line 1370 "hbf2gf.w"

char Buffer[STRING_LENGTH+1];


/*:47*//*52:*/
#line 1577 "hbf2gf.w"

HBF_CHAR min_char,max_char;


/*:52*//*54:*/
#line 1602 "hbf2gf.w"

char b2_codes[256];
unsigned char min_2_byte,max_2_byte;


/*:54*/
#line 149 "hbf2gf.w"
;


int main(argc,argv)
int argc;
char*argv[];

{if(argc!=2)
{fprintf(stderr,"\nUsage: hbf2gf configurationfile\n");
exit(-1);
}

printf(banner);

strncpy(config_file,argv[1],FILE_NAME_LENGTH);
config_file[FILE_NAME_LENGTH]= '\0';

read_config();

/*24:*/
#line 651 "hbf2gf.w"

{int col;


for(col= 0;col<input_size_x;++col)
grayrow[col]= HALFSCALE;

code= (min_char&0xFF00)+min_2_byte;

s_mag_x= mag_x*magstep*SCALE;
s_mag_y= mag_y*magstep*SCALE;
}


/*:24*/
#line 168 "hbf2gf.w"
;
/*5:*/
#line 187 "hbf2gf.w"

{int i,j,max_numb;


i= (unicode==TRUE?(min_char>>8):1);
if(nmb_files==-1)
max_numb= (unicode==TRUE?0x100:100);
else
max_numb= nmb_files;

for(j= 0;(j<max_numb)&&!end_of_file;i++,j++)
write_file(i);

nmb_files= j;
}


/*:5*/
#line 169 "hbf2gf.w"
;

hbfClose(hbf);

if(tfm_files)
write_pl();
write_job();

return 0;
}


/*:4*//*8:*/
#line 224 "hbf2gf.w"

void write_file(file_number)
int file_number;

{char output_file[FILE_NAME_LENGTH+1];


if(unicode)
sprintf(output_file,"%s%02x.gf",output_name,file_number);
else
sprintf(output_file,"%s%02i.gf",output_name,file_number);
if(!(out= fopen(output_file,WRITE_BIN)))
{fprintf(stderr,"Couldn't open %s\n",output_file);
exit(-1);
}
printf("Writing %s ",output_file);

write_pre();
write_data();
write_post();

printf("\n");

fclose(out);
}


/*:8*//*10:*/
#line 270 "hbf2gf.w"

void write_pre(void)
{char out_s[40],s[20];
time_t secs_now;
struct tm*time_now;


strcpy(out_s,header);

secs_now= time(NULL);
time_now= localtime(&secs_now);
strftime(s,20,"%Y.%m.%d:%H.%M",time_now);
strcat(out_s,s);

fputc(PRE,out);
fputc(GF_ID,out);
fputc(strlen(out_s),out);
fputs(out_s,out);
}


/*:10*//*13:*/
#line 345 "hbf2gf.w"

void write_data(void)
{dot_count= 0;
char_adr_p= char_adr;

for(last_char= 0;(last_char<256)&&!end_of_file;last_char++)
/*14:*/
#line 370 "hbf2gf.w"

{if(dot_count++%10==0)
{printf(".");
fflush(stdout);
}

empty_char= FALSE;
make_pixel_array();
if(end_of_file)
return;

*char_adr_p= ftell(out);
char_adr_p++;

if(empty_char)
{fputc(BOC1,out);
fputc((unsigned char)last_char,out);
fputc(0,out);
fputc(0,out);
fputc(0,out);
fputc(0,out);
fputc(EOC,out);
}
else
{fputc(BOC,out);
fputl(last_char,out);
fputl(-1L,out);
fputl(pk_offset_x,out);
fputl(pk_output_size_x+pk_offset_x,out);
fputl(pk_offset_y,out);
fputl(pk_output_size_y+pk_offset_y,out);

write_coding();

fputc(EOC,out);
}
}


/*:14*/
#line 351 "hbf2gf.w"
;
}


/*:13*//*17:*/
#line 453 "hbf2gf.w"

void write_post(void)
{long special_adr;
long post_adr;

long designsize= design_size*_2_20;

int pk_dx;
long tfm_width;

int i;
long temp;


ppp_x= dpi_x/72.27*magstep;
ppp_y= dpi_y/72.27*magstep;

pk_total_min_x= pk_offset_x;
pk_total_max_x= pk_output_size_x+2*pk_offset_x;
pk_total_min_y= pk_offset_y;
pk_total_max_y= pk_output_size_y+pk_offset_y;

pk_dx= pk_total_max_x;
tfm_width= (tfm_output_size_x+2*tfm_offset_x)*_2_20;


/*18:*/
#line 498 "hbf2gf.w"

special_adr= ftell(out);

if(*coding)
{fputc(XXX1,out);
fputc(strlen(coding),out);
fputs(coding,out);
}

if(*comment)
{fputc(XXX1,out);
fputc(strlen(comment),out);
fputs(comment,out);
}


/*:18*/
#line 479 "hbf2gf.w"
;
/*19:*/
#line 527 "hbf2gf.w"

post_adr= ftell(out);
fputc(POST,out);
fputl(special_adr,out);

fputl(designsize,out);
fputl(checksum,out);
fputl(ppp_x*_2_16,out);
fputl(ppp_y*_2_16,out);
fputl(pk_total_min_x,out);
fputl(pk_total_max_x,out);
fputl(pk_total_min_y,out);
fputl(pk_total_max_y,out);

char_adr_p= char_adr;

if(pk_dx<256)
{for(i= 0;i<last_char;i++)
{fputc(CHAR_LOC0,out);
fputc(i,out);
fputc(pk_dx,out);
fputl(tfm_width,out);
fputl(*char_adr_p++,out);
}
}
else
{for(i= 0;i<last_char;i++)
{fputc(CHAR_LOC,out);
fputc(i,out);
fputl(pk_dx*_2_16,out);
fputl(0,out);
fputl(tfm_width,out);
fputl(*char_adr_p++,out);
}
}


/*:19*/
#line 480 "hbf2gf.w"
;
/*20:*/
#line 578 "hbf2gf.w"

fputc(POSTPOST,out);
fputl(post_adr,out);
fputc(GF_ID,out);
temp= ftell(out);
i= (int)(temp%4)+4;
while(i--)
fputc(POSTPOST_ID,out);


/*:20*/
#line 481 "hbf2gf.w"
;
}


/*:17*//*22:*/
#line 596 "hbf2gf.w"

void fputl(num,f)
long num;
FILE*f;

{fputc(num>>24,f);
fputc(num>>16,f);
fputc(num>>8,f);
fputc(num,f);
}


/*:22*//*26:*/
#line 680 "hbf2gf.w"

void make_pixel_array(void)
{unsigned char*prP;
unsigned char*temp_prP;
unsigned char*new_prP;
long*grP;

register unsigned char*xP;
register unsigned char*nxP;

register int row,col;
int rows_read= 0;
register int need_to_read_row= 1;

long frac_row_to_fill= SCALE;
long frac_row_left= s_mag_y;

int no_code= FALSE;


prP= pixelrow;
temp_prP= temp_pixelrow;
new_prP= new_pixelrow;
grP= grayrow;
out_char_p= out_char;

again:
if(b2_codes[code&0xFF])
{bitmap= hbfGetBitmap(hbf,code);
bP= (unsigned char*)bitmap;


if(!bitmap)
empty_char= TRUE;
else
{/*27:*/
#line 738 "hbf2gf.w"

if(pk_output_size_y==input_size_y)
temp_prP= prP;

for(row= 0;row<pk_output_size_y;++row)
{/*28:*/
#line 750 "hbf2gf.w"

if(pk_output_size_y==input_size_y)

read_row(prP);
else
{while(frac_row_left<frac_row_to_fill)
{if(need_to_read_row)
if(rows_read<input_size_y)
{read_row(prP);
++rows_read;
}

for(col= 0,xP= prP;col<input_size_x;++col,++xP)
grP[col]+= frac_row_left*(*xP);

frac_row_to_fill-= frac_row_left;
frac_row_left= s_mag_y;
need_to_read_row= 1;
}

/*29:*/
#line 777 "hbf2gf.w"

if(need_to_read_row)
if(rows_read<input_size_y)
{read_row(prP);
++rows_read;
need_to_read_row= 0;
}

for(col= 0,xP= prP,nxP= temp_prP;
col<input_size_x;++col,++xP,++nxP)
{register long g;


g= grP[col]+frac_row_to_fill*(*xP);
g/= SCALE;
if(g>PIXEL_MAXVAL)
g= PIXEL_MAXVAL;

*nxP= g;
grP[col]= HALFSCALE;
}

frac_row_left-= frac_row_to_fill;
if(frac_row_left==0)
{frac_row_left= s_mag_y;
need_to_read_row= 1;
}
frac_row_to_fill= SCALE;


/*:29*/
#line 770 "hbf2gf.w"
;
}


/*:28*/
#line 743 "hbf2gf.w"
;
/*30:*/
#line 809 "hbf2gf.w"

if(pk_output_size_x==input_size_x)

write_row(temp_prP);
else
{register long g= HALFSCALE;
register long frac_col_to_fill= SCALE;
register long frac_col_left;
register int need_col= 0;


nxP= new_prP;

for(col= 0,xP= temp_prP;col<input_size_x;++col,++xP)
{frac_col_left= s_mag_x;
while(frac_col_left>=frac_col_to_fill)
{if(need_col)
{++nxP;
g= HALFSCALE;
}

g+= frac_col_to_fill*(*xP);
g/= SCALE;
if(g>PIXEL_MAXVAL)
g= PIXEL_MAXVAL;

*nxP= g;
frac_col_left-= frac_col_to_fill;
frac_col_to_fill= SCALE;
need_col= 1;
}

if(frac_col_left>0)
{if(need_col)
{++nxP;
g= HALFSCALE;
need_col= 0;
}

g+= frac_col_left*(*xP);
frac_col_to_fill-= frac_col_left;
}
}

/*31:*/
#line 858 "hbf2gf.w"

if(frac_col_to_fill>0)
{--xP;
g+= frac_col_to_fill*(*xP);
}

if(!need_col)
{g/= SCALE;
if(g>PIXEL_MAXVAL)
g= PIXEL_MAXVAL;
*nxP= g;
}

write_row(new_prP);


/*:31*/
#line 853 "hbf2gf.w"
;
}


/*:30*/
#line 745 "hbf2gf.w"
;
}


/*:27*/
#line 715 "hbf2gf.w"
;
}
}
else
no_code= TRUE;

if((code&0xFF)==max_2_byte)
code+= 0xFF-(max_2_byte-min_2_byte);
if(code>=max_char)
{end_of_file= TRUE;
return;
}

code++;

if(no_code)
{no_code= FALSE;
goto again;
}
}


/*:26*//*33:*/
#line 886 "hbf2gf.w"

#ifdef __GNUC__
inline
#endif
void read_row(pixelrow)
unsigned char*pixelrow;

{register int col,bitshift;
register unsigned char*xP;
register unsigned char item= 0;


bitshift= -1;

for(col= 0,xP= pixelrow;col<input_size_x;++col,++xP)
{if(bitshift==-1)
{item= *(bP++);
bitshift= 7;
}
*xP= ((item>>bitshift)&1)==1?0:PIXEL_MAXVAL;
--bitshift;
}
}


/*:33*//*36:*/
#line 928 "hbf2gf.w"

#ifdef __GNUC__
inline
#endif
void write_row(pixelrow)
unsigned char*pixelrow;

{register int col;
register unsigned char*xP;


for(col= 0,xP= pixelrow;col<pk_output_size_x;++col,++xP)
*(out_char_p++)= (*xP>=threshold)?0:1;

}


/*:36*//*38:*/
#line 983 "hbf2gf.w"

void write_coding(void)
{register int count,skip;
register unsigned char paint;
register int x,y;
register unsigned char*cp;


x= 0;
y= 0;
cp= out_char+y*pk_output_size_x+x;
count= skip= 0;
paint= WHITE;
goto start;

while(y<pk_output_size_y)
{/*39:*/
#line 1008 "hbf2gf.w"

count= 0;
x= 0;
cp= out_char+y*pk_output_size_x+x;

while(x<pk_output_size_x)
{if(*cp==paint)
count++;
else
{if(skip==0)
if(count<=164)
fputc(NEW_ROW_(count),out);
else
{fputc(NEW_ROW_(0),out);
fputc(PAINT_(0),out);
fputc(PAINT1,out);
fputc(count,out);
}
else
{if(skip==1)
fputc(SKIP0,out);
else
{fputc(SKIP1,out);
fputc(skip,out);
}
skip= 0;
if(count<64)
fputc(PAINT_(count),out);
else
{fputc(PAINT1,out);
fputc(count,out);
}
}
count= 0;
paint= BLACK;
break;
}
x++;
cp++;
}
if(x>=pk_output_size_x)
{skip++;
y++;
continue;
}


/*:39*/
#line 999 "hbf2gf.w"
;
start:
/*40:*/
#line 1056 "hbf2gf.w"

while(x<pk_output_size_x)
{if(*cp==paint)
count++;
else
{if(count<64)
fputc(PAINT_(count),out);
else
{fputc(PAINT1,out);
fputc(count,out);
}
count= 1;
paint= BLACK-paint;
}
x++;
cp++;
}
if(paint==BLACK)
{if(count<64)
fputc(PAINT_(count),out);
else
{fputc(PAINT1,out);
fputc(count,out);
}
paint= WHITE;
}


/*:40*/
#line 1001 "hbf2gf.w"
;
y++;
}
}


/*:38*//*42:*/
#line 1095 "hbf2gf.w"

void write_pl(void)
{int i;
char output_file[FILE_NAME_LENGTH+1];


sprintf(output_file,"%s.pl",output_name);
if(!(out= fopen(output_file,WRITE_TXT)))
{fprintf(stderr,"Couldn't open %s\n",output_file);
exit(-1);
}
printf("\nWriting %s\n",output_file);

fprintf(out,
"\n(DESIGNSIZE R %.6f)"
"\n(COMMENT DESIGNSIZE IS IN POINTS)"
"\n(COMMENT OTHER SIZES ARE MULTIPLES OF DESIGNSIZE)"
"\n(CHECKSUM O %lo)"
"\n(FONTDIMEN"
"\n   (SLANT R 0.0)"
"\n   (SPACE R 0.0)"
"\n   (STRETCH R 0.0)"
"\n   (SHRINK R 0.0)"
"\n   (XHEIGHT R 1.0)"
"\n   (QUAD R 1.0)"
"\n   (EXTRASPACE R 0.0)"
"\n   )",design_size,checksum);

for(i= 0;i<256;i++)
{fprintf(out,
"\n(CHARACTER O %o"
"\n   (CHARWD R %.6f)"
"\n   (CHARHT R %.6f)"
"\n   (CHARDP R %.6f)"
"\n   )",
i,
tfm_output_size_x+2*tfm_offset_x,
tfm_output_size_y+tfm_offset_y,
-tfm_offset_y);
}

fclose(out);
}


/*:42*//*45:*/
#line 1172 "hbf2gf.w"

void write_job(void)
{FILE*out;
int i,j;
char buffer[FILE_NAME_LENGTH+1];


strcpy(buffer,output_name);
strcat(buffer,job_extension);
if(!(out= fopen(buffer,WRITE_TXT)))
{fprintf(stderr,"Couldn't open %s\n",buffer);
exit(-1);
}
printf("\nWriting %s\n",buffer);

if(unicode)
{for(i= (min_char>>8),j= 0;j<nmb_files;i++,j++)
fprintf(out,
"%s %s%02x.gf %s%s%02x.%.0ipk\n"
"%s %s%02x.gf\n",
GFTOPK_NAME,output_name,i,
pk_directory,output_name,i,
long_extension?(int)(dpi_x*magstep+0.5):0,
rm_command,output_name,i);
}
else
{for(i= 1;i<=nmb_files;i++)
fprintf(out,
"%s %s%02i.gf %s%s%02i.%.0ipk\n"
"%s %s%02i.gf\n",
GFTOPK_NAME,output_name,i,
pk_directory,output_name,i,
long_extension?(int)(dpi_x*magstep+0.5):0,
rm_command,output_name,i);
}

if(tfm_files)
{fprintf(out,
"\n"
"%s %s.pl %s.tfm\n"
"%s %s.pl\n"
"\n",
PLTOTF_NAME,output_name,output_name,
rm_command,output_name);

if(unicode)
{for(i= (min_char>>8),j= 0;j<nmb_files;i++,j++)
fprintf(out,
"%s %s.tfm %s%s%02x.tfm\n",
cp_command,output_name,
tfm_directory,output_name,i);
}
else
{for(i= 1;i<=nmb_files;i++)
fprintf(out,
"%s %s.tfm %s%s%02i.tfm\n",
cp_command,output_name,
tfm_directory,output_name,i);
}

fprintf(out,
"\n"
"%s %s.tfm",
rm_command,output_name);
}

fclose(out);
}


/*:45*//*49:*/
#line 1380 "hbf2gf.w"

void read_config(void)
{HBF_BBOX*boxp;


if(!(config= fopen(config_file,READ_TXT)))
{fprintf(stderr,"Couldn't open %s\n",config_file);
exit(-1);
}

/*50:*/
#line 1401 "hbf2gf.w"

if(!fsearch("hbf_header"))
config_error("hbf_header");
else
strcpy(hbf_header,Buffer);

hbfDebug= 1;


if(!(hbf= hbfOpen(hbf_header)))
exit(-1);

hbfDebug= 0;

boxp= hbfBitmapBBox(hbf);
input_size_x= boxp->hbf_width;
input_size_y= boxp->hbf_height;

if(!fsearch("output_name"))
config_error("output_name");
else
strcpy(output_name,Buffer);


/*:50*/
#line 1390 "hbf2gf.w"
;
/*51:*/
#line 1426 "hbf2gf.w"

{int offset_x;
int offset_y;


if(fsearch("nmb_files"))
nmb_files= atoi(Buffer);
if(fsearch("unicode"))
if(Buffer[0]=='y'||Buffer[0]=='Y')
unicode= TRUE;

if(fsearch("tfm_files"))
if(Buffer[0]=='n'||Buffer[0]=='N')
tfm_files= FALSE;

if(fsearch("mag_x"))
mag_x= atof(Buffer);
if(fsearch("mag_y"))
mag_y= atof(Buffer);
if(mag_x&&!mag_y)
mag_y= mag_x;
if(mag_y&&!mag_x)
mag_x= mag_y;
if(mag_x<=0)
{fprintf(stderr,"Invalid horizontal magnification\n");
exit(-1);
}
if(mag_y<=0)
{fprintf(stderr,"Invalid vertical magnification\n");
exit(-1);
}

if(fsearch("design_size"))
design_size= atof(Buffer);
if(fsearch("target_size"))
target_size= atof(Buffer);
else
target_size= design_size;
magstep= target_size/design_size;

if(fsearch("dpi_x"))
dpi_x= atoi(Buffer);
if(fsearch("dpi_y"))
dpi_y= atoi(Buffer);
if(dpi_x&&!dpi_y)
dpi_y= dpi_x;
if(dpi_y&&!dpi_x)
dpi_x= dpi_y;
if(dpi_x<=PRINTER_MIN_RES_X)
{fprintf(stderr,"Invalid horizontal printer resolution\n");
exit(-1);
}
if(dpi_y<=PRINTER_MIN_RES_Y)
{fprintf(stderr,"Invalid vertical printer resolution\n");
exit(-1);
}

if(fsearch("x_offset"))
offset_x= atoi(Buffer);
else
offset_x= boxp->hbf_xDisplacement*mag_x+0.5;
if(fsearch("y_offset"))
offset_y= atoi(Buffer);
else
offset_y= boxp->hbf_yDisplacement*mag_y+0.5;
pk_offset_x= offset_x*magstep+0.5;
pk_offset_y= offset_y*magstep+0.5;
tfm_offset_x= offset_x/(dpi_x/72.27)/design_size;
tfm_offset_y= offset_y/(dpi_y/72.27)/design_size;

pk_output_size_x= input_size_x*mag_x*magstep+0.5;
pk_output_size_y= input_size_y*mag_y*magstep+0.5;
tfm_output_size_x= input_size_x*mag_x/
(dpi_x/72.27)/design_size;
tfm_output_size_y= input_size_y*mag_y/
(dpi_y/72.27)/design_size;
if(pk_output_size_x>MAX_CHAR_SIZE)
{fprintf(stderr,"Output character box width too big\n");
exit(-1);
}
if(pk_output_size_y>MAX_CHAR_SIZE)
{fprintf(stderr,"Output character box height too big\n");
exit(-1);
}

if(!fsearch("comment"))
comment[0]= '\0';
else
strcpy(comment,Buffer);

if(fsearch("threshold"))
threshold= atoi(Buffer);
if(threshold<=0||threshold>=255)
{fprintf(stderr,"Invalid threshold\n");
exit(-1);
}

if(!fsearch("checksum"))
checksum= (unsigned long)time(NULL);

else
{char*dummy;


checksum= strtoul(Buffer,&dummy,10);
}

if(!fsearch("coding"))
coding[0]= '\0';
else
strcpy(coding,Buffer);

if(!fsearch("pk_directory"))
pk_directory[0]= '\0';
else
strcpy(pk_directory,Buffer);

if(!fsearch("tfm_directory"))
tfm_directory[0]= '\0';
else
strcpy(tfm_directory,Buffer);

if(fsearch("long_extension"))
if(Buffer[0]=='n'||Buffer[0]=='N')
long_extension= FALSE;

if(fsearch("rm_command"))
strcpy(rm_command,Buffer);
else
strcpy(rm_command,"rm");

if(fsearch("cp_command"))
strcpy(cp_command,Buffer);
else
strcpy(cp_command,"cp");

if(!fsearch("job_extension"))
job_extension[0]= '\0';
else
{strncpy(job_extension,Buffer,EXTENSION_LENGTH);
job_extension[EXTENSION_LENGTH]= '\0';
}
}


/*:51*/
#line 1391 "hbf2gf.w"
;

/*53:*/
#line 1582 "hbf2gf.w"

{const void*cp;
HBF_CHAR dummy;


cp= hbfGetCodeRange(hbf,NULL,&min_char,&max_char);
for(;cp!=NULL;cp= hbfGetCodeRange(hbf,cp,&dummy,&max_char))
;
}


/*:53*/
#line 1393 "hbf2gf.w"
;
/*55:*/
#line 1608 "hbf2gf.w"

{const void*b2r;
unsigned char dummy;
int i;


for(i= 0;i<256;i++)
b2_codes[i]= 0;

b2r= hbfGetByte2Range(hbf,NULL,&min_2_byte,&max_2_byte);
dummy= min_2_byte;
for(;b2r!=NULL;b2r= hbfGetByte2Range(hbf,b2r,&dummy,&max_2_byte))
{for(i= dummy;i<=max_2_byte;i++)
b2_codes[i]= VALID_SUBCODE;
}
}


/*:55*/
#line 1394 "hbf2gf.w"
;

fclose(config);
}


/*:49*//*57:*/
#line 1637 "hbf2gf.w"

int fsearch(search_string)
char*search_string;

{char*P,p;
int Ch,ch,old_ch= '\n';
int count= STRING_LENGTH;


rewind(config);

do
{P= search_string;
p= tolower(*P);
Ch= fgetc(config);
ch= tolower(Ch);
while(!(ch==p&&old_ch=='\n')&&Ch!=EOF)


{old_ch= ch;
Ch= fgetc(config);
ch= tolower(Ch);
}

for(;;)
{if(*(++P)=='\0')
if((Ch= fgetc(config))==' '||Ch=='\t')

goto success;
Ch= fgetc(config);
if(tolower(Ch)!=tolower(*P))
break;
}
}
while(Ch!=EOF);

return 0;

success:
P= Buffer;

while((Ch= fgetc(config))==' '||Ch=='\t')

;
while(Ch!='\n'&&--count>0&&Ch!=EOF)
{*P++= Ch;
Ch= fgetc(config);
}
*P= '\0';

return(*Buffer)?1:0;
}


/*:57*//*59:*/
#line 1700 "hbf2gf.w"

void config_error(message)
char*message;

{fprintf(stderr,"Couldn't find \"%s\" entry in configuration file\n",
message);
exit(-1);
}


/*:59*/