[Scummvm-cvs-logs] SF.net SVN: scummvm:[38325] scummvm/trunk/engines/sci

fingolfin at users.sourceforge.net fingolfin at users.sourceforge.net
Sun Feb 15 23:43:13 CET 2009


Revision: 38325
          http://scummvm.svn.sourceforge.net/scummvm/?rev=38325&view=rev
Author:   fingolfin
Date:     2009-02-15 22:43:13 +0000 (Sun, 15 Feb 2009)

Log Message:
-----------
SCI: Run astyle to make the code be more compliant with our Code Formatting Guidelines: rest

Modified Paths:
--------------
    scummvm/trunk/engines/sci/sci.cpp
    scummvm/trunk/engines/sci/sci.h
    scummvm/trunk/engines/sci/tools/bdf.cpp
    scummvm/trunk/engines/sci/tools/bdf.h
    scummvm/trunk/engines/sci/tools/bdfP.h
    scummvm/trunk/engines/sci/tools/bdfgname.cpp
    scummvm/trunk/engines/sci/tools/bdfgrid.cpp
    scummvm/trunk/engines/sci/tools/bdftofont.cpp
    scummvm/trunk/engines/sci/tools/classes.cpp
    scummvm/trunk/engines/sci/tools/fonttoc.cpp
    scummvm/trunk/engines/sci/tools/graphics_png.h
    scummvm/trunk/engines/sci/tools/listwords.cpp
    scummvm/trunk/engines/sci/tools/musicplayer.cpp
    scummvm/trunk/engines/sci/tools/scidisasm.cpp
    scummvm/trunk/engines/sci/tools/scipack.cpp
    scummvm/trunk/engines/sci/tools/sciunpack.cpp
    scummvm/trunk/engines/sci/tools/scriptdump.cpp
    scummvm/trunk/engines/sci/tools/vocabdump.cpp

Modified: scummvm/trunk/engines/sci/sci.cpp
===================================================================
--- scummvm/trunk/engines/sci/sci.cpp	2009-02-15 22:42:09 UTC (rev 38324)
+++ scummvm/trunk/engines/sci/sci.cpp	2009-02-15 22:43:13 UTC (rev 38325)
@@ -37,8 +37,7 @@
 extern gfx_driver_t gfx_driver_scummvm;
 
 int
-c_quit(state_t *s)
-{
+c_quit(state_t *s) {
 	script_abort_flag = 1; /* Terminate VM */
 	_debugstate_valid = 0;
 	_debug_seeking = 0;
@@ -47,15 +46,13 @@
 }
 
 int
-c_die(state_t *s)
-{
+c_die(state_t *s) {
 	exit(0); /* Die */
 	return 0; /* ;-P (fixes warning) */
 }
 
 static void
-init_console()
-{
+init_console() {
 #ifdef WANT_CONSOLE
 	con_gfx_init();
 #endif
@@ -75,29 +72,28 @@
 		"Dirty frames management\n");
 	*/
 	con_hook_int(&gfx_crossblit_alpha_threshold, "alpha_threshold",
-		"Alpha threshold for crossblitting\n");
+	             "Alpha threshold for crossblitting\n");
 	con_hook_int(&sci0_palette, "sci0_palette",
-		"SCI0 palette- 0: EGA, 1:AGI/Amiga, 2:Grayscale\n");
+	             "SCI0 palette- 0: EGA, 1:AGI/Amiga, 2:Grayscale\n");
 	con_hook_int(&sci01_priority_table_flags, "sci01_priority_table_flags",
-		"SCI01 priority table debugging flags: 1:Disable, 2:Print on change\n");
+	             "SCI01 priority table debugging flags: 1:Disable, 2:Print on change\n");
 
 	con_passthrough = 1; /* enables all sciprintf data to be sent to stdout */
 }
 
 static int
-init_gamestate(state_t *gamestate, sci_version_t version)
-{
+init_gamestate(state_t *gamestate, sci_version_t version) {
 	int errc;
 
 	if ((errc = script_init_engine(gamestate, version))) { /* Initialize game state */
 		int recovered = 0;
 
 		if (errc == SCI_ERROR_INVALID_SCRIPT_VERSION) {
-			int tversion = SCI_VERSION_FTU_NEW_SCRIPT_HEADER - ((version < SCI_VERSION_FTU_NEW_SCRIPT_HEADER)? 0 : 1);
+			int tversion = SCI_VERSION_FTU_NEW_SCRIPT_HEADER - ((version < SCI_VERSION_FTU_NEW_SCRIPT_HEADER) ? 0 : 1);
 
 			while (!recovered && tversion) {
 				printf("Trying version %d.%03x.%03d instead\n", SCI_VERSION_MAJOR(tversion),
-					SCI_VERSION_MINOR(tversion), SCI_VERSION_PATCHLEVEL(tversion));
+				       SCI_VERSION_MINOR(tversion), SCI_VERSION_PATCHLEVEL(tversion));
 
 				errc = script_init_engine(gamestate, tversion);
 
@@ -126,7 +122,7 @@
 		}
 
 		if (!recovered) {
-			fprintf(stderr,"Script initialization failed. Aborting...\n");
+			fprintf(stderr, "Script initialization failed. Aborting...\n");
 			return 1;
 		}
 	}
@@ -134,8 +130,7 @@
 }
 
 static void
-detect_versions(sci_version_t *version, int *res_version)
-{
+detect_versions(sci_version_t *version, int *res_version) {
 	sci_version_t exe_version;
 	sci_version_t hash_version;
 	int hash_res_version;
@@ -149,9 +144,9 @@
 
 	if (got_exe_version) {
 		sciprintf("Interpreter version: %d.%03d.%03d (by executable scan)\n",
-				  SCI_VERSION_MAJOR(exe_version),
-				  SCI_VERSION_MINOR(exe_version),
-				  SCI_VERSION_PATCHLEVEL(exe_version));
+		          SCI_VERSION_MAJOR(exe_version),
+		          SCI_VERSION_MINOR(exe_version),
+		          SCI_VERSION_PATCHLEVEL(exe_version));
 
 		if (SCI_VERSION_MAJOR(exe_version) >= 1) {
 			sciprintf("FIXME: Implement version mapping (results of executable scan ignored)\n");
@@ -164,20 +159,20 @@
 
 	if (game_name) {
 		sciprintf("Interpreter version: %d.%03d.%03d (by hash code %08X)\n",
-				  SCI_VERSION_MAJOR(hash_version),
-				  SCI_VERSION_MINOR(hash_version),
-				  SCI_VERSION_PATCHLEVEL(hash_version), code);
+		          SCI_VERSION_MAJOR(hash_version),
+		          SCI_VERSION_MINOR(hash_version),
+		          SCI_VERSION_PATCHLEVEL(hash_version), code);
 		if (got_exe_version && exe_version != hash_version)
-				sciprintf("UNEXPECTED INCONSISTENCY: Hash code %08X indicates interpreter version\n"
-					  "  %d.%03d.%03d, but analysis of the executable yields %d.%03d.%03d (for game\n"
-					  "  '%s'). Please report this!\n",
-					  code,
-					  SCI_VERSION_MAJOR(hash_version),
-					  SCI_VERSION_MINOR(hash_version),
-					  SCI_VERSION_PATCHLEVEL(hash_version),
-					  SCI_VERSION_MAJOR(exe_version),
-					  SCI_VERSION_MINOR(exe_version),
-					  SCI_VERSION_PATCHLEVEL(exe_version), game_name);
+			sciprintf("UNEXPECTED INCONSISTENCY: Hash code %08X indicates interpreter version\n"
+			          "  %d.%03d.%03d, but analysis of the executable yields %d.%03d.%03d (for game\n"
+			          "  '%s'). Please report this!\n",
+			          code,
+			          SCI_VERSION_MAJOR(hash_version),
+			          SCI_VERSION_MINOR(hash_version),
+			          SCI_VERSION_PATCHLEVEL(hash_version),
+			          SCI_VERSION_MAJOR(exe_version),
+			          SCI_VERSION_MINOR(exe_version),
+			          SCI_VERSION_PATCHLEVEL(exe_version), game_name);
 
 		if (hash_res_version != SCI_VERSION_AUTODETECT)
 			sciprintf("Resource version: %d (by hash code)\n", hash_res_version);
@@ -188,8 +183,8 @@
 
 		if (got_exe_version)
 			sciprintf("Please report the preceding two lines and the name of the game you were trying\n"
-				  "to run to the FreeSCI development team to help other users!\n",
-				  code);
+			          "to run to the FreeSCI development team to help other users!\n",
+			          code);
 	}
 
 	if (game_name)
@@ -206,17 +201,16 @@
 
 	if (*version)
 		sciprintf("Using interpreter version %d.%03d.%03d\n",
-				  SCI_VERSION_MAJOR(*version),
-				  SCI_VERSION_MINOR(*version),
-				  SCI_VERSION_PATCHLEVEL(*version));
+		          SCI_VERSION_MAJOR(*version),
+		          SCI_VERSION_MINOR(*version),
+		          SCI_VERSION_PATCHLEVEL(*version));
 
 	if (*res_version != SCI_VERSION_AUTODETECT)
 		sciprintf("Using resource version %d\n", *res_version);
 }
 
 int
-main_()
-{
+main_() {
 	resource_mgr_t *resmgr;
 
 	init_console(); /* So we can get any output */
@@ -234,11 +228,11 @@
 	char resource_dir[MAXPATHLEN+1] = "";
 	getcwd(resource_dir, MAXPATHLEN); /* Store resource directory */
 
-	resmgr = scir_new_resource_manager(resource_dir, res_version, 1, 256*1024);
+	resmgr = scir_new_resource_manager(resource_dir, res_version, 1, 256 * 1024);
 
 	if (!resmgr) {
 		printf("No resources found in '%s'.\nAborting...\n",
-			resource_dir);
+		       resource_dir);
 		exit(1);
 	}
 
@@ -262,7 +256,7 @@
 
 
 	if (game_init(gamestate)) { /* Initialize */
-		fprintf(stderr,"Game initialization failed: Aborting...\n");
+		fprintf(stderr, "Game initialization failed: Aborting...\n");
 		return 1;
 	}
 
@@ -283,7 +277,7 @@
 	gfx_state.version = resmgr->sci_version;
 	gamestate->gfx_state = &gfx_state;
 
-/**** Default config: */
+	/**** Default config: */
 	gfx_options_t gfx_options;
 	gfx_options.workarounds = 0;
 	gfx_options.buffer_pics_nr = 0;
@@ -299,32 +293,32 @@
 	gfx_options.text_xlate_filter = GFX_XLATE_FILTER_NONE;
 	gfx_options.dirty_frames = GFXOP_DIRTY_FRAMES_CLUSTERS;
 	gfx_options.pic0_antialiasing = GFXR_ANTIALIASING_NONE;
-	gfx_options.pic_port_bounds = gfx_rect(0,10,320,190);
+	gfx_options.pic_port_bounds = gfx_rect(0, 10, 320, 190);
 	for (int i = 0; i < GFX_RESOURCE_TYPES_NR; i++) {
 		gfx_options.res_conf.assign[i] = NULL;
 		gfx_options.res_conf.mod[i] = NULL;
 	}
-/**** Default config ends */
+	/**** Default config ends */
 
 	if (gfxop_init_default(&gfx_state, &gfx_options, resmgr)) {
-		fprintf(stderr,"Graphics initialization failed. Aborting...\n");
+		fprintf(stderr, "Graphics initialization failed. Aborting...\n");
 		return 1;
 	}
 
 	if (game_init_graphics(gamestate)) { /* Init interpreter graphics */
-		fprintf(stderr,"Game initialization failed: Error in GFX subsystem. Aborting...\n");
+		fprintf(stderr, "Game initialization failed: Error in GFX subsystem. Aborting...\n");
 		return 1;
 	}
 
 	if (game_init_sound(gamestate, 0)) {
-		fprintf(stderr,"Game initialization failed: Error in sound subsystem. Aborting...\n");
+		fprintf(stderr, "Game initialization failed: Error in sound subsystem. Aborting...\n");
 		return 1;
 	}
 
 	printf("Emulating SCI version %d.%03d.%03d\n",
-		SCI_VERSION_MAJOR(gamestate->version),
-		SCI_VERSION_MINOR(gamestate->version),
-		SCI_VERSION_PATCHLEVEL(gamestate->version));
+	       SCI_VERSION_MAJOR(gamestate->version),
+	       SCI_VERSION_MINOR(gamestate->version),
+	       SCI_VERSION_PATCHLEVEL(gamestate->version));
 
 	game_run(&gamestate); /* Run the game */
 
@@ -344,7 +338,7 @@
 }
 
 SciEngine::SciEngine(OSystem *syst, const SciGameDescription *desc)
-	: Engine(syst) {
+		: Engine(syst) {
 	// Put your engine in a sane state, but do nothing big yet;
 	// in particular, do not load data from files; rather, if you
 	// need to do such things, do them from init().

Modified: scummvm/trunk/engines/sci/sci.h
===================================================================
--- scummvm/trunk/engines/sci/sci.h	2009-02-15 22:42:09 UTC (rev 38324)
+++ scummvm/trunk/engines/sci/sci.h	2009-02-15 22:43:13 UTC (rev 38325)
@@ -29,15 +29,15 @@
 //class Console;
 
 class SciEngine : public Engine {
-	public:
-		SciEngine(OSystem *syst, const SciGameDescription *desc);
-		~SciEngine();
+public:
+	SciEngine(OSystem *syst, const SciGameDescription *desc);
+	~SciEngine();
 
-		virtual Common::Error init(void);
-		virtual Common::Error go(void);
+	virtual Common::Error init(void);
+	virtual Common::Error go(void);
 
-	private:
-		//Console *_console;
+private:
+	//Console *_console;
 };
 
 /*

Modified: scummvm/trunk/engines/sci/tools/bdf.cpp
===================================================================
--- scummvm/trunk/engines/sci/tools/bdf.cpp	2009-02-15 22:42:09 UTC (rev 38324)
+++ scummvm/trunk/engines/sci/tools/bdf.cpp	2009-02-15 22:43:13 UTC (rev 38325)
@@ -21,7 +21,7 @@
  */
 #ifndef lint
 #ifdef __GNUC__
-static char rcsid[] __attribute__ ((unused)) = "$Id: bdf.c 1284 2004-04-02 07:42:44Z jameson $";
+static char rcsid[] __attribute__((unused)) = "$Id: bdf.c 1284 2004-04-02 07:42:44Z jameson $";
 #else
 static char rcsid[] = "$Id: bdf.c 1284 2004-04-02 07:42:44Z jameson $";
 #endif
@@ -57,17 +57,17 @@
  **************************************************************************/
 
 static bdf_options_t _bdf_opts = {
-    1,                /* Hint TTF glyphs.               */
-    1,                /* Correct metrics.               */
-    1,                /* Preserve unencoded glyphs.     */
-    1,                /* Preserve comments.             */
-    1,                /* Pad character-cells.           */
-    BDF_PROPORTIONAL, /* Default spacing.               */
-    12,               /* Default point size.            */
-    0,                /* Default horizontal resolution. */
-    0,                /* Default vertical resolution.   */
-    1,                /* Bits per pixel.                */
-    BDF_UNIX_EOL,     /* Line separator.                */
+	1,                /* Hint TTF glyphs.               */
+	1,                /* Correct metrics.               */
+	1,                /* Preserve unencoded glyphs.     */
+	1,                /* Preserve comments.             */
+	1,                /* Pad character-cells.           */
+	BDF_PROPORTIONAL, /* Default spacing.               */
+	12,               /* Default point size.            */
+	0,                /* Default horizontal resolution. */
+	0,                /* Default vertical resolution.   */
+	1,                /* Bits per pixel.                */
+	BDF_UNIX_EOL,     /* Line separator.                */
 };
 
 /**************************************************************************
@@ -81,93 +81,93 @@
  * RAW_* and AXIS_* properties in X11R6 polymorphic fonts.
  */
 static bdf_property_t _bdf_properties[] = {
-    {"ADD_STYLE_NAME",          BDF_ATOM,     1},
-    {"AVERAGE_WIDTH",           BDF_INTEGER,  1},
-    {"AVG_CAPITAL_WIDTH",       BDF_INTEGER,  1},
-    {"AVG_LOWERCASE_WIDTH",     BDF_INTEGER,  1},
-    {"CAP_HEIGHT",              BDF_INTEGER,  1},
-    {"CHARSET_COLLECTIONS",     BDF_ATOM,     1},
-    {"CHARSET_ENCODING",        BDF_ATOM,     1},
-    {"CHARSET_REGISTRY",        BDF_ATOM,     1},
-    {"COMMENT",                 BDF_ATOM,     1},
-    {"COPYRIGHT",               BDF_ATOM,     1},
-    {"DEFAULT_CHAR",            BDF_CARDINAL, 1},
-    {"DESTINATION",             BDF_CARDINAL, 1},
-    {"DEVICE_FONT_NAME",        BDF_ATOM,     1},
-    {"END_SPACE",               BDF_INTEGER,  1},
-    {"FACE_NAME",               BDF_ATOM,     1},
-    {"FAMILY_NAME",             BDF_ATOM,     1},
-    {"FIGURE_WIDTH",            BDF_INTEGER,  1},
-    {"FONT",                    BDF_ATOM,     1},
-    {"FONTNAME_REGISTRY",       BDF_ATOM,     1},
-    {"FONT_ASCENT",             BDF_INTEGER,  1},
-    {"FONT_DESCENT",            BDF_INTEGER,  1},
-    {"FOUNDRY",                 BDF_ATOM,     1},
-    {"FULL_NAME",               BDF_ATOM,     1},
-    {"ITALIC_ANGLE",            BDF_INTEGER,  1},
-    {"MAX_SPACE",               BDF_INTEGER,  1},
-    {"MIN_SPACE",               BDF_INTEGER,  1},
-    {"NORM_SPACE",              BDF_INTEGER,  1},
-    {"NOTICE",                  BDF_ATOM,     1},
-    {"PIXEL_SIZE",              BDF_INTEGER,  1},
-    {"POINT_SIZE",              BDF_INTEGER,  1},
-    {"QUAD_WIDTH",              BDF_INTEGER,  1},
-    {"RAW_ASCENT",              BDF_INTEGER,  1},
-    {"RAW_AVERAGE_WIDTH",       BDF_INTEGER,  1},
-    {"RAW_AVG_CAPITAL_WIDTH",   BDF_INTEGER,  1},
-    {"RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER,  1},
-    {"RAW_CAP_HEIGHT",          BDF_INTEGER,  1},
-    {"RAW_DESCENT",             BDF_INTEGER,  1},
-    {"RAW_END_SPACE",           BDF_INTEGER,  1},
-    {"RAW_FIGURE_WIDTH",        BDF_INTEGER,  1},
-    {"RAW_MAX_SPACE",           BDF_INTEGER,  1},
-    {"RAW_MIN_SPACE",           BDF_INTEGER,  1},
-    {"RAW_NORM_SPACE",          BDF_INTEGER,  1},
-    {"RAW_PIXEL_SIZE",          BDF_INTEGER,  1},
-    {"RAW_POINT_SIZE",          BDF_INTEGER,  1},
-    {"RAW_PIXELSIZE",           BDF_INTEGER,  1},
-    {"RAW_POINTSIZE",           BDF_INTEGER,  1},
-    {"RAW_QUAD_WIDTH",          BDF_INTEGER,  1},
-    {"RAW_SMALL_CAP_SIZE",      BDF_INTEGER,  1},
-    {"RAW_STRIKEOUT_ASCENT",    BDF_INTEGER,  1},
-    {"RAW_STRIKEOUT_DESCENT",   BDF_INTEGER,  1},
-    {"RAW_SUBSCRIPT_SIZE",      BDF_INTEGER,  1},
-    {"RAW_SUBSCRIPT_X",         BDF_INTEGER,  1},
-    {"RAW_SUBSCRIPT_Y",         BDF_INTEGER,  1},
-    {"RAW_SUPERSCRIPT_SIZE",    BDF_INTEGER,  1},
-    {"RAW_SUPERSCRIPT_X",       BDF_INTEGER,  1},
-    {"RAW_SUPERSCRIPT_Y",       BDF_INTEGER,  1},
-    {"RAW_UNDERLINE_POSITION",  BDF_INTEGER,  1},
-    {"RAW_UNDERLINE_THICKNESS", BDF_INTEGER,  1},
-    {"RAW_X_HEIGHT",            BDF_INTEGER,  1},
-    {"RELATIVE_SETWIDTH",       BDF_CARDINAL, 1},
-    {"RELATIVE_WEIGHT",         BDF_CARDINAL, 1},
-    {"RESOLUTION",              BDF_INTEGER,  1},
-    {"RESOLUTION_X",            BDF_CARDINAL, 1},
-    {"RESOLUTION_Y",            BDF_CARDINAL, 1},
-    {"SETWIDTH_NAME",           BDF_ATOM,     1},
-    {"SLANT",                   BDF_ATOM,     1},
-    {"SMALL_CAP_SIZE",          BDF_INTEGER,  1},
-    {"SPACING",                 BDF_ATOM,     1},
-    {"STRIKEOUT_ASCENT",        BDF_INTEGER,  1},
-    {"STRIKEOUT_DESCENT",       BDF_INTEGER,  1},
-    {"SUBSCRIPT_SIZE",          BDF_INTEGER,  1},
-    {"SUBSCRIPT_X",             BDF_INTEGER,  1},
-    {"SUBSCRIPT_Y",             BDF_INTEGER,  1},
-    {"SUPERSCRIPT_SIZE",        BDF_INTEGER,  1},
-    {"SUPERSCRIPT_X",           BDF_INTEGER,  1},
-    {"SUPERSCRIPT_Y",           BDF_INTEGER,  1},
-    {"UNDERLINE_POSITION",      BDF_INTEGER,  1},
-    {"UNDERLINE_THICKNESS",     BDF_INTEGER,  1},
-    {"WEIGHT",                  BDF_CARDINAL, 1},
-    {"WEIGHT_NAME",             BDF_ATOM,     1},
-    {"X_HEIGHT",                BDF_INTEGER,  1},
-    {"_MULE_BASELINE_OFFSET",   BDF_INTEGER,  1},
-    {"_MULE_RELATIVE_COMPOSE",  BDF_INTEGER,  1},
+	{"ADD_STYLE_NAME",          BDF_ATOM,     1},
+	{"AVERAGE_WIDTH",           BDF_INTEGER,  1},
+	{"AVG_CAPITAL_WIDTH",       BDF_INTEGER,  1},
+	{"AVG_LOWERCASE_WIDTH",     BDF_INTEGER,  1},
+	{"CAP_HEIGHT",              BDF_INTEGER,  1},
+	{"CHARSET_COLLECTIONS",     BDF_ATOM,     1},
+	{"CHARSET_ENCODING",        BDF_ATOM,     1},
+	{"CHARSET_REGISTRY",        BDF_ATOM,     1},
+	{"COMMENT",                 BDF_ATOM,     1},
+	{"COPYRIGHT",               BDF_ATOM,     1},
+	{"DEFAULT_CHAR",            BDF_CARDINAL, 1},
+	{"DESTINATION",             BDF_CARDINAL, 1},
+	{"DEVICE_FONT_NAME",        BDF_ATOM,     1},
+	{"END_SPACE",               BDF_INTEGER,  1},
+	{"FACE_NAME",               BDF_ATOM,     1},
+	{"FAMILY_NAME",             BDF_ATOM,     1},
+	{"FIGURE_WIDTH",            BDF_INTEGER,  1},
+	{"FONT",                    BDF_ATOM,     1},
+	{"FONTNAME_REGISTRY",       BDF_ATOM,     1},
+	{"FONT_ASCENT",             BDF_INTEGER,  1},
+	{"FONT_DESCENT",            BDF_INTEGER,  1},
+	{"FOUNDRY",                 BDF_ATOM,     1},
+	{"FULL_NAME",               BDF_ATOM,     1},
+	{"ITALIC_ANGLE",            BDF_INTEGER,  1},
+	{"MAX_SPACE",               BDF_INTEGER,  1},
+	{"MIN_SPACE",               BDF_INTEGER,  1},
+	{"NORM_SPACE",              BDF_INTEGER,  1},
+	{"NOTICE",                  BDF_ATOM,     1},
+	{"PIXEL_SIZE",              BDF_INTEGER,  1},
+	{"POINT_SIZE",              BDF_INTEGER,  1},
+	{"QUAD_WIDTH",              BDF_INTEGER,  1},
+	{"RAW_ASCENT",              BDF_INTEGER,  1},
+	{"RAW_AVERAGE_WIDTH",       BDF_INTEGER,  1},
+	{"RAW_AVG_CAPITAL_WIDTH",   BDF_INTEGER,  1},
+	{"RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER,  1},
+	{"RAW_CAP_HEIGHT",          BDF_INTEGER,  1},
+	{"RAW_DESCENT",             BDF_INTEGER,  1},
+	{"RAW_END_SPACE",           BDF_INTEGER,  1},
+	{"RAW_FIGURE_WIDTH",        BDF_INTEGER,  1},
+	{"RAW_MAX_SPACE",           BDF_INTEGER,  1},
+	{"RAW_MIN_SPACE",           BDF_INTEGER,  1},
+	{"RAW_NORM_SPACE",          BDF_INTEGER,  1},
+	{"RAW_PIXEL_SIZE",          BDF_INTEGER,  1},
+	{"RAW_POINT_SIZE",          BDF_INTEGER,  1},
+	{"RAW_PIXELSIZE",           BDF_INTEGER,  1},
+	{"RAW_POINTSIZE",           BDF_INTEGER,  1},
+	{"RAW_QUAD_WIDTH",          BDF_INTEGER,  1},
+	{"RAW_SMALL_CAP_SIZE",      BDF_INTEGER,  1},
+	{"RAW_STRIKEOUT_ASCENT",    BDF_INTEGER,  1},
+	{"RAW_STRIKEOUT_DESCENT",   BDF_INTEGER,  1},
+	{"RAW_SUBSCRIPT_SIZE",      BDF_INTEGER,  1},
+	{"RAW_SUBSCRIPT_X",         BDF_INTEGER,  1},
+	{"RAW_SUBSCRIPT_Y",         BDF_INTEGER,  1},
+	{"RAW_SUPERSCRIPT_SIZE",    BDF_INTEGER,  1},
+	{"RAW_SUPERSCRIPT_X",       BDF_INTEGER,  1},
+	{"RAW_SUPERSCRIPT_Y",       BDF_INTEGER,  1},
+	{"RAW_UNDERLINE_POSITION",  BDF_INTEGER,  1},
+	{"RAW_UNDERLINE_THICKNESS", BDF_INTEGER,  1},
+	{"RAW_X_HEIGHT",            BDF_INTEGER,  1},
+	{"RELATIVE_SETWIDTH",       BDF_CARDINAL, 1},
+	{"RELATIVE_WEIGHT",         BDF_CARDINAL, 1},
+	{"RESOLUTION",              BDF_INTEGER,  1},
+	{"RESOLUTION_X",            BDF_CARDINAL, 1},
+	{"RESOLUTION_Y",            BDF_CARDINAL, 1},
+	{"SETWIDTH_NAME",           BDF_ATOM,     1},
+	{"SLANT",                   BDF_ATOM,     1},
+	{"SMALL_CAP_SIZE",          BDF_INTEGER,  1},
+	{"SPACING",                 BDF_ATOM,     1},
+	{"STRIKEOUT_ASCENT",        BDF_INTEGER,  1},
+	{"STRIKEOUT_DESCENT",       BDF_INTEGER,  1},
+	{"SUBSCRIPT_SIZE",          BDF_INTEGER,  1},
+	{"SUBSCRIPT_X",             BDF_INTEGER,  1},
+	{"SUBSCRIPT_Y",             BDF_INTEGER,  1},
+	{"SUPERSCRIPT_SIZE",        BDF_INTEGER,  1},
+	{"SUPERSCRIPT_X",           BDF_INTEGER,  1},
+	{"SUPERSCRIPT_Y",           BDF_INTEGER,  1},
+	{"UNDERLINE_POSITION",      BDF_INTEGER,  1},
+	{"UNDERLINE_THICKNESS",     BDF_INTEGER,  1},
+	{"WEIGHT",                  BDF_CARDINAL, 1},
+	{"WEIGHT_NAME",             BDF_ATOM,     1},
+	{"X_HEIGHT",                BDF_INTEGER,  1},
+	{"_MULE_BASELINE_OFFSET",   BDF_INTEGER,  1},
+	{"_MULE_RELATIVE_COMPOSE",  BDF_INTEGER,  1},
 };
 
 static unsigned long _num_bdf_properties =
-sizeof(_bdf_properties) / sizeof(_bdf_properties[0]);
+    sizeof(_bdf_properties) / sizeof(_bdf_properties[0]);
 
 /*
  * User defined properties.
@@ -184,15 +184,15 @@
 #define INITIAL_HT_SIZE 241
 
 typedef struct {
-    char *key;
-    void *data;
+	char *key;
+	void *data;
 } _hashnode, *hashnode;
 
 typedef struct {
-    int limit;
-    int size;
-    int used;
-    hashnode *table;
+	int limit;
+	int size;
+	int used;
+	hashnode *table;
 } hashtable;
 
 typedef void (*hash_free_func)(
@@ -210,26 +210,26 @@
 hashtable *ht;
 #endif
 {
-    char *kp = key;
-    unsigned long res = 0;
-    hashnode *bp = ht->table, *ndp;
+	char *kp = key;
+	unsigned long res = 0;
+	hashnode *bp = ht->table, *ndp;
 
-    /*
-     * Mocklisp hash function.
-     */
-    while (*kp)
-      res = (res << 5) - res + *kp++;
+	/*
+	 * Mocklisp hash function.
+	 */
+	while (*kp)
+		res = (res << 5) - res + *kp++;
 
-    ndp = bp + (res % ht->size);
-    while (*ndp) {
-        kp = (*ndp)->key;
-        if (kp[0] == key[0] && strcmp(kp, key) == 0)
-          break;
-        ndp--;
-        if (ndp < bp)
-          ndp = bp + (ht->size - 1);
-    }
-    return ndp;
+	ndp = bp + (res % ht->size);
+	while (*ndp) {
+		kp = (*ndp)->key;
+		if (kp[0] == key[0] && strcmp(kp, key) == 0)
+			break;
+		ndp--;
+		if (ndp < bp)
+			ndp = bp + (ht->size - 1);
+	}
+	return ndp;
 }
 
 static void
@@ -240,21 +240,21 @@
 hashtable *ht;
 #endif
 {
-    hashnode *obp = ht->table, *bp, *nbp;
-    int i, sz = ht->size;
+	hashnode *obp = ht->table, *bp, *nbp;
+	int i, sz = ht->size;
 
-    ht->size <<= 1;
-    ht->limit = ht->size / 3;
-    ht->table = (hashnode *) malloc(sizeof(hashnode) * ht->size);
-    (void) memset((char *) ht->table, 0, sizeof(hashnode) * ht->size);
+	ht->size <<= 1;
+	ht->limit = ht->size / 3;
+	ht->table = (hashnode *) malloc(sizeof(hashnode) * ht->size);
+	(void) memset((char *) ht->table, 0, sizeof(hashnode) * ht->size);
 
-    for (i = 0, bp = obp; i < sz; i++, bp++) {
-        if (*bp) {
-            nbp = hash_bucket((*bp)->key, ht);
-            *nbp = *bp;
-        }
-    }
-    free((char *) obp);
+	for (i = 0, bp = obp; i < sz; i++, bp++) {
+		if (*bp) {
+			nbp = hash_bucket((*bp)->key, ht);
+			*nbp = *bp;
+		}
+	}
+	free((char *) obp);
 }
 
 static void
@@ -265,13 +265,13 @@
 hashtable *ht;
 #endif
 {
-    int sz = INITIAL_HT_SIZE;
+	int sz = INITIAL_HT_SIZE;
 
-    ht->size = sz;
-    ht->limit = sz / 3;
-    ht->used = 0;
-    ht->table = (hashnode *) malloc(sizeof(hashnode) * sz);
-    (void) memset((char *) ht->table, 0, sizeof(hashnode) * sz);
+	ht->size = sz;
+	ht->limit = sz / 3;
+	ht->used = 0;
+	ht->table = (hashnode *) malloc(sizeof(hashnode) * sz);
+	(void) memset((char *) ht->table, 0, sizeof(hashnode) * sz);
 }
 
 static void
@@ -282,15 +282,15 @@
 hashtable *ht;
 #endif
 {
-    int i, sz = ht->size;
-    hashnode *bp = ht->table;
+	int i, sz = ht->size;
+	hashnode *bp = ht->table;
 
-    for (i = 0; i < sz; i++, bp++) {
-        if (*bp)
-          free((char *) *bp);
-    }
-    if (sz > 0)
-      free((char *) ht->table);
+	for (i = 0; i < sz; i++, bp++) {
+		if (*bp)
+			free((char *) *bp);
+	}
+	if (sz > 0)
+		free((char *) ht->table);
 }
 
 static void
@@ -303,19 +303,19 @@
 hashtable *ht;
 #endif
 {
-    hashnode nn, *bp = hash_bucket(key, ht);
+	hashnode nn, *bp = hash_bucket(key, ht);
 
-    nn = *bp;
-    if (!nn) {
-        *bp = nn = (hashnode) malloc(sizeof(_hashnode));
-        nn->key = key;
-        nn->data = data;
+	nn = *bp;
+	if (!nn) {
+		*bp = nn = (hashnode) malloc(sizeof(_hashnode));
+		nn->key = key;
+		nn->data = data;
 
-        if (ht->used >= ht->limit)
-          hash_rehash(ht);
-        ht->used++;
-    } else
-      nn->data = data;
+		if (ht->used >= ht->limit)
+			hash_rehash(ht);
+		ht->used++;
+	} else
+		nn->data = data;
 }
 
 static hashnode
@@ -327,8 +327,8 @@
 hashtable *ht;
 #endif
 {
-    hashnode *np = hash_bucket(key, ht);
-    return *np;
+	hashnode *np = hash_bucket(key, ht);
+	return *np;
 }
 
 static void
@@ -340,13 +340,13 @@
 hashtable *ht;
 #endif
 {
-    hashnode *hp;
+	hashnode *hp;
 
-    hp = hash_bucket(name, ht);
-    if (*hp) {
-        free((char *) *hp);
-        *hp = 0;
-    }
+	hp = hash_bucket(name, ht);
+	if (*hp) {
+		free((char *) *hp);
+		*hp = 0;
+	}
 }
 
 /*
@@ -377,37 +377,37 @@
  * List structure for splitting lines into fields.
  */
 typedef struct {
-    char **field;
-    unsigned long size;
-    unsigned long used;
-    char *bfield;
-    unsigned long bsize;
-    unsigned long bused;
+	char **field;
+	unsigned long size;
+	unsigned long used;
+	char *bfield;
+	unsigned long bsize;
+	unsigned long bused;
 } _bdf_list_t;
 
 /*
  * Structure used while loading BDF fonts.
  */
 typedef struct {
-    unsigned long flags;
-    unsigned long cnt;
-    unsigned long row;
-    unsigned long bpr;
-    short minlb;
-    short maxlb;
-    short maxrb;
-    short maxas;
-    short maxds;
-    short rbearing;
-    char *glyph_name;
-    long glyph_enc;
-    bdf_font_t *font;
-    bdf_options_t *opts;
-    void *client_data;
-    bdf_callback_t callback;
-    bdf_callback_struct_t cb;
-    unsigned long have[2048];
-    _bdf_list_t list;
+	unsigned long flags;
+	unsigned long cnt;
+	unsigned long row;
+	unsigned long bpr;
+	short minlb;
+	short maxlb;
+	short maxrb;
+	short maxas;
+	short maxds;
+	short rbearing;
+	char *glyph_name;
+	long glyph_enc;
+	bdf_font_t *font;
+	bdf_options_t *opts;
+	void *client_data;
+	bdf_callback_t callback;
+	bdf_callback_struct_t cb;
+	unsigned long have[2048];
+	_bdf_list_t list;
 } _bdf_parse_t;
 
 #define setsbit(m, cc) (m[(cc) >> 3] |= (1 << ((cc) & 7)))
@@ -433,129 +433,129 @@
 _bdf_list_t *list;
 #endif
 {
-    int mult, final_empty;
-    char *sp, *ep, *end;
-    unsigned char seps[32];
+	int mult, final_empty;
+	char *sp, *ep, *end;
+	unsigned char seps[32];
 
-    /*
-     * Initialize the list.
-     */
-    list->used = list->bused = 0;
+	/*
+	 * Initialize the list.
+	 */
+	list->used = list->bused = 0;
 
-    /*
-     * If the line is empty, then simply return.
-     */
-    if (linelen == 0 || line[0] == 0)
-      return;
+	/*
+	 * If the line is empty, then simply return.
+	 */
+	if (linelen == 0 || line[0] == 0)
+		return;
 
-    /*
-     * If the `separators' parameter is NULL or empty, split the list into
-     * individual bytes.
-     */
-    if (separators == 0 || *separators == 0) {
-        if (linelen > list->bsize) {
-            if (list->bsize)
-              list->bfield = (char *) malloc(linelen);
-            else
-              list->bfield = (char *) realloc(list->bfield, linelen);
-            list->bsize = linelen;
-        }
-        list->bused = linelen;
-        (void) memcpy(list->bfield, line, linelen);
-        return;
-    }
+	/*
+	 * If the `separators' parameter is NULL or empty, split the list into
+	 * individual bytes.
+	 */
+	if (separators == 0 || *separators == 0) {
+		if (linelen > list->bsize) {
+			if (list->bsize)
+				list->bfield = (char *) malloc(linelen);
+			else
+				list->bfield = (char *) realloc(list->bfield, linelen);
+			list->bsize = linelen;
+		}
+		list->bused = linelen;
+		(void) memcpy(list->bfield, line, linelen);
+		return;
+	}
 
-    /*
-     * Prepare the separator bitmap.
-     */
-    (void) memset((char *) seps, 0, 32);
+	/*
+	 * Prepare the separator bitmap.
+	 */
+	(void) memset((char *) seps, 0, 32);
 
-    /*
-     * If the very last character of the separator string is a plus, then set
-     * the `mult' flag to indicate that multiple separators should be
-     * collapsed into one.
-     */
-    for (mult = 0, sp = separators; sp && *sp; sp++) {
-        if (*sp == '+' && *(sp + 1) == 0)
-          mult = 1;
-        else
-          setsbit(seps, *sp);
-    }
+	/*
+	 * If the very last character of the separator string is a plus, then set
+	 * the `mult' flag to indicate that multiple separators should be
+	 * collapsed into one.
+	 */
+	for (mult = 0, sp = separators; sp && *sp; sp++) {
+		if (*sp == '+' && *(sp + 1) == 0)
+			mult = 1;
+		else
+			setsbit(seps, *sp);
+	}
 
-    /*
-     * Break the line up into fields.
-     */
-    for (final_empty = 0, sp = ep = line, end = sp + linelen;
-         sp < end && *sp;) {
-        /*
-         * Collect everything that is not a separator.
-         */
-        for (; *ep && !sbitset(seps, *ep); ep++) ;
+	/*
+	 * Break the line up into fields.
+	 */
+	for (final_empty = 0, sp = ep = line, end = sp + linelen;
+	        sp < end && *sp;) {
+		/*
+		 * Collect everything that is not a separator.
+		 */
+		for (; *ep && !sbitset(seps, *ep); ep++) ;
 
-        /*
-         * Resize the list if necessary.
-         */
-        if (list->used == list->size) {
-            if (list->size == 0)
-              list->field = (char **) malloc(sizeof(char *) * 5);
-            else
-              list->field = (char **)
-                  realloc((char *) list->field,
-                          sizeof(char *) * (list->size + 5));
+		/*
+		 * Resize the list if necessary.
+		 */
+		if (list->used == list->size) {
+			if (list->size == 0)
+				list->field = (char **) malloc(sizeof(char *) * 5);
+			else
+				list->field = (char **)
+				              realloc((char *) list->field,
+				                      sizeof(char *) * (list->size + 5));
 
-            list->size += 5;
-        }
+			list->size += 5;
+		}
 
-        /*
-         * Assign the field appropriately.
-         */
-        list->field[list->used++] = (ep > sp) ? sp : empty;
+		/*
+		 * Assign the field appropriately.
+		 */
+		list->field[list->used++] = (ep > sp) ? sp : empty;
 
-        sp = ep;
-        if (mult) {
-            /*
-             * If multiple separators should be collapsed, do it now by
-             * setting all the separator characters to 0.
-             */
-            for (; *ep && sbitset(seps, *ep); ep++)
-              *ep = 0;
-        } else if (*ep != 0)
-          /*
-           * Don't collapse multiple separators by making them 0, so just
-           * make the one encountered 0.
-           */
-          *ep++ = 0;
-        final_empty = (ep > sp && *ep == 0);
-        sp = ep;
-    }
+		sp = ep;
+		if (mult) {
+			/*
+			 * If multiple separators should be collapsed, do it now by
+			 * setting all the separator characters to 0.
+			 */
+			for (; *ep && sbitset(seps, *ep); ep++)
+				*ep = 0;
+		} else if (*ep != 0)
+			/*
+			 * Don't collapse multiple separators by making them 0, so just
+			 * make the one encountered 0.
+			 */
+			*ep++ = 0;
+		final_empty = (ep > sp && *ep == 0);
+		sp = ep;
+	}
 
-    /*
-     * Finally, NULL terminate the list.
-     */
-    if (list->used + final_empty + 1 >= list->size) {
-        if (list->used == list->size) {
-            if (list->size == 0)
-              list->field = (char **) malloc(sizeof(char *) * 5);
-            else
-              list->field = (char **)
-                  realloc((char *) list->field,
-                          sizeof(char *) * (list->size + 5));
-            list->size += 5;
-        }
-    }
-    if (final_empty)
-      list->field[list->used++] = empty;
+	/*
+	 * Finally, NULL terminate the list.
+	 */
+	if (list->used + final_empty + 1 >= list->size) {
+		if (list->used == list->size) {
+			if (list->size == 0)
+				list->field = (char **) malloc(sizeof(char *) * 5);
+			else
+				list->field = (char **)
+				              realloc((char *) list->field,
+				                      sizeof(char *) * (list->size + 5));
+			list->size += 5;
+		}
+	}
+	if (final_empty)
+		list->field[list->used++] = empty;
 
-    if (list->used == list->size) {
-        if (list->size == 0)
-          list->field = (char **) malloc(sizeof(char *) * 5);
-        else
-          list->field = (char **)
-              realloc((char *) list->field,
-                      sizeof(char *) * (list->size + 5));
-        list->size += 5;
-    }
-    list->field[list->used] = 0;
+	if (list->used == list->size) {
+		if (list->size == 0)
+			list->field = (char **) malloc(sizeof(char *) * 5);
+		else
+			list->field = (char **)
+			              realloc((char *) list->field,
+			                      sizeof(char *) * (list->size + 5));
+		list->size += 5;
+	}
+	list->field[list->used] = 0;
 }
 
 static void
@@ -567,18 +567,18 @@
 _bdf_list_t *list;
 #endif
 {
-    unsigned long i, u;
+	unsigned long i, u;
 
-    if (list == 0 || list->used == 0 || n == 0)
-      return;
+	if (list == 0 || list->used == 0 || n == 0)
+		return;
 
-    if (n >= list->used) {
-        list->used = 0;
-        return;
-    }
-    for (u = n, i = 0; u < list->used; i++, u++)
-      list->field[i] = list->field[u];
-    list->used -= n;
+	if (n >= list->used) {
+		list->used = 0;
+		return;
+	}
+	for (u = n, i = 0; u < list->used; i++, u++)
+		list->field[i] = list->field[u];
+	list->used -= n;
 }
 
 static char *
@@ -591,26 +591,26 @@
 _bdf_list_t *list;
 #endif
 {
-    unsigned long i, j;
-    char *fp, *dp;
+	unsigned long i, j;
+	char *fp, *dp;
 
-    if (list == 0 || list->used == 0)
-      return 0;
+	if (list == 0 || list->used == 0)
+		return 0;
 
-    *len = 0;
+	*len = 0;
 
-    dp = list->field[0];
-    for (i = j = 0; i < list->used; i++) {
-        fp = list->field[i];
-        while (*fp)
-          dp[j++] = *fp++;
-        if (i + 1 < list->used)
-          dp[j++] = c;
-    }
-    dp[j] = 0;
+	dp = list->field[0];
+	for (i = j = 0; i < list->used; i++) {
+		fp = list->field[i];
+		while (*fp)
+			dp[j++] = *fp++;
+		if (i + 1 < list->used)
+			dp[j++] = c;
+	}
+	dp[j] = 0;
 
-    *len = j;
-    return dp;
+	*len = j;
+	return dp;
 }
 
 /*
@@ -628,82 +628,82 @@
 unsigned long *lno;
 #endif
 {
-    _bdf_line_func_t cb;
-    unsigned long lineno;
-    int n, res, done, refill, bytes, hold;
-    char *ls, *le, *pp, *pe, *hp;
-    char buf[65536];
+	_bdf_line_func_t cb;
+	unsigned long lineno;
+	int n, res, done, refill, bytes, hold;
+	char *ls, *le, *pp, *pe, *hp;
+	char buf[65536];
 
-    if (callback == 0)
-      return -1;
+	if (callback == 0)
+		return -1;
 
-    cb = callback;
-    lineno = 1;
-    buf[0] = 0;
-    res = done = 0;
-    pp = ls = le = buf;
-    bytes = 65536;
-    while (!done && (n = read(fd, pp, bytes)) > 0) {
-        /*
-         * Determine the new end of the buffer pages.
-         */
-        pe = pp + n;
+	cb = callback;
+	lineno = 1;
+	buf[0] = 0;
+	res = done = 0;
+	pp = ls = le = buf;
+	bytes = 65536;
+	while (!done && (n = read(fd, pp, bytes)) > 0) {
+		/*
+		 * Determine the new end of the buffer pages.
+		 */
+		pe = pp + n;
 
-        for (refill = 0; done == 0 && refill == 0; ) {
-            while (le < pe && *le != '\n' && *le != '\r')
-              le++;
+		for (refill = 0; done == 0 && refill == 0;) {
+			while (le < pe && *le != '\n' && *le != '\r')
+				le++;
 
-            if (le == pe) {
-                /*
-                 * Hit the end of the last page in the buffer.  Need to find
-                 * out how many pages to shift and how many pages need to be
-                 * read in.  Adjust the line start and end pointers down to
-                 * point to the right places in the pages.
-                 */
-                pp = buf + (((ls - buf) >> 13) << 13);
-                n = pp - buf;
-                ls -= n;
-                le -= n;
-                n = pe - pp;
-                (void) memcpy(buf, pp, n);
-                pp = buf + n;
-                bytes = 65536 - n;
-                refill = 1;
-            } else {
-                /*
-                 * Temporarily NULL terminate the line.
-                 */
-                hp = le;
-                hold = *le;
-                *le = 0;
+			if (le == pe) {
+				/*
+				 * Hit the end of the last page in the buffer.  Need to find
+				 * out how many pages to shift and how many pages need to be
+				 * read in.  Adjust the line start and end pointers down to
+				 * point to the right places in the pages.
+				 */
+				pp = buf + (((ls - buf) >> 13) << 13);
+				n = pp - buf;
+				ls -= n;
+				le -= n;
+				n = pe - pp;
+				(void) memcpy(buf, pp, n);
+				pp = buf + n;
+				bytes = 65536 - n;
+				refill = 1;
+			} else {
+				/*
+				 * Temporarily NULL terminate the line.
+				 */
+				hp = le;
+				hold = *le;
+				*le = 0;
 
-                if (callback && *ls != '#' && *ls != 0x1a && le > ls &&
-                    (res = (*cb)(ls, le - ls, lineno, (void *) &cb,
-                                 client_data)) != 0)
-                  done = 1;
-                else {
-                    ls = ++le;
-                    /*
-                     * Handle the case of DOS crlf sequences.
-                     */
-                    if (le < pe && hold == '\n' && *le =='\r')
-                      ls = ++le;
-                }
+				if (callback && *ls != '#' && *ls != 0x1a && le > ls &&
+				        (res = (*cb)(ls, le - ls, lineno, (void *) & cb,
+				                     client_data)) != 0)
+					done = 1;
+				else {
+					ls = ++le;
+					/*
+					 * Handle the case of DOS crlf sequences.
+					 */
+					if (le < pe && hold == '\n' && *le == '\r')
+						ls = ++le;
+				}
 
-                /*
-                 * Increment the line number.
-                 */
-                lineno++;
+				/*
+				 * Increment the line number.
+				 */
+				lineno++;
 
-                /*
-                 * Restore the character at the end of the line.
-                 */
-                *hp = hold;
-            }
-        }
-    }
-    *lno = lineno;
-    return res;
+				/*
+				 * Restore the character at the end of the line.
+				 */
+				*hp = hold;
+			}
+		}
+	}
+	*lno = lineno;
+	return res;
 }
 
 unsigned char *
@@ -715,93 +715,108 @@
 unsigned long len;
 #endif
 {
-    unsigned char *ns;
+	unsigned char *ns;
 
-    if (s == 0 || len == 0)
-      return 0;
+	if (s == 0 || len == 0)
+		return 0;
 
-    ns = (unsigned char *) malloc(len);
-    (void) memcpy((char *) ns, (char *) s, len);
-    return ns;
+	ns = (unsigned char *) malloc(len);
+	(void) memcpy((char *) ns, (char *) s, len);
+	return ns;
 }
 
 void
-_bdf_memmove(char *dest, char *src, unsigned long bytes)
-{
-    long i, j;
+_bdf_memmove(char *dest, char *src, unsigned long bytes) {
+	long i, j;
 
-    i = (long) bytes;
-    j = i & 7;
-    i = (i + 7) >> 3;
+	i = (long) bytes;
+	j = i & 7;
+	i = (i + 7) >> 3;
 
-    /*
-     * Do a memmove using Ye Olde Duff's Device for efficiency.
-     */
-    if (src < dest) {
-        src += bytes;
-        dest += bytes;
+	/*
+	 * Do a memmove using Ye Olde Duff's Device for efficiency.
+	 */
+	if (src < dest) {
+		src += bytes;
+		dest += bytes;
 
-        switch (j) {
-          case 0: do {
-              *--dest = *--src;
-            case 7: *--dest = *--src;
-            case 6: *--dest = *--src;
-            case 5: *--dest = *--src;
-            case 4: *--dest = *--src;
-            case 3: *--dest = *--src;
-            case 2: *--dest = *--src;
-            case 1: *--dest = *--src;
-          } while (--i > 0);
-        }
-    } else if (src > dest) {
-        switch (j) {
-          case 0: do {
-              *dest++ = *src++;
-            case 7: *dest++ = *src++;
-            case 6: *dest++ = *src++;
-            case 5: *dest++ = *src++;
-            case 4: *dest++ = *src++;
-            case 3: *dest++ = *src++;
-            case 2: *dest++ = *src++;
-            case 1: *dest++ = *src++;
-          } while (--i > 0);
-        }
-    }
+		switch (j) {
+		case 0:
+			do {
+				*--dest = *--src;
+			case 7:
+				*--dest = *--src;
+			case 6:
+				*--dest = *--src;
+			case 5:
+				*--dest = *--src;
+			case 4:
+				*--dest = *--src;
+			case 3:
+				*--dest = *--src;
+			case 2:
+				*--dest = *--src;
+			case 1:
+				*--dest = *--src;
+			} while (--i > 0);
+		}
+	} else if (src > dest) {
+		switch (j) {
+		case 0:
+			do {
+				*dest++ = *src++;
+			case 7:
+				*dest++ = *src++;
+			case 6:
+				*dest++ = *src++;
+			case 5:
+				*dest++ = *src++;
+			case 4:
+				*dest++ = *src++;
+			case 3:
+				*dest++ = *src++;
+			case 2:
+				*dest++ = *src++;
+			case 1:
+				*dest++ = *src++;
+			} while (--i > 0);
+		}
+	}
 }
 
 static unsigned char a2i[128] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
 static unsigned char odigits[32] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 static unsigned char ddigits[32] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 static unsigned char hdigits[32] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
-    0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
+	0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 #define isdigok(m, d) (m[(d) >> 3] & (1 << ((d) & 7)))
@@ -818,37 +833,44 @@
 int base;
 #endif
 {
-    unsigned long v;
-    unsigned char *dmap;
+	unsigned long v;
+	unsigned char *dmap;
 
-    if (s == 0 || *s == 0)
-      return 0;
+	if (s == 0 || *s == 0)
+		return 0;
 
-    /*
-     * Make sure the radix is something recognizable.  Default to 10.
-     */
-    switch (base) {
-      case 8: dmap = odigits; break;
-      case 16: dmap = hdigits; break;
-      default: base = 10; dmap = ddigits; break;
-    }
+	/*
+	 * Make sure the radix is something recognizable.  Default to 10.
+	 */
+	switch (base) {
+	case 8:
+		dmap = odigits;
+		break;
+	case 16:
+		dmap = hdigits;
+		break;
+	default:
+		base = 10;
+		dmap = ddigits;
+		break;
+	}
 
-    /*
-     * Check for the special hex prefix.
-     */
-    if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
-        base = 16;
-        dmap = hdigits;
-        s += 2;
-    }
+	/*
+	 * Check for the special hex prefix.
+	 */
+	if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
+		base = 16;
+		dmap = hdigits;
+		s += 2;
+	}
 
-    for (v = 0; isdigok(dmap, *s); s++)
-      v = (v * base) + a2i[(int) *s];
+	for (v = 0; isdigok(dmap, *s); s++)
+		v = (v * base) + a2i[(int) *s];
 
-    if (end != 0)
-      *end = s;
+	if (end != 0)
+		*end = s;
 
-    return v;
+	return v;
 }
 
 /*
@@ -863,46 +885,53 @@
 int base;
 #endif
 {
-    long v, neg;
-    unsigned char *dmap;
+	long v, neg;
+	unsigned char *dmap;
 
-    if (s == 0 || *s == 0)
-      return 0;
+	if (s == 0 || *s == 0)
+		return 0;
 
-    /*
-     * Make sure the radix is something recognizable.  Default to 10.
-     */
-    switch (base) {
-      case 8: dmap = odigits; break;
-      case 16: dmap = hdigits; break;
-      default: base = 10; dmap = ddigits; break;
-    }
+	/*
+	 * Make sure the radix is something recognizable.  Default to 10.
+	 */
+	switch (base) {
+	case 8:
+		dmap = odigits;
+		break;
+	case 16:
+		dmap = hdigits;
+		break;
+	default:
+		base = 10;
+		dmap = ddigits;
+		break;
+	}
 
-    /*
-     * Check for a minus sign.
-     */
-    neg = 0;
-    if (*s == '-') {
-        s++;
-        neg = 1;
-    }
+	/*
+	 * Check for a minus sign.
+	 */
+	neg = 0;
+	if (*s == '-') {
+		s++;
+		neg = 1;
+	}
 
-    /*
-     * Check for the special hex prefix.
-     */
-    if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
-        base = 16;
-        dmap = hdigits;
-        s += 2;
-    }
+	/*
+	 * Check for the special hex prefix.
+	 */
+	if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
+		base = 16;
+		dmap = hdigits;
+		s += 2;
+	}
 
-    for (v = 0; isdigok(dmap, *s); s++)
-      v = (v * base) + a2i[(int) *s];
+	for (v = 0; isdigok(dmap, *s); s++)
+		v = (v * base) + a2i[(int) *s];
 
-    if (end != 0)
-      *end = s;
+	if (end != 0)
+		*end = s;
 
-    return (!neg) ? v : -v;
+	return (!neg) ? v : -v;
 }
 
 /*
@@ -917,46 +946,53 @@
 int base;
 #endif
 {
-    short v, neg;
-    unsigned char *dmap;
+	short v, neg;
+	unsigned char *dmap;
 
-    if (s == 0 || *s == 0)
-      return 0;
+	if (s == 0 || *s == 0)
+		return 0;
 
-    /*
-     * Make sure the radix is something recognizable.  Default to 10.
-     */
-    switch (base) {
-      case 8: dmap = odigits; break;
-      case 16: dmap = hdigits; break;
-      default: base = 10; dmap = ddigits; break;
-    }
+	/*
+	 * Make sure the radix is something recognizable.  Default to 10.
+	 */
+	switch (base) {
+	case 8:
+		dmap = odigits;
+		break;
+	case 16:
+		dmap = hdigits;
+		break;
+	default:
+		base = 10;
+		dmap = ddigits;
+		break;
+	}
 
-    /*
-     * Check for a minus.
-     */
-    neg = 0;
-    if (*s == '-') {
-        s++;
-        neg = 1;
-    }
+	/*
+	 * Check for a minus.
+	 */
+	neg = 0;
+	if (*s == '-') {
+		s++;
+		neg = 1;
+	}
 
-    /*
-     * Check for the special hex prefix.
-     */
-    if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
-        base = 16;
-        dmap = hdigits;
-        s += 2;
-    }
+	/*
+	 * Check for the special hex prefix.
+	 */
+	if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
+		base = 16;
+		dmap = hdigits;
+		s += 2;
+	}
 
-    for (v = 0; isdigok(dmap, *s); s++)
-      v = (v * base) + a2i[(int) *s];
+	for (v = 0; isdigok(dmap, *s); s++)
+		v = (v * base) + a2i[(int) *s];
 
-    if (end != 0)
-      *end = s;
+	if (end != 0)
+		*end = s;
 
-    return (!neg) ? v : -v;
+	return (!neg) ? v : -v;
 }
 
 /*
@@ -970,15 +1006,15 @@
 char *a, *b;
 #endif
 {
-    bdf_glyph_t *c1, *c2;
+	bdf_glyph_t *c1, *c2;
 
-    c1 = (bdf_glyph_t *) a;
-    c2 = (bdf_glyph_t *) b;
-    if (c1->encoding < c2->encoding)
-      return -1;
-    else if (c1->encoding > c2->encoding)
-      return 1;
-    return 0;
+	c1 = (bdf_glyph_t *) a;
+	c2 = (bdf_glyph_t *) b;
+	if (c1->encoding < c2->encoding)
+		return -1;
+	else if (c1->encoding > c2->encoding)
+		return 1;
+	return 0;
 }
 
 /**************************************************************************
@@ -1047,19 +1083,19 @@
 unsigned long len;
 #endif
 {
-    char *cp;
+	char *cp;
 
-    if (font->acmsgs_len == 0)
-      font->acmsgs = (char *) malloc(len + 1);
-    else
-      font->acmsgs = (char *) realloc(font->acmsgs,
-                                      font->acmsgs_len + len + 1);
+	if (font->acmsgs_len == 0)
+		font->acmsgs = (char *) malloc(len + 1);
+	else
+		font->acmsgs = (char *) realloc(font->acmsgs,
+		                                font->acmsgs_len + len + 1);
 
-    cp = font->acmsgs + font->acmsgs_len;
-    (void) memcpy(cp, msg, len);
-    cp += len;
-    *cp++ = '\n';
-    font->acmsgs_len += len + 1;
+	cp = font->acmsgs + font->acmsgs_len;
+	(void) memcpy(cp, msg, len);
+	cp += len;
+	*cp++ = '\n';
+	font->acmsgs_len += len + 1;
 }
 
 void
@@ -1072,19 +1108,19 @@
 unsigned long len;
 #endif
 {
-    char *cp;
+	char *cp;
 
-    if (font->comments_len == 0)
-      font->comments = (char *) malloc(len + 1);
-    else
-      font->comments = (char *) realloc(font->comments,
-                                        font->comments_len + len + 1);
+	if (font->comments_len == 0)
+		font->comments = (char *) malloc(len + 1);
+	else
+		font->comments = (char *) realloc(font->comments,
+		                                  font->comments_len + len + 1);
 
-    cp = font->comments + font->comments_len;
-    (void) memcpy(cp, comment, len);
-    cp += len;
-    *cp++ = '\n';
-    font->comments_len += len + 1;
+	cp = font->comments + font->comments_len;
+	(void) memcpy(cp, comment, len);
+	cp += len;
+	*cp++ = '\n';
+	font->comments_len += len + 1;
 }
 
 /*
@@ -1100,28 +1136,37 @@
 bdf_options_t *opts;
 #endif
 {
-    unsigned long len;
-    char name[128];
-    _bdf_list_t list;
+	unsigned long len;
+	char name[128];
+	_bdf_list_t list;
 
-    if (font == 0 || font->name == 0 || font->name[0] == 0)
-      return;
+	if (font == 0 || font->name == 0 || font->name[0] == 0)
+		return;
 
-    font->spacing = opts->font_spacing;
+	font->spacing = opts->font_spacing;
 
-    len = (unsigned long) (strlen(font->name) + 1);
-    (void) memcpy(name, font->name, len);
-    list.size = list.used = 0;
-    _bdf_split("-", name, len, &list);
-    if (list.used == 15) {
-        switch (list.field[11][0]) {
-          case 'C': case 'c': font->spacing = BDF_CHARCELL; break;
-          case 'M': case 'm': font->spacing = BDF_MONOWIDTH; break;
-          case 'P': case 'p': font->spacing = BDF_PROPORTIONAL; break;
-        }
-    }
-    if (list.size > 0)
-      free((char *) list.field);
+	len = (unsigned long)(strlen(font->name) + 1);
+	(void) memcpy(name, font->name, len);
+	list.size = list.used = 0;
+	_bdf_split("-", name, len, &list);
+	if (list.used == 15) {
+		switch (list.field[11][0]) {
+		case 'C':
+		case 'c':
+			font->spacing = BDF_CHARCELL;
+			break;
+		case 'M':
+		case 'm':
+			font->spacing = BDF_MONOWIDTH;
+			break;
+		case 'P':
+		case 'p':
+			font->spacing = BDF_PROPORTIONAL;
+			break;
+		}
+	}
+	if (list.size > 0)
+		free((char *) list.field);
 }
 
 /*
@@ -1138,68 +1183,68 @@
 char **name, **value;
 #endif
 {
-    int hold;
-    char *sp, *ep;
-    bdf_property_t *p;
+	int hold;
+	char *sp, *ep;
+	bdf_property_t *p;
 
-    *name = sp = ep = line;
-    while (*ep && *ep != ' ' && *ep != '\t')
-      ep++;
+	*name = sp = ep = line;
+	while (*ep && *ep != ' ' && *ep != '\t')
+		ep++;
 
-    hold = -1;
-    if (*ep) {
-        hold = *ep;
-        *ep = 0;
-    }
+	hold = -1;
+	if (*ep) {
+		hold = *ep;
+		*ep = 0;
+	}
 
-    p = bdf_get_property(sp);
+	p = bdf_get_property(sp);
 
-    /*
-     * Restore the character that was saved before any return can happen.
-     */
-    if (hold != -1)
-      *ep = hold;
+	/*
+	 * Restore the character that was saved before any return can happen.
+	 */
+	if (hold != -1)
+		*ep = hold;
 
-    /*
-     * If the propert exists and is not an atom, just return here.
-     */
-    if (p && p->format != BDF_ATOM)
-      return 0;
+	/*
+	 * If the propert exists and is not an atom, just return here.
+	 */
+	if (p && p->format != BDF_ATOM)
+		return 0;
 
-    /*
-     * The property is an atom.  Trim all leading and trailing whitespace and
-     * double quotes for the atom value.
-     */
-    sp = ep;
-    ep = line + linelen;
+	/*
+	 * The property is an atom.  Trim all leading and trailing whitespace and
+	 * double quotes for the atom value.
+	 */
+	sp = ep;
+	ep = line + linelen;
 
-    /*
-     * Trim the leading whitespace if it exists.
-     */
-    *sp++ = 0;
-    while (*sp && (*sp == ' ' || *sp == '\t'))
-      sp++;
+	/*
+	 * Trim the leading whitespace if it exists.
+	 */
+	*sp++ = 0;
+	while (*sp && (*sp == ' ' || *sp == '\t'))
+		sp++;
 
-    /*
-     * Trim the leading double quote if it exists.
-     */
-    if (*sp == '"')
-      sp++;
-    *value = sp;
+	/*
+	 * Trim the leading double quote if it exists.
+	 */
+	if (*sp == '"')
+		sp++;
+	*value = sp;
 
-    /*
-     * Trim the trailing whitespace if it exists.
-     */
-    while (ep > sp && (*(ep - 1) == ' ' || *(ep - 1) == '\t'))
-      *--ep = 0;
+	/*
+	 * Trim the trailing whitespace if it exists.
+	 */
+	while (ep > sp && (*(ep - 1) == ' ' || *(ep - 1) == '\t'))
+		*--ep = 0;
 
-    /*
-     * Trim the trailing double quote if it exists.
-     */
-    if (ep > sp && *(ep - 1) == '"')
-      *--ep = 0;
+	/*
+	 * Trim the trailing double quote if it exists.
+	 */
+	if (ep > sp && *(ep - 1) == '"')
+		*--ep = 0;
 
-    return 1;
+	return 1;
 }
 
 static void
@@ -1211,138 +1256,138 @@
 char *name, *value;
 #endif
 {
-    unsigned long propid;
-    hashnode hn;
-    int len;
-    bdf_property_t *prop, *fp;
+	unsigned long propid;
+	hashnode hn;
+	int len;
+	bdf_property_t *prop, *fp;
 
-    /*
-     * First, check to see if the property already exists in the font.
-     */
-    if ((hn = hash_lookup(name, (hashtable *) font->internal)) != 0) {
-        /*
-         * The property already exists in the font, so simply replace
-         * the value of the property with the current value.
-         */
-        fp = font->props + (unsigned long) hn->data;
+	/*
+	 * First, check to see if the property already exists in the font.
+	 */
+	if ((hn = hash_lookup(name, (hashtable *) font->internal)) != 0) {
+		/*
+		 * The property already exists in the font, so simply replace
+		 * the value of the property with the current value.
+		 */
+		fp = font->props + (unsigned long) hn->data;
 
-        switch (fp->format) {
-          case BDF_ATOM:
-            /*
-             * Delete the current atom if it exists.
-             */
-            if (fp->value.atom != 0)
-              free(fp->value.atom);
+		switch (fp->format) {
+		case BDF_ATOM:
+			/*
+			 * Delete the current atom if it exists.
+			 */
+			if (fp->value.atom != 0)
+				free(fp->value.atom);
 
-            if (value == 0)
-              len = 1;
-            else
-              len = strlen(value) + 1;
-            if (len > 1) {
-                fp->value.atom = (char *) malloc(len);
-                (void) memcpy(fp->value.atom, value, len);
-            } else
-              fp->value.atom = 0;
-            break;
-          case BDF_INTEGER:
-            fp->value.int32 = _bdf_atol(value, 0, 10);
-            break;
-          case BDF_CARDINAL:
-            fp->value.card32 = _bdf_atoul(value, 0, 10);
-            break;
-        }
-        return;
-    }
+			if (value == 0)
+				len = 1;
+			else
+				len = strlen(value) + 1;
+			if (len > 1) {
+				fp->value.atom = (char *) malloc(len);
+				(void) memcpy(fp->value.atom, value, len);
+			} else
+				fp->value.atom = 0;
+			break;
+		case BDF_INTEGER:
+			fp->value.int32 = _bdf_atol(value, 0, 10);
+			break;
+		case BDF_CARDINAL:
+			fp->value.card32 = _bdf_atoul(value, 0, 10);
+			break;
+		}
+		return;
+	}
 
-    /*
-     * See if this property type exists yet or not.  If not, create it.
-     */
-    hn = hash_lookup(name, &proptbl);
-    if (hn == 0) {
-        bdf_create_property(name, BDF_ATOM);
-        hn = hash_lookup(name, &proptbl);
-    }
+	/*
+	 * See if this property type exists yet or not.  If not, create it.
+	 */
+	hn = hash_lookup(name, &proptbl);
+	if (hn == 0) {
+		bdf_create_property(name, BDF_ATOM);
+		hn = hash_lookup(name, &proptbl);
+	}
 
-    /*
-     * Allocate another property if this is overflow.
-     */
-    if (font->props_used == font->props_size) {
-        if (font->props_size == 0)
-          font->props = (bdf_property_t *) malloc(sizeof(bdf_property_t));
-        else
-          font->props = (bdf_property_t *)
-              realloc((char *) font->props, sizeof(bdf_property_t) *
-                      (font->props_size + 1));
-        fp = font->props + font->props_size;
-        (void) memset((char *) fp, 0, sizeof(bdf_property_t));
-        font->props_size++;
-    }
+	/*
+	 * Allocate another property if this is overflow.
+	 */
+	if (font->props_used == font->props_size) {
+		if (font->props_size == 0)
+			font->props = (bdf_property_t *) malloc(sizeof(bdf_property_t));
+		else
+			font->props = (bdf_property_t *)
+			              realloc((char *) font->props, sizeof(bdf_property_t) *
+			                      (font->props_size + 1));
+		fp = font->props + font->props_size;
+		(void) memset((char *) fp, 0, sizeof(bdf_property_t));
+		font->props_size++;
+	}
 
-    propid = (unsigned long) hn->data;
-    if (propid >= _num_bdf_properties)
-      prop = user_props + (propid - _num_bdf_properties);
-    else
-      prop = _bdf_properties + propid;
+	propid = (unsigned long) hn->data;
+	if (propid >= _num_bdf_properties)
+		prop = user_props + (propid - _num_bdf_properties);
+	else
+		prop = _bdf_properties + propid;
 
-    fp = font->props + font->props_used;
+	fp = font->props + font->props_used;
 
-    fp->name = prop->name;
-    fp->format = prop->format;
-    fp->builtin = prop->builtin;
+	fp->name = prop->name;
+	fp->format = prop->format;
+	fp->builtin = prop->builtin;
 
-    switch (prop->format) {
-      case BDF_ATOM:
-        if (value == 0)
-          len = 1;
-        else
-          len = strlen(value) + 1;
-        if (len > 1) {
-            fp->value.atom = (char *) malloc(len);
-            (void) memcpy(fp->value.atom, value, len);
-        } else
-          fp->value.atom = 0;
-        break;
-      case BDF_INTEGER:
-        fp->value.int32 = _bdf_atol(value, 0, 10);
-        break;
-      case BDF_CARDINAL:
-        fp->value.card32 = _bdf_atoul(value, 0, 10);
-        break;
-    }
+	switch (prop->format) {
+	case BDF_ATOM:
+		if (value == 0)
+			len = 1;
+		else
+			len = strlen(value) + 1;
+		if (len > 1) {
+			fp->value.atom = (char *) malloc(len);
+			(void) memcpy(fp->value.atom, value, len);
+		} else
+			fp->value.atom = 0;
+		break;
+	case BDF_INTEGER:
+		fp->value.int32 = _bdf_atol(value, 0, 10);
+		break;
+	case BDF_CARDINAL:
+		fp->value.card32 = _bdf_atoul(value, 0, 10);
+		break;
+	}
 
-    /*
-     * If the property happens to be a comment, then it doesn't need
-     * to be added to the internal hash table.
-     */
-    if (memcmp(name, "COMMENT", 7) != 0)
-      /*
-       * Add the property to the font property table.
-       */
-      hash_insert(fp->name, (void *) font->props_used,
-                  (hashtable *) font->internal);
+	/*
+	 * If the property happens to be a comment, then it doesn't need
+	 * to be added to the internal hash table.
+	 */
+	if (memcmp(name, "COMMENT", 7) != 0)
+		/*
+		 * Add the property to the font property table.
+		 */
+		hash_insert(fp->name, (void *) font->props_used,
+		            (hashtable *) font->internal);
 
-    font->props_used++;
+	font->props_used++;
 
-    /*
-     * Some special cases need to be handled here.  The DEFAULT_CHAR property
-     * needs to be located if it exists in the property list, the FONT_ASCENT
-     * and FONT_DESCENT need to be assigned if they are present, and the
-     * SPACING property should override the default spacing.
-     */
-    if (memcmp(name, "DEFAULT_CHAR", 12) == 0)
-      font->default_glyph = fp->value.int32;
-    else if (memcmp(name, "FONT_ASCENT", 11) == 0)
-      font->font_ascent = fp->value.int32;
-    else if (memcmp(name, "FONT_DESCENT", 12) == 0)
-      font->font_descent = fp->value.int32;
-    else if (memcmp(name, "SPACING", 7) == 0) {
-        if (fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P')
-          font->spacing = BDF_PROPORTIONAL;
-        else if (fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M')
-          font->spacing = BDF_MONOWIDTH;
-        else if (fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C')
-          font->spacing = BDF_CHARCELL;
-    }
+	/*
+	 * Some special cases need to be handled here.  The DEFAULT_CHAR property
+	 * needs to be located if it exists in the property list, the FONT_ASCENT
+	 * and FONT_DESCENT need to be assigned if they are present, and the
+	 * SPACING property should override the default spacing.
+	 */
+	if (memcmp(name, "DEFAULT_CHAR", 12) == 0)
+		font->default_glyph = fp->value.int32;
+	else if (memcmp(name, "FONT_ASCENT", 11) == 0)
+		font->font_ascent = fp->value.int32;
+	else if (memcmp(name, "FONT_DESCENT", 12) == 0)
+		font->font_descent = fp->value.int32;
+	else if (memcmp(name, "SPACING", 7) == 0) {
+		if (fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P')
+			font->spacing = BDF_PROPORTIONAL;
+		else if (fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M')
+			font->spacing = BDF_MONOWIDTH;
+		else if (fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C')
+			font->spacing = BDF_CHARCELL;
+	}
 }
 
 /*
@@ -1359,413 +1404,413 @@
 void *call_data, *client_data;
 #endif
 {
-    int c;
-    char *s;
-    unsigned char *bp;
-    unsigned long i, slen, nibbles;
-    double ps, rx, dw, sw;
-    _bdf_line_func_t *next;
-    _bdf_parse_t *p;
-    bdf_glyph_t *glyph;
-    bdf_font_t *font;
-    char nbuf[128];
+	int c;
+	char *s;
+	unsigned char *bp;
+	unsigned long i, slen, nibbles;
+	double ps, rx, dw, sw;
+	_bdf_line_func_t *next;
+	_bdf_parse_t *p;
+	bdf_glyph_t *glyph;
+	bdf_font_t *font;
+	char nbuf[128];
 
-    next = (_bdf_line_func_t *) call_data;
-    p = (_bdf_parse_t *) client_data;
+	next = (_bdf_line_func_t *) call_data;
+	p = (_bdf_parse_t *) client_data;
 
-    font = p->font;
+	font = p->font;
 
-    /*
-     * Check for a comment.
-     */
-    if (memcmp(line, "COMMENT", 7) == 0) {
-        linelen -= 7;
-        s = line + 7;
-        if (*s != 0) {
-            s++;
-            linelen--;
-        }
-        _bdf_add_comment(p->font, s, linelen);
-        return 0;
-    }
+	/*
+	 * Check for a comment.
+	 */
+	if (memcmp(line, "COMMENT", 7) == 0) {
+		linelen -= 7;
+		s = line + 7;
+		if (*s != 0) {
+			s++;
+			linelen--;
+		}
+		_bdf_add_comment(p->font, s, linelen);
+		return 0;
+	}
 
-    /*
-     * The very first thing expected is the number of glyphs.
-     */
-    if (!(p->flags & _BDF_GLYPHS)) {
-        if (memcmp(line, "CHARS", 5) != 0) {
-            sprintf(nbuf, ERRMSG1, lineno, "CHARS");
-            _bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
-            return BDF_MISSING_CHARS;
-        }
-        _bdf_split(" +", line, linelen, &p->list);
-        p->cnt = font->glyphs_size = _bdf_atoul(p->list.field[1], 0, 10);
+	/*
+	 * The very first thing expected is the number of glyphs.
+	 */
+	if (!(p->flags & _BDF_GLYPHS)) {
+		if (memcmp(line, "CHARS", 5) != 0) {
+			sprintf(nbuf, ERRMSG1, lineno, "CHARS");
+			_bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
+			return BDF_MISSING_CHARS;
+		}
+		_bdf_split(" +", line, linelen, &p->list);
+		p->cnt = font->glyphs_size = _bdf_atoul(p->list.field[1], 0, 10);
 
-        /*
-         * Make sure the number of glyphs is non-zero.
-         */
-        if (p->cnt == 0)
-          font->glyphs_size = 64;
+		/*
+		 * Make sure the number of glyphs is non-zero.
+		 */
+		if (p->cnt == 0)
+			font->glyphs_size = 64;
 
-        font->glyphs = (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) *
-                                              font->glyphs_size);
+		font->glyphs = (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) *
+		                                      font->glyphs_size);
 
-        /*
-         * Set up the callback to indicate the glyph loading is about to
-         * begin.
-         */
-        if (p->callback != 0) {
-            p->cb.reason = BDF_LOAD_START;
-            p->cb.total = p->cnt;
-            p->cb.current = 0;
-            (*p->callback)(&p->cb, p->client_data);
-        }
-        p->flags |= _BDF_GLYPHS;
-        return 0;
-    }
+		/*
+		 * Set up the callback to indicate the glyph loading is about to
+		 * begin.
+		 */
+		if (p->callback != 0) {
+			p->cb.reason = BDF_LOAD_START;
+			p->cb.total = p->cnt;
+			p->cb.current = 0;
+			(*p->callback)(&p->cb, p->client_data);
+		}
+		p->flags |= _BDF_GLYPHS;
+		return 0;
+	}
 
-    /*
-     * Check for the ENDFONT field.
-     */
-    if (memcmp(line, "ENDFONT", 7) == 0) {
-        /*
-         * Sort the glyphs by encoding.
-         */
-        qsort((char *) font->glyphs, font->glyphs_used, sizeof(bdf_glyph_t),
-              by_encoding);
+	/*
+	 * Check for the ENDFONT field.
+	 */
+	if (memcmp(line, "ENDFONT", 7) == 0) {
+		/*
+		 * Sort the glyphs by encoding.
+		 */
+		qsort((char *) font->glyphs, font->glyphs_used, sizeof(bdf_glyph_t),
+		      by_encoding);
 
-        p->flags &= ~_BDF_START;
-        return 0;
-    }
+		p->flags &= ~_BDF_START;
+		return 0;
+	}
 
-    /*
-     * Check for the ENDCHAR field.
-     */
-    if (memcmp(line, "ENDCHAR", 7) == 0) {
-        /*
-         * Set up and call the callback if it was passed.
-         */
-        if (p->callback != 0) {
-            p->cb.reason = BDF_LOADING;
-            p->cb.total = font->glyphs_size;
-            p->cb.current = font->glyphs_used;
-            (*p->callback)(&p->cb, p->client_data);
-        }
-        p->glyph_enc = 0;
-        p->flags &= ~_BDF_GLYPH_BITS;
-        return 0;
-    }
+	/*
+	 * Check for the ENDCHAR field.
+	 */
+	if (memcmp(line, "ENDCHAR", 7) == 0) {
+		/*
+		 * Set up and call the callback if it was passed.
+		 */
+		if (p->callback != 0) {
+			p->cb.reason = BDF_LOADING;
+			p->cb.total = font->glyphs_size;
+			p->cb.current = font->glyphs_used;
+			(*p->callback)(&p->cb, p->client_data);
+		}
+		p->glyph_enc = 0;
+		p->flags &= ~_BDF_GLYPH_BITS;
+		return 0;
+	}
 
-    /*
-     * Check to see if a glyph is being scanned but should be ignored
-     * because it is an unencoded glyph.
-     */
-    if ((p->flags & _BDF_GLYPH) &&
-        p->glyph_enc == -1 && p->opts->keep_unencoded == 0)
-      return 0;
+	/*
+	 * Check to see if a glyph is being scanned but should be ignored
+	 * because it is an unencoded glyph.
+	 */
+	if ((p->flags & _BDF_GLYPH) &&
+	        p->glyph_enc == -1 && p->opts->keep_unencoded == 0)
+		return 0;
 
-    /*
-     * Check for the STARTCHAR field.
-     */
-    if (memcmp(line, "STARTCHAR", 9) == 0) {
-        /*
-         * Set the character name in the parse info first until the
-         * encoding can be checked for an unencoded character.
-         */
-        if (p->glyph_name != 0)
-          free(p->glyph_name);
-        _bdf_split(" +", line, linelen, &p->list);
-        _bdf_shift(1, &p->list);
-        s = _bdf_join(' ', &slen, &p->list);
-        p->glyph_name = (char *) malloc(slen + 1);
-        (void) memcpy(p->glyph_name, s, slen + 1);
-        p->flags |= _BDF_GLYPH;
-        return 0;
-    }
+	/*
+	 * Check for the STARTCHAR field.
+	 */
+	if (memcmp(line, "STARTCHAR", 9) == 0) {
+		/*
+		 * Set the character name in the parse info first until the
+		 * encoding can be checked for an unencoded character.
+		 */
+		if (p->glyph_name != 0)
+			free(p->glyph_name);
+		_bdf_split(" +", line, linelen, &p->list);
+		_bdf_shift(1, &p->list);
+		s = _bdf_join(' ', &slen, &p->list);
+		p->glyph_name = (char *) malloc(slen + 1);
+		(void) memcpy(p->glyph_name, s, slen + 1);
+		p->flags |= _BDF_GLYPH;
+		return 0;
+	}
 
-    /*
-     * Check for the ENCODING field.
-     */
-    if (memcmp(line, "ENCODING", 8) == 0) {
-        if (!(p->flags & _BDF_GLYPH)) {
-            /*
-             * Missing STARTCHAR field.
-             */
-            sprintf(nbuf, ERRMSG1, lineno, "STARTCHAR");
-            _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-            return BDF_MISSING_STARTCHAR;
-        }
-        _bdf_split(" +", line, linelen, &p->list);
-        p->glyph_enc = _bdf_atol(p->list.field[1], 0, 10);
+	/*
+	 * Check for the ENCODING field.
+	 */
+	if (memcmp(line, "ENCODING", 8) == 0) {
+		if (!(p->flags & _BDF_GLYPH)) {
+			/*
+			 * Missing STARTCHAR field.
+			 */
+			sprintf(nbuf, ERRMSG1, lineno, "STARTCHAR");
+			_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+			return BDF_MISSING_STARTCHAR;
+		}
+		_bdf_split(" +", line, linelen, &p->list);
+		p->glyph_enc = _bdf_atol(p->list.field[1], 0, 10);
 
-        /*
-         * Check to see if this encoding has already been encountered.  If it
-         * has then change it to unencoded so it gets added if indicated.
-         */
-        if (p->glyph_enc >= 0) {
-            if (_bdf_glyph_modified(p->have, p->glyph_enc)) {
-                /*
-                 * Add a message saying a glyph has been moved to the
-                 * unencoded area.
-                 */
-                sprintf(nbuf, ACMSG12, p->glyph_enc, p->glyph_name);
-                _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-                p->glyph_enc = -1;
-                font->modified = 1;
-            } else
-              _bdf_set_glyph_modified(p->have, p->glyph_enc);
-        }
+		/*
+		 * Check to see if this encoding has already been encountered.  If it
+		 * has then change it to unencoded so it gets added if indicated.
+		 */
+		if (p->glyph_enc >= 0) {
+			if (_bdf_glyph_modified(p->have, p->glyph_enc)) {
+				/*
+				 * Add a message saying a glyph has been moved to the
+				 * unencoded area.
+				 */
+				sprintf(nbuf, ACMSG12, p->glyph_enc, p->glyph_name);
+				_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+				p->glyph_enc = -1;
+				font->modified = 1;
+			} else
+				_bdf_set_glyph_modified(p->have, p->glyph_enc);
+		}
 
-        if (p->glyph_enc >= 0) {
-            /*
-             * Make sure there are enough glyphs allocated in case the
-             * number of characters happen to be wrong.
-             */
-            if (font->glyphs_used == font->glyphs_size) {
-                font->glyphs = (bdf_glyph_t *)
-                    realloc((char *) font->glyphs,
-                            sizeof(bdf_glyph_t) * (font->glyphs_size + 64));
-                (void) memset((char *) (font->glyphs + font->glyphs_size),
-                              0, sizeof(bdf_glyph_t) << 6);
-                font->glyphs_size += 64;
-            }
+		if (p->glyph_enc >= 0) {
+			/*
+			 * Make sure there are enough glyphs allocated in case the
+			 * number of characters happen to be wrong.
+			 */
+			if (font->glyphs_used == font->glyphs_size) {
+				font->glyphs = (bdf_glyph_t *)
+				               realloc((char *) font->glyphs,
+				                       sizeof(bdf_glyph_t) * (font->glyphs_size + 64));
+				(void) memset((char *)(font->glyphs + font->glyphs_size),
+				              0, sizeof(bdf_glyph_t) << 6);
+				font->glyphs_size += 64;
+			}
 
-            glyph = font->glyphs + font->glyphs_used++;
-            glyph->name = p->glyph_name;
-            glyph->encoding = p->glyph_enc;
+			glyph = font->glyphs + font->glyphs_used++;
+			glyph->name = p->glyph_name;
+			glyph->encoding = p->glyph_enc;
 
-            /*
-             * Reset the initial glyph info.
-             */
-            p->glyph_name = 0;
-        } else {
-            /*
-             * Unencoded glyph.  Check to see if it should be added or not.
-             */
-            if (p->opts->keep_unencoded != 0) {
-                /*
-                 * Allocate the next unencoded glyph.
-                 */
-                if (font->unencoded_used == font->unencoded_size) {
-                    if (font->unencoded_size == 0)
-                      font->unencoded = (bdf_glyph_t *)
-                          malloc(sizeof(bdf_glyph_t) << 2);
-                    else
-                      font->unencoded = (bdf_glyph_t *)
-                          realloc((char *) font->unencoded,
-                                  sizeof(bdf_glyph_t) *
-                                  (font->unencoded_size + 4));
-                    font->unencoded_size += 4;
-                }
+			/*
+			 * Reset the initial glyph info.
+			 */
+			p->glyph_name = 0;
+		} else {
+			/*
+			 * Unencoded glyph.  Check to see if it should be added or not.
+			 */
+			if (p->opts->keep_unencoded != 0) {
+				/*
+				 * Allocate the next unencoded glyph.
+				 */
+				if (font->unencoded_used == font->unencoded_size) {
+					if (font->unencoded_size == 0)
+						font->unencoded = (bdf_glyph_t *)
+						                  malloc(sizeof(bdf_glyph_t) << 2);
+					else
+						font->unencoded = (bdf_glyph_t *)
+						                  realloc((char *) font->unencoded,
+						                          sizeof(bdf_glyph_t) *
+						                          (font->unencoded_size + 4));
+					font->unencoded_size += 4;
+				}
 
-                glyph = font->unencoded + font->unencoded_used;
-                glyph->name = p->glyph_name;
-                glyph->encoding = font->unencoded_used++;
-            } else
-              /*
-               * Free up the glyph name if the unencoded shouldn't be
-               * kept.
-               */
-              free(p->glyph_name);
+				glyph = font->unencoded + font->unencoded_used;
+				glyph->name = p->glyph_name;
+				glyph->encoding = font->unencoded_used++;
+			} else
+				/*
+				 * Free up the glyph name if the unencoded shouldn't be
+				 * kept.
+				 */
+				free(p->glyph_name);
 
-            p->glyph_name = 0;
-        }
+			p->glyph_name = 0;
+		}
 
-        /*
-         * Clear the flags that might be added when width and height are
-         * checked for consistency.
-         */
-        p->flags &= ~(_BDF_GLYPH_WIDTH_CHECK|_BDF_GLYPH_HEIGHT_CHECK);
+		/*
+		 * Clear the flags that might be added when width and height are
+		 * checked for consistency.
+		 */
+		p->flags &= ~(_BDF_GLYPH_WIDTH_CHECK | _BDF_GLYPH_HEIGHT_CHECK);
 
-        p->flags |= _BDF_ENCODING;
-        return 0;
-    }
+		p->flags |= _BDF_ENCODING;
+		return 0;
+	}
 
-    /*
-     * Point at the glyph being constructed.
-     */
-    if (p->glyph_enc == -1)
-      glyph = font->unencoded + (font->unencoded_used - 1);
-    else
-      glyph = font->glyphs + (font->glyphs_used - 1);
+	/*
+	 * Point at the glyph being constructed.
+	 */
+	if (p->glyph_enc == -1)
+		glyph = font->unencoded + (font->unencoded_used - 1);
+	else
+		glyph = font->glyphs + (font->glyphs_used - 1);
 
-    /*
-     * Check to see if a bitmap is being constructed.
-     */
-    if (p->flags & _BDF_BITMAP) {
-        /*
-         * If there are more rows than are specified in the glyph metrics,
-         * ignore the remaining lines.
-         */
-        if (p->row >= glyph->bbx.height) {
-            if (!(p->flags & _BDF_GLYPH_HEIGHT_CHECK)) {
-                sprintf(nbuf, ACMSG13, glyph->encoding);
-                _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-                p->flags |= _BDF_GLYPH_HEIGHT_CHECK;
-                font->modified = 1;
-            }
-            return 0;
-        }
+	/*
+	 * Check to see if a bitmap is being constructed.
+	 */
+	if (p->flags & _BDF_BITMAP) {
+		/*
+		 * If there are more rows than are specified in the glyph metrics,
+		 * ignore the remaining lines.
+		 */
+		if (p->row >= glyph->bbx.height) {
+			if (!(p->flags & _BDF_GLYPH_HEIGHT_CHECK)) {
+				sprintf(nbuf, ACMSG13, glyph->encoding);
+				_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+				p->flags |= _BDF_GLYPH_HEIGHT_CHECK;
+				font->modified = 1;
+			}
+			return 0;
+		}
 
-        /*
-         * Only collect the number of nibbles indicated by the glyph metrics.
-         * If there are more columns, they are simply ignored.
-         */
-        nibbles = p->bpr << 1;
-        bp = glyph->bitmap + (p->row * p->bpr);
-        for (i = 0, *bp = 0; i < nibbles; i++) {
-            c = line[i];
-            *bp = (*bp << 4) + a2i[c];
-            if (i + 1 < nibbles && (i & 1))
-              *++bp = 0;
-        }
+		/*
+		 * Only collect the number of nibbles indicated by the glyph metrics.
+		 * If there are more columns, they are simply ignored.
+		 */
+		nibbles = p->bpr << 1;
+		bp = glyph->bitmap + (p->row * p->bpr);
+		for (i = 0, *bp = 0; i < nibbles; i++) {
+			c = line[i];
+			*bp = (*bp << 4) + a2i[c];
+			if (i + 1 < nibbles && (i & 1))
+				*++bp = 0;
+		}
 
-        /*
-         * If any line has extra columns, indicate they have been removed.
-         */
-        if ((line[nibbles] == '0' || a2i[(int) line[nibbles]] != 0) &&
-            !(p->flags & _BDF_GLYPH_WIDTH_CHECK)) {
-            sprintf(nbuf, ACMSG14, glyph->encoding);
-            _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-            p->flags |= _BDF_GLYPH_WIDTH_CHECK;
-            font->modified = 1;
-        }
+		/*
+		 * If any line has extra columns, indicate they have been removed.
+		 */
+		if ((line[nibbles] == '0' || a2i[(int) line[nibbles]] != 0) &&
+		        !(p->flags & _BDF_GLYPH_WIDTH_CHECK)) {
+			sprintf(nbuf, ACMSG14, glyph->encoding);
+			_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+			p->flags |= _BDF_GLYPH_WIDTH_CHECK;
+			font->modified = 1;
+		}
 
-        p->row++;
-        return 0;
-    }
+		p->row++;
+		return 0;
+	}
 
-    /*
-     * Expect the SWIDTH (scalable width) field next.
-     */
-    if (memcmp(line, "SWIDTH", 6) == 0) {
-        if (!(p->flags & _BDF_ENCODING)) {
-            /*
-             * Missing ENCODING field.
-             */
-            sprintf(nbuf, ERRMSG1, lineno, "ENCODING");
-            _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-            return BDF_MISSING_ENCODING;
-        }
-        _bdf_split(" +", line, linelen, &p->list);
-        glyph->swidth = _bdf_atoul(p->list.field[1], 0, 10);
-        p->flags |= _BDF_SWIDTH;
-        return 0;
-    }
+	/*
+	 * Expect the SWIDTH (scalable width) field next.
+	 */
+	if (memcmp(line, "SWIDTH", 6) == 0) {
+		if (!(p->flags & _BDF_ENCODING)) {
+			/*
+			 * Missing ENCODING field.
+			 */
+			sprintf(nbuf, ERRMSG1, lineno, "ENCODING");
+			_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+			return BDF_MISSING_ENCODING;
+		}
+		_bdf_split(" +", line, linelen, &p->list);
+		glyph->swidth = _bdf_atoul(p->list.field[1], 0, 10);
+		p->flags |= _BDF_SWIDTH;
+		return 0;
+	}
 
-    /*
-     * Expect the DWIDTH (scalable width) field next.
-     */
-    if (memcmp(line, "DWIDTH", 6) == 0) {
-        _bdf_split(" +", line, linelen, &p->list);
-        glyph->dwidth = _bdf_atoul(p->list.field[1], 0, 10);
+	/*
+	 * Expect the DWIDTH (scalable width) field next.
+	 */
+	if (memcmp(line, "DWIDTH", 6) == 0) {
+		_bdf_split(" +", line, linelen, &p->list);
+		glyph->dwidth = _bdf_atoul(p->list.field[1], 0, 10);
 
-        if (!(p->flags & _BDF_SWIDTH)) {
-            /*
-             * Missing SWIDTH field.  Add an auto correction message and set
-             * the scalable width from the device width.
-             */
-            sprintf(nbuf, ACMSG9, lineno);
-            _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-            ps = (double) font->point_size;
-            rx = (double) font->resolution_x;
-            dw = (double) glyph->dwidth;
-            glyph->swidth = (unsigned short) ((dw * 72000.0) / (ps * rx));
-        }
+		if (!(p->flags & _BDF_SWIDTH)) {
+			/*
+			 * Missing SWIDTH field.  Add an auto correction message and set
+			 * the scalable width from the device width.
+			 */
+			sprintf(nbuf, ACMSG9, lineno);
+			_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+			ps = (double) font->point_size;
+			rx = (double) font->resolution_x;
+			dw = (double) glyph->dwidth;
+			glyph->swidth = (unsigned short)((dw * 72000.0) / (ps * rx));
+		}
 
-        p->flags |= _BDF_DWIDTH;
-        return 0;
-    }
+		p->flags |= _BDF_DWIDTH;
+		return 0;
+	}
 
-    /*
-     * Expect the BBX field next.
-     */
-    if (memcmp(line, "BBX", 3) == 0) {
-        _bdf_split(" +", line, linelen, &p->list);
-        glyph->bbx.width = _bdf_atos(p->list.field[1], 0, 10);
-        glyph->bbx.height = _bdf_atos(p->list.field[2], 0, 10);
-        glyph->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10);
-        glyph->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10);
+	/*
+	 * Expect the BBX field next.
+	 */
+	if (memcmp(line, "BBX", 3) == 0) {
+		_bdf_split(" +", line, linelen, &p->list);
+		glyph->bbx.width = _bdf_atos(p->list.field[1], 0, 10);
+		glyph->bbx.height = _bdf_atos(p->list.field[2], 0, 10);
+		glyph->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10);
+		glyph->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10);
 
-        /*
-         * Generate the ascent and descent of the character.
-         */
-        glyph->bbx.ascent = glyph->bbx.height + glyph->bbx.y_offset;
-        glyph->bbx.descent = -glyph->bbx.y_offset;
+		/*
+		 * Generate the ascent and descent of the character.
+		 */
+		glyph->bbx.ascent = glyph->bbx.height + glyph->bbx.y_offset;
+		glyph->bbx.descent = -glyph->bbx.y_offset;
 
-        /*
-         * Determine the overall font bounding box as the characters are
-         * loaded so corrections can be done later if indicated.
-         */
-        p->maxas = MAX(glyph->bbx.ascent, p->maxas);
-        p->maxds = MAX(glyph->bbx.descent, p->maxds);
-        p->rbearing = glyph->bbx.width + glyph->bbx.x_offset;
-        p->maxrb = MAX(p->rbearing, p->maxrb);
-        p->minlb = MIN(glyph->bbx.x_offset, p->minlb);
-        p->maxlb = MAX(glyph->bbx.x_offset, p->maxlb);
+		/*
+		 * Determine the overall font bounding box as the characters are
+		 * loaded so corrections can be done later if indicated.
+		 */
+		p->maxas = MAX(glyph->bbx.ascent, p->maxas);
+		p->maxds = MAX(glyph->bbx.descent, p->maxds);
+		p->rbearing = glyph->bbx.width + glyph->bbx.x_offset;
+		p->maxrb = MAX(p->rbearing, p->maxrb);
+		p->minlb = MIN(glyph->bbx.x_offset, p->minlb);
+		p->maxlb = MAX(glyph->bbx.x_offset, p->maxlb);
 
-        if (!(p->flags & _BDF_DWIDTH)) {
-            /*
-             * Missing DWIDTH field.  Add an auto correction message and set
-             * the device width to the glyph width.
-             */
-            sprintf(nbuf, ACMSG10, lineno);
-            _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-            glyph->dwidth = glyph->bbx.width;
-        }
+		if (!(p->flags & _BDF_DWIDTH)) {
+			/*
+			 * Missing DWIDTH field.  Add an auto correction message and set
+			 * the device width to the glyph width.
+			 */
+			sprintf(nbuf, ACMSG10, lineno);
+			_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+			glyph->dwidth = glyph->bbx.width;
+		}
 
-        /*
-         * If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH
-         * value if necessary.
-         */
-        if (p->opts->correct_metrics != 0) {
-            /*
-             * Determine the point size of the glyph.
-             */
-            ps = (double) font->point_size;
-            rx = (double) font->resolution_x;
-            dw = (double) glyph->dwidth;
-            sw = (unsigned short) ((dw * 72000.0) / (ps * rx));
+		/*
+		 * If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH
+		 * value if necessary.
+		 */
+		if (p->opts->correct_metrics != 0) {
+			/*
+			 * Determine the point size of the glyph.
+			 */
+			ps = (double) font->point_size;
+			rx = (double) font->resolution_x;
+			dw = (double) glyph->dwidth;
+			sw = (unsigned short)((dw * 72000.0) / (ps * rx));
 
-            if (sw != glyph->swidth) {
-                glyph->swidth = (unsigned short) sw;
-                if (p->glyph_enc == -1)
-                  _bdf_set_glyph_modified(font->umod,
-                                          font->unencoded_used - 1);
-                else
-                  _bdf_set_glyph_modified(font->nmod, glyph->encoding);
-                p->flags |= _BDF_SWIDTH_ADJ;
-                font->modified = 1;
-            }
-        }
-        p->flags |= _BDF_BBX;
-        return 0;
-    }
+			if (sw != glyph->swidth) {
+				glyph->swidth = (unsigned short) sw;
+				if (p->glyph_enc == -1)
+					_bdf_set_glyph_modified(font->umod,
+					                        font->unencoded_used - 1);
+				else
+					_bdf_set_glyph_modified(font->nmod, glyph->encoding);
+				p->flags |= _BDF_SWIDTH_ADJ;
+				font->modified = 1;
+			}
+		}
+		p->flags |= _BDF_BBX;
+		return 0;
+	}
 
-    /*
-     * And finally, gather up the bitmap.
-     */
-    if (memcmp(line, "BITMAP", 6) == 0) {
-        if (!(p->flags & _BDF_BBX)) {
-            /*
-             * Missing BBX field.
-             */
-            sprintf(nbuf, ERRMSG1, lineno, "BBX");
-            _bdf_add_acmsg(font, nbuf, strlen(nbuf));
-            return BDF_MISSING_BBX;
-        }
-        /*
-         * Allocate enough space for the bitmap.
-         */
-        p->bpr = ((glyph->bbx.width * p->font->bpp) + 7) >> 3;
-        glyph->bytes = p->bpr * glyph->bbx.height;
-        glyph->bitmap = (unsigned char *) malloc(glyph->bytes);
-        p->row = 0;
-        p->flags |= _BDF_BITMAP;
-        return 0;
-    }
+	/*
+	 * And finally, gather up the bitmap.
+	 */
+	if (memcmp(line, "BITMAP", 6) == 0) {
+		if (!(p->flags & _BDF_BBX)) {
+			/*
+			 * Missing BBX field.
+			 */
+			sprintf(nbuf, ERRMSG1, lineno, "BBX");
+			_bdf_add_acmsg(font, nbuf, strlen(nbuf));
+			return BDF_MISSING_BBX;
+		}
+		/*
+		 * Allocate enough space for the bitmap.
+		 */
+		p->bpr = ((glyph->bbx.width * p->font->bpp) + 7) >> 3;
+		glyph->bytes = p->bpr * glyph->bbx.height;
+		glyph->bitmap = (unsigned char *) malloc(glyph->bytes);
+		p->row = 0;
+		p->flags |= _BDF_BITMAP;
+		return 0;
+	}
 
-    return BDF_INVALID_LINE;
+	return BDF_INVALID_LINE;
 }
 
 /*
@@ -1782,74 +1827,74 @@
 void *call_data, *client_data;
 #endif
 {
-    unsigned long vlen;
-    _bdf_line_func_t *next;
-    _bdf_parse_t *p;
-    char *name, *value, nbuf[128];
+	unsigned long vlen;
+	_bdf_line_func_t *next;
+	_bdf_parse_t *p;
+	char *name, *value, nbuf[128];
 
-    next = (_bdf_line_func_t *) call_data;
-    p = (_bdf_parse_t *) client_data;
+	next = (_bdf_line_func_t *) call_data;
+	p = (_bdf_parse_t *) client_data;
 
-    /*
-     * Check for the end of the properties.
-     */
-    if (memcmp(line, "ENDPROPERTIES", 13) == 0) {
-        /*
-         * If the FONT_ASCENT or FONT_DESCENT properties have not been
-         * encountered yet, then make sure they are added as properties and
-         * make sure they are set from the font bounding box info.
-         *
-         * This is *always* done regardless of the options, because X11
-         * requires these two fields to compile fonts.
-         */
-        if (bdf_get_font_property(p->font, "FONT_ASCENT") == 0) {
-            p->font->font_ascent = p->font->bbx.ascent;
-            sprintf(nbuf, "%hd", p->font->bbx.ascent);
-            _bdf_add_property(p->font, "FONT_ASCENT", nbuf);
-            sprintf(nbuf, ACMSG1, p->font->bbx.ascent);
-            _bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
-            p->font->modified = 1;
-        }
-        if (bdf_get_font_property(p->font, "FONT_DESCENT") == 0) {
-            p->font->font_descent = p->font->bbx.descent;
-            sprintf(nbuf, "%hd", p->font->bbx.descent);
-            _bdf_add_property(p->font, "FONT_DESCENT", nbuf);
-            sprintf(nbuf, ACMSG2, p->font->bbx.descent);
-            _bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
-            p->font->modified = 1;
-        }
-        p->flags &= ~_BDF_PROPS;
-        *next = _bdf_parse_glyphs;
-        return 0;
-    }
+	/*
+	 * Check for the end of the properties.
+	 */
+	if (memcmp(line, "ENDPROPERTIES", 13) == 0) {
+		/*
+		 * If the FONT_ASCENT or FONT_DESCENT properties have not been
+		 * encountered yet, then make sure they are added as properties and
+		 * make sure they are set from the font bounding box info.
+		 *
+		 * This is *always* done regardless of the options, because X11
+		 * requires these two fields to compile fonts.
+		 */
+		if (bdf_get_font_property(p->font, "FONT_ASCENT") == 0) {
+			p->font->font_ascent = p->font->bbx.ascent;
+			sprintf(nbuf, "%hd", p->font->bbx.ascent);
+			_bdf_add_property(p->font, "FONT_ASCENT", nbuf);
+			sprintf(nbuf, ACMSG1, p->font->bbx.ascent);
+			_bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
+			p->font->modified = 1;
+		}
+		if (bdf_get_font_property(p->font, "FONT_DESCENT") == 0) {
+			p->font->font_descent = p->font->bbx.descent;
+			sprintf(nbuf, "%hd", p->font->bbx.descent);
+			_bdf_add_property(p->font, "FONT_DESCENT", nbuf);
+			sprintf(nbuf, ACMSG2, p->font->bbx.descent);
+			_bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
+			p->font->modified = 1;
+		}
+		p->flags &= ~_BDF_PROPS;
+		*next = _bdf_parse_glyphs;
+		return 0;
+	}
 
-    /*
-     * Ignore the _XFREE86_GLYPH_RANGES properties.
-     */
-    if (memcmp(line, "_XFREE86_GLYPH_RANGES", 21) == 0)
-      return 0;
+	/*
+	 * Ignore the _XFREE86_GLYPH_RANGES properties.
+	 */
+	if (memcmp(line, "_XFREE86_GLYPH_RANGES", 21) == 0)
+		return 0;
 
-    /*
-     * Handle COMMENT fields and properties in a special way to preserve
-     * the spacing.
-     */
-    if (memcmp(line, "COMMENT", 7) == 0) {
-        name = value = line;
-        value += 7;
-        if (*value)
-          *value++ = 0;
-        _bdf_add_property(p->font, name, value);
-    } else if (_bdf_is_atom(line, linelen, &name, &value))
-      _bdf_add_property(p->font, name, value);
-    else {
-        _bdf_split(" +", line, linelen, &p->list);
-        name = p->list.field[0];
-        _bdf_shift(1, &p->list);
-        value = _bdf_join(' ', &vlen, &p->list);
-        _bdf_add_property(p->font, name, value);
-    }
+	/*
+	 * Handle COMMENT fields and properties in a special way to preserve
+	 * the spacing.
+	 */
+	if (memcmp(line, "COMMENT", 7) == 0) {
+		name = value = line;
+		value += 7;
+		if (*value)
+			*value++ = 0;
+		_bdf_add_property(p->font, name, value);
+	} else if (_bdf_is_atom(line, linelen, &name, &value))
+		_bdf_add_property(p->font, name, value);
+	else {
+		_bdf_split(" +", line, linelen, &p->list);
+		name = p->list.field[0];
+		_bdf_shift(1, &p->list);
+		value = _bdf_join(' ', &vlen, &p->list);
+		_bdf_add_property(p->font, name, value);
+	}
 
-    return 0;
+	return 0;
 }
 
 /*
@@ -1866,147 +1911,147 @@
 void *call_data, *client_data;
 #endif
 {
-    unsigned long slen;
-    _bdf_line_func_t *next;
-    _bdf_parse_t *p;
-    bdf_font_t *font;
-    char *s, nbuf[128];
+	unsigned long slen;
+	_bdf_line_func_t *next;
+	_bdf_parse_t *p;
+	bdf_font_t *font;
+	char *s, nbuf[128];
 
-    next = (_bdf_line_func_t *) call_data;
-    p = (_bdf_parse_t *) client_data;
+	next = (_bdf_line_func_t *) call_data;
+	p = (_bdf_parse_t *) client_data;
 
-    /*
-     * Check for a comment.  This is done to handle those fonts that have
-     * comments before the STARTFONT line for some reason.
-     */
-    if (memcmp(line, "COMMENT", 7) == 0) {
-        if (p->opts->keep_comments != 0 && p->font != 0) {
-            linelen -= 7;
-            s = line + 7;
-            if (*s != 0) {
-                s++;
-                linelen--;
-            }
-            _bdf_add_comment(p->font, s, linelen);
-        }
-        return 0;
-    }
+	/*
+	 * Check for a comment.  This is done to handle those fonts that have
+	 * comments before the STARTFONT line for some reason.
+	 */
+	if (memcmp(line, "COMMENT", 7) == 0) {
+		if (p->opts->keep_comments != 0 && p->font != 0) {
+			linelen -= 7;
+			s = line + 7;
+			if (*s != 0) {
+				s++;
+				linelen--;
+			}
+			_bdf_add_comment(p->font, s, linelen);
+		}
+		return 0;
+	}
 
-    if (!(p->flags & _BDF_START)) {
-        if (memcmp(line, "STARTFONT", 9) != 0)
-          /*
-           * No STARTFONT field is a good indication of a problem.
-           */
-          return BDF_MISSING_START;
-        p->flags = _BDF_START;
-        p->font = font = (bdf_font_t *) calloc(1, sizeof(bdf_font_t));
-        p->font->internal = (void *) malloc(sizeof(hashtable));
-        hash_init((hashtable *) p->font->internal);
-        p->font->spacing = p->opts->font_spacing;
-        p->font->default_glyph = -1;
-        return 0;
-    }
+	if (!(p->flags & _BDF_START)) {
+		if (memcmp(line, "STARTFONT", 9) != 0)
+			/*
+			 * No STARTFONT field is a good indication of a problem.
+			 */
+			return BDF_MISSING_START;
+		p->flags = _BDF_START;
+		p->font = font = (bdf_font_t *) calloc(1, sizeof(bdf_font_t));
+		p->font->internal = (void *) malloc(sizeof(hashtable));
+		hash_init((hashtable *) p->font->internal);
+		p->font->spacing = p->opts->font_spacing;
+		p->font->default_glyph = -1;
+		return 0;
+	}
 
-    /*
-     * Check for the start of the properties.
-     */
-    if (memcmp(line, "STARTPROPERTIES", 15) == 0) {
-        _bdf_split(" +", line, linelen, &p->list);
-        p->cnt = p->font->props_size = _bdf_atoul(p->list.field[1], 0, 10);
-        p->font->props = (bdf_property_t *)
-            malloc(sizeof(bdf_property_t) * p->cnt);
-        p->flags |= _BDF_PROPS;
-        *next = _bdf_parse_properties;
-        return 0;
-    }
+	/*
+	 * Check for the start of the properties.
+	 */
+	if (memcmp(line, "STARTPROPERTIES", 15) == 0) {
+		_bdf_split(" +", line, linelen, &p->list);
+		p->cnt = p->font->props_size = _bdf_atoul(p->list.field[1], 0, 10);
+		p->font->props = (bdf_property_t *)
+		                 malloc(sizeof(bdf_property_t) * p->cnt);
+		p->flags |= _BDF_PROPS;
+		*next = _bdf_parse_properties;
+		return 0;
+	}
 
-    /*
-     * Check for the FONTBOUNDINGBOX field.
-     */
-    if (memcmp(line, "FONTBOUNDINGBOX", 15) == 0) {
-        if (!(p->flags & _BDF_SIZE)) {
-            /*
-             * Missing the SIZE field.
-             */
-            sprintf(nbuf, ERRMSG1, lineno, "SIZE");
-            _bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
-            return BDF_MISSING_SIZE;
-        }
-        _bdf_split(" +", line, linelen, &p->list);
-        p->font->bbx.width = _bdf_atos(p->list.field[1], 0, 10);
-        p->font->bbx.height = _bdf_atos(p->list.field[2], 0, 10);
-        p->font->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10);
-        p->font->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10);
-        p->font->bbx.ascent = p->font->bbx.height + p->font->bbx.y_offset;
-        p->font->bbx.descent = -p->font->bbx.y_offset;
-        p->flags |= _BDF_FONT_BBX;
-        return 0;
-    }
+	/*
+	 * Check for the FONTBOUNDINGBOX field.
+	 */
+	if (memcmp(line, "FONTBOUNDINGBOX", 15) == 0) {
+		if (!(p->flags & _BDF_SIZE)) {
+			/*
+			 * Missing the SIZE field.
+			 */
+			sprintf(nbuf, ERRMSG1, lineno, "SIZE");
+			_bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
+			return BDF_MISSING_SIZE;
+		}
+		_bdf_split(" +", line, linelen, &p->list);
+		p->font->bbx.width = _bdf_atos(p->list.field[1], 0, 10);
+		p->font->bbx.height = _bdf_atos(p->list.field[2], 0, 10);
+		p->font->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10);
+		p->font->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10);
+		p->font->bbx.ascent = p->font->bbx.height + p->font->bbx.y_offset;
+		p->font->bbx.descent = -p->font->bbx.y_offset;
+		p->flags |= _BDF_FONT_BBX;
+		return 0;
+	}
 
-    /*
-     * The next thing to check for is the FONT field.
-     */
-    if (memcmp(line, "FONT", 4) == 0) {
-        _bdf_split(" +", line, linelen, &p->list);
-        _bdf_shift(1, &p->list);
-        s = _bdf_join(' ', &slen, &p->list);
-        p->font->name = (char *) malloc(slen + 1);
-        (void) memcpy(p->font->name, s, slen + 1);
-        /*
-         * If the font name is an XLFD name, set the spacing to the one in the
-         * font name.  If there is no spacing fall back on the default.
-         */
-        _bdf_set_default_spacing(p->font, p->opts);
-        p->flags |= _BDF_FONT_NAME;
-        return 0;
-    }
+	/*
+	 * The next thing to check for is the FONT field.
+	 */
+	if (memcmp(line, "FONT", 4) == 0) {
+		_bdf_split(" +", line, linelen, &p->list);
+		_bdf_shift(1, &p->list);
+		s = _bdf_join(' ', &slen, &p->list);
+		p->font->name = (char *) malloc(slen + 1);
+		(void) memcpy(p->font->name, s, slen + 1);
+		/*
+		 * If the font name is an XLFD name, set the spacing to the one in the
+		 * font name.  If there is no spacing fall back on the default.
+		 */
+		_bdf_set_default_spacing(p->font, p->opts);
+		p->flags |= _BDF_FONT_NAME;
+		return 0;
+	}
 
-    /*
-     * Check for the SIZE field.
-     */
-    if (memcmp(line, "SIZE", 4) == 0) {
-        if (!(p->flags & _BDF_FONT_NAME)) {
-            /*
-             * Missing the FONT field.
-             */
-            sprintf(nbuf, ERRMSG1, lineno, "FONT");
-            _bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
-            return BDF_MISSING_FONTNAME;
-        }
-        _bdf_split(" +", line, linelen, &p->list);
-        p->font->point_size = _bdf_atoul(p->list.field[1], 0, 10);
-        p->font->resolution_x = _bdf_atoul(p->list.field[2], 0, 10);
-        p->font->resolution_y = _bdf_atoul(p->list.field[3], 0, 10);
+	/*
+	 * Check for the SIZE field.
+	 */
+	if (memcmp(line, "SIZE", 4) == 0) {
+		if (!(p->flags & _BDF_FONT_NAME)) {
+			/*
+			 * Missing the FONT field.
+			 */
+			sprintf(nbuf, ERRMSG1, lineno, "FONT");
+			_bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
+			return BDF_MISSING_FONTNAME;
+		}
+		_bdf_split(" +", line, linelen, &p->list);
+		p->font->point_size = _bdf_atoul(p->list.field[1], 0, 10);
+		p->font->resolution_x = _bdf_atoul(p->list.field[2], 0, 10);
+		p->font->resolution_y = _bdf_atoul(p->list.field[3], 0, 10);
 
-        /*
-         * Check for the bits per pixel field.
-         */
-        if (p->list.used == 5) {
-            p->font->bpp = _bdf_atos(p->list.field[4], 0, 10);
-            if (p->font->bpp > 1 && (p->font->bpp & 1)) {
-                /*
-                 * Move up to the next bits per pixel value if an odd number
-                 * is encountered.
-                 */
-                p->font->bpp++;
-                if (p->font->bpp <= 4) {
-                    sprintf(nbuf, ACMSG11, p->font->bpp);
-                    _bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
-                }
-            }
-            if (p->font->bpp > 4) {
-                sprintf(nbuf, ACMSG11, p->font->bpp);
-                _bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
-                p->font->bpp = 4;
-            }
-        } else
-          p->font->bpp = 1;
+		/*
+		 * Check for the bits per pixel field.
+		 */
+		if (p->list.used == 5) {
+			p->font->bpp = _bdf_atos(p->list.field[4], 0, 10);
+			if (p->font->bpp > 1 && (p->font->bpp & 1)) {
+				/*
+				 * Move up to the next bits per pixel value if an odd number
+				 * is encountered.
+				 */
+				p->font->bpp++;
+				if (p->font->bpp <= 4) {
+					sprintf(nbuf, ACMSG11, p->font->bpp);
+					_bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
+				}
+			}
+			if (p->font->bpp > 4) {
+				sprintf(nbuf, ACMSG11, p->font->bpp);
+				_bdf_add_acmsg(p->font, nbuf, strlen(nbuf));
+				p->font->bpp = 4;
+			}
+		} else
+			p->font->bpp = 1;
 
-        p->flags |= _BDF_SIZE;
-        return 0;
-    }
+		p->flags |= _BDF_SIZE;
+		return 0;
+	}
 
-    return BDF_INVALID_LINE;
+	return BDF_INVALID_LINE;
 }
 
 /**************************************************************************
@@ -2022,12 +2067,12 @@
 bdf_setup()
 #endif
 {
-    unsigned long i;
-    bdf_property_t *prop;
+	unsigned long i;
+	bdf_property_t *prop;
 
-    hash_init(&proptbl);
-    for (i = 0, prop = _bdf_properties; i < _num_bdf_properties; i++, prop++)
-      hash_insert(prop->name, (void *) i, &proptbl);
+	hash_init(&proptbl);
+	for (i = 0, prop = _bdf_properties; i < _num_bdf_properties; i++, prop++)
+		hash_insert(prop->name, (void *) i, &proptbl);
 }
 
 void
@@ -2037,23 +2082,23 @@
 bdf_cleanup()
 #endif
 {
-    unsigned long i;
-    bdf_property_t *prop;
+	unsigned long i;
+	bdf_property_t *prop;
 
-    hash_free(&proptbl);
+	hash_free(&proptbl);
 
-    /*
-     * Free up the user defined properties.
-     */
-    for (prop = user_props, i = 0; i < nuser_props; i++, prop++) {
-        free(prop->name);
-        if (prop->format == BDF_ATOM && prop->value.atom != 0)
-          free(prop->value.atom);
-    }
-    if (nuser_props > 0)
-      free((char *) user_props);
+	/*
+	 * Free up the user defined properties.
+	 */
+	for (prop = user_props, i = 0; i < nuser_props; i++, prop++) {
+		free(prop->name);
+		if (prop->format == BDF_ATOM && prop->value.atom != 0)
+			free(prop->value.atom);
+	}
+	if (nuser_props > 0)
+		free((char *) user_props);
 
-    _bdf_glyph_name_cleanup();
+	_bdf_glyph_name_cleanup();
 }
 
 bdf_font_t *
@@ -2068,149 +2113,149 @@
 void *data;
 #endif
 {
-    int n;
-    unsigned long lineno;
-    char msgbuf[128];
-    _bdf_parse_t p;
+	int n;
+	unsigned long lineno;
+	char msgbuf[128];
+	_bdf_parse_t p;
 
-    (void) memset((char *) &p, 0, sizeof(_bdf_parse_t));
-    p.opts = (opts != 0) ? opts : &_bdf_opts;
-    p.minlb = 32767;
-    p.callback = callback;
-    p.client_data = data;
-    n = _bdf_readlines(fileno(in), _bdf_parse_start, (void *) &p, &lineno);
+	(void) memset((char *) &p, 0, sizeof(_bdf_parse_t));
+	p.opts = (opts != 0) ? opts : &_bdf_opts;
+	p.minlb = 32767;
+	p.callback = callback;
+	p.client_data = data;
+	n = _bdf_readlines(fileno(in), _bdf_parse_start, (void *) & p, &lineno);
 
-    if (p.font != 0) {
-        /*
-         * If the font is not proportional, set the fonts monowidth
-         * field to the width of the font bounding box.
-         */
-        if (p.font->spacing != BDF_PROPORTIONAL)
-          p.font->monowidth = p.font->bbx.width;
+	if (p.font != 0) {
+		/*
+		 * If the font is not proportional, set the fonts monowidth
+		 * field to the width of the font bounding box.
+		 */
+		if (p.font->spacing != BDF_PROPORTIONAL)
+			p.font->monowidth = p.font->bbx.width;
 
-        /*
-         * If the number of glyphs loaded is not that of the original count,
-         * indicate the difference.
-         */
-        if (p.cnt != p.font->glyphs_used + p.font->unencoded_used) {
-            sprintf(msgbuf, ACMSG15, p.cnt,
-                    p.font->glyphs_used + p.font->unencoded_used);
-            _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf));
-            p.font->modified = 1;
-        }
+		/*
+		 * If the number of glyphs loaded is not that of the original count,
+		 * indicate the difference.
+		 */
+		if (p.cnt != p.font->glyphs_used + p.font->unencoded_used) {
+			sprintf(msgbuf, ACMSG15, p.cnt,
+			        p.font->glyphs_used + p.font->unencoded_used);
+			_bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf));
+			p.font->modified = 1;
+		}
 
-        /*
-         * Once the font has been loaded, adjust the overall font metrics if
-         * necessary.
-         */
-        if (p.opts->correct_metrics != 0 &&
-            (p.font->glyphs_used > 0 || p.font->unencoded_used > 0)) {
-            if (p.maxrb - p.minlb != p.font->bbx.width) {
-                sprintf(msgbuf, ACMSG3, p.font->bbx.width, p.maxrb - p.minlb);
-                _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf));
-                p.font->bbx.width = p.maxrb - p.minlb;

@@ Diff output truncated at 100000 characters. @@

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




More information about the Scummvm-git-logs mailing list