X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/641cfd145e8d17956c3bf5d357c09fecb24f8e58..81d8cc5377be3560177ee576d314fe4331e275c3:/src/image.c diff --git a/src/image.c b/src/image.c index c5bed6f12e..538ae2b777 100644 --- a/src/image.c +++ b/src/image.c @@ -75,7 +75,12 @@ typedef struct x_bitmap_record Bitmap_Record; #endif /* HAVE_X_WINDOWS */ #ifdef HAVE_NTGUI -#include "w32.h" + +/* We need (or want) w32.h only when we're _not_ compiling for Cygwin. */ +#ifdef WINDOWSNT +# include "w32.h" +#endif + /* W32_TODO : Color tables on W32. */ #undef COLOR_TABLE_SUPPORT @@ -186,11 +191,11 @@ x_bitmap_width (FRAME_PTR f, ptrdiff_t id) } #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI) -int +ptrdiff_t x_bitmap_pixmap (FRAME_PTR f, ptrdiff_t id) { /* HAVE_NTGUI needs the explicit cast here. */ - return (int) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap; + return (ptrdiff_t) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap; } #endif @@ -429,6 +434,9 @@ x_destroy_all_bitmaps (Display_Info *dpyinfo) dpyinfo->bitmaps_last = 0; } +static bool x_create_x_image_and_pixmap (struct frame *, int, int, int, + XImagePtr *, Pixmap *); +static void x_destroy_x_image (XImagePtr ximg); #ifdef HAVE_X_WINDOWS @@ -440,23 +448,17 @@ static unsigned long four_corners_best (XImagePtr ximg, unsigned long width, unsigned long height); -static int x_create_x_image_and_pixmap (struct frame *f, int width, int height, - int depth, XImagePtr *ximg, - Pixmap *pixmap); - -static void x_destroy_x_image (XImagePtr ximg); - /* Create a mask of a bitmap. Note is this not a perfect mask. It's nicer with some borders in this context */ -int +void x_create_bitmap_mask (struct frame *f, ptrdiff_t id) { Pixmap pixmap, mask; XImagePtr ximg, mask_img; unsigned long width, height; - int result; + bool result; unsigned long bg; unsigned long x, y, xp, xm, yp, ym; GC gc; @@ -464,7 +466,7 @@ x_create_bitmap_mask (struct frame *f, ptrdiff_t id) Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f); if (!(id > 0)) - return -1; + return; pixmap = x_bitmap_pixmap (f, id); width = x_bitmap_width (f, id); @@ -477,7 +479,7 @@ x_create_bitmap_mask (struct frame *f, ptrdiff_t id) if (!ximg) { unblock_input (); - return -1; + return; } result = x_create_x_image_and_pixmap (f, width, height, 1, &mask_img, &mask); @@ -486,7 +488,7 @@ x_create_bitmap_mask (struct frame *f, ptrdiff_t id) if (!result) { XDestroyImage (ximg); - return -1; + return; } bg = four_corners_best (ximg, NULL, width, height); @@ -525,8 +527,6 @@ x_create_bitmap_mask (struct frame *f, ptrdiff_t id) XDestroyImage (ximg); x_destroy_x_image (mask_img); - - return 0; } #endif /* HAVE_X_WINDOWS */ @@ -559,16 +559,15 @@ static Lisp_Object QCcrop, QCrotation; static Lisp_Object Qcount, Qextension_data, Qdelay; static Lisp_Object Qlaplace, Qemboss, Qedge_detection, Qheuristic; -/* Function prototypes. */ +/* Forward function prototypes. */ -static struct image_type *define_image_type (struct image_type *, Lisp_Object); static struct image_type *lookup_image_type (Lisp_Object); -static void image_error (const char *format, Lisp_Object, Lisp_Object); static void x_laplace (struct frame *, struct image *); static void x_emboss (struct frame *, struct image *); -static int x_build_heuristic_mask (struct frame *, struct image *, - Lisp_Object); -#ifdef HAVE_NTGUI +static void x_build_heuristic_mask (struct frame *, struct image *, + Lisp_Object); +#ifdef WINDOWSNT +extern Lisp_Object Vlibrary_cache; #define CACHE_IMAGE_TYPE(type, status) \ do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0) #else @@ -586,7 +585,7 @@ define_image_type (struct image_type *type) { struct image_type *p = NULL; Lisp_Object target_type = *type->type; - int type_valid = 1; + bool type_valid = 1; block_input (); @@ -596,7 +595,7 @@ define_image_type (struct image_type *type) if (type->init) { -#ifdef HAVE_NTGUI +#if defined HAVE_NTGUI && defined WINDOWSNT /* If we failed to load the library before, don't try again. */ Lisp_Object tested = Fassq (target_type, Vlibrary_cache); if (CONSP (tested) && NILP (XCDR (tested))) @@ -625,17 +624,17 @@ define_image_type (struct image_type *type) } -/* Value is non-zero if OBJECT is a valid Lisp image specification. A +/* Value is true if OBJECT is a valid Lisp image specification. A valid image specification is a list whose car is the symbol `image', and whose rest is a property list. The property list must contain a value for key `:type'. That value must be the name of a supported image type. The rest of the property list depends on the image type. */ -int +bool valid_image_p (Lisp_Object object) { - int valid_p = 0; + bool valid_p = 0; if (IMAGEP (object)) { @@ -705,8 +704,8 @@ struct image_keyword /* The type of value allowed. */ enum image_value_type type; - /* Non-zero means key must be present. */ - int mandatory_p; + /* True means key must be present. */ + bool mandatory_p; /* Used to recognize duplicate keywords in a property list. */ int count; @@ -716,18 +715,13 @@ struct image_keyword }; -static int parse_image_spec (Lisp_Object, struct image_keyword *, - int, Lisp_Object); -static Lisp_Object image_spec_value (Lisp_Object, Lisp_Object, int *); - - /* Parse image spec SPEC according to KEYWORDS. A valid image spec has the format (image KEYWORD VALUE ...). One of the keyword/ value pairs must be `:type TYPE'. KEYWORDS is a vector of image_keywords structures of size NKEYWORDS describing other - allowed keyword/value pairs. Value is non-zero if SPEC is valid. */ + allowed keyword/value pairs. Value is true if SPEC is valid. */ -static int +static bool parse_image_spec (Lisp_Object spec, struct image_keyword *keywords, int nkeywords, Lisp_Object type) { @@ -859,11 +853,11 @@ parse_image_spec (Lisp_Object spec, struct image_keyword *keywords, /* Return the value of KEY in image specification SPEC. Value is nil - if KEY is not present in SPEC. if FOUND is not null, set *FOUND - to 1 if KEY was found in SPEC, set it to 0 otherwise. */ + if KEY is not present in SPEC. Set *FOUND depending on whether KEY + was found in SPEC. */ static Lisp_Object -image_spec_value (Lisp_Object spec, Lisp_Object key, int *found) +image_spec_value (Lisp_Object spec, Lisp_Object key, bool *found) { Lisp_Object tail; @@ -967,8 +961,6 @@ or omitted means use the selected frame. */) Image type independent image structures ***********************************************************************/ -static void free_image (struct frame *f, struct image *img); - #define MAX_IMAGE_SIZE 10.0 /* Allocate and return a new image structure for image specification SPEC. SPEC has a hash value of HASH. */ @@ -1018,10 +1010,9 @@ free_image (struct frame *f, struct image *img) } } -/* Return 1 if the given widths and heights are valid for display; - otherwise, return 0. */ +/* Return true if the given widths and heights are valid for display. */ -static int +static bool check_image_size (struct frame *f, int width, int height) { int w, h; @@ -1060,7 +1051,7 @@ prepare_image_for_display (struct frame *f, struct image *img) /* If IMG doesn't have a pixmap yet, load it now, using the image type dependent loader function. */ if (img->pixmap == NO_PIXMAP && !img->load_failed_p) - img->load_failed_p = img->type->load (f, img) == 0; + img->load_failed_p = ! img->type->load (f, img); } @@ -1193,7 +1184,7 @@ image_background (struct image *img, struct frame *f, XImagePtr_or_DC ximg) if (! img->background_valid) /* IMG doesn't have a background yet, try to guess a reasonable value. */ { - int free_ximg = !ximg; + bool free_ximg = !ximg; #ifdef HAVE_NTGUI HGDIOBJ prev; #endif /* HAVE_NTGUI */ @@ -1234,7 +1225,7 @@ image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_D { if (img->mask) { - int free_mask = !mask; + bool free_mask = !mask; #ifdef HAVE_NTGUI HGDIOBJ prev; #endif /* HAVE_NTGUI */ @@ -1272,23 +1263,13 @@ image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_D Helper functions for X image types ***********************************************************************/ -static void x_clear_image_1 (struct frame *, struct image *, int, - int, int); -static void x_clear_image (struct frame *f, struct image *img); -static unsigned long x_alloc_image_color (struct frame *f, - struct image *img, - Lisp_Object color_name, - unsigned long dflt); - - -/* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means - free the pixmap if any. MASK_P non-zero means clear the mask - pixmap if any. COLORS_P non-zero means free colors allocated for - the image, if any. */ +/* Clear X resources of image IMG on frame F. PIXMAP_P means free the + pixmap if any. MASK_P means clear the mask pixmap if any. + COLORS_P means free colors allocated for the image, if any. */ static void -x_clear_image_1 (struct frame *f, struct image *img, int pixmap_p, int mask_p, - int colors_p) +x_clear_image_1 (struct frame *f, struct image *img, bool pixmap_p, + bool mask_p, bool colors_p) { if (pixmap_p && img->pixmap) { @@ -1368,7 +1349,6 @@ x_alloc_image_color (struct frame *f, struct image *img, Lisp_Object color_name, ***********************************************************************/ static void cache_image (struct frame *f, struct image *img); -static void postprocess_image (struct frame *, struct image *); /* Return a new, initialized image cache that is allocated from the heap. Call free_image_cache to free an image cache. */ @@ -1641,7 +1621,7 @@ postprocess_image (struct frame *f, struct image *img) x_build_heuristic_mask (f, img, mask); else { - int found_p; + bool found_p; mask = image_spec_value (spec, QCmask, &found_p); @@ -1714,7 +1694,7 @@ lookup_image (struct frame *f, Lisp_Object spec) block_input (); img = make_image (spec, hash); cache_image (f, img); - img->load_failed_p = img->type->load (f, img) == 0; + img->load_failed_p = ! img->type->load (f, img); img->frame_foreground = FRAME_FOREGROUND_PIXEL (f); img->frame_background = FRAME_BACKGROUND_PIXEL (f); @@ -1860,7 +1840,7 @@ mark_image_cache (struct image_cache *c) X / NS / W32 support code ***********************************************************************/ -#ifdef HAVE_NTGUI +#ifdef WINDOWSNT /* Macro for defining functions that will be loaded from image DLLs. */ #define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args @@ -1871,18 +1851,13 @@ mark_image_cache (struct image_cache *c) if (!fn_##func) return 0; \ } -#endif /* HAVE_NTGUI */ - -static int x_create_x_image_and_pixmap (struct frame *, int, int, int, - XImagePtr *, Pixmap *); -static void x_destroy_x_image (XImagePtr); -static void x_put_x_image (struct frame *, XImagePtr, Pixmap, int, int); +#endif /* WINDOWSNT */ -/* Return nonzero if XIMG's size WIDTH x HEIGHT doesn't break the +/* Return true if XIMG's size WIDTH x HEIGHT doesn't break the windowing system. WIDTH and HEIGHT must both be positive. If XIMG is null, assume it is a bitmap. */ -static int +static bool x_check_image_size (XImagePtr ximg, int width, int height) { #ifdef HAVE_X_WINDOWS @@ -1921,12 +1896,12 @@ x_check_image_size (XImagePtr ximg, int width, int height) frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created. Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated via xmalloc. Print error messages via image_error if an error - occurs. Value is non-zero if successful. + occurs. Value is true if successful. On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH should indicate the bit depth of the image. */ -static int +static bool x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth, XImagePtr *ximg, Pixmap *pixmap) { @@ -2165,12 +2140,11 @@ x_find_image_file (Lisp_Object file) static unsigned char * slurp_file (char *file, ptrdiff_t *size) { - FILE *fp = NULL; + FILE *fp = fopen (file, "rb"); unsigned char *buf = NULL; struct stat st; - if (stat (file, &st) == 0 - && (fp = fopen (file, "rb")) != NULL + if (fp && fstat (fileno (fp), &st) == 0 && 0 <= st.st_size && st.st_size <= min (PTRDIFF_MAX, SIZE_MAX) && (buf = xmalloc (st.st_size), fread (buf, 1, st.st_size, fp) == st.st_size)) @@ -2198,15 +2172,9 @@ slurp_file (char *file, ptrdiff_t *size) XBM images ***********************************************************************/ -static int xbm_scan (unsigned char **, unsigned char *, char *, int *); -static int xbm_load (struct frame *f, struct image *img); -static int xbm_load_image (struct frame *f, struct image *img, - unsigned char *, unsigned char *); -static int xbm_image_p (Lisp_Object object); -static int xbm_read_bitmap_data (struct frame *f, - unsigned char *, unsigned char *, - int *, int *, char **, int); -static int xbm_file_p (Lisp_Object); +static bool xbm_load (struct frame *f, struct image *img); +static bool xbm_image_p (Lisp_Object object); +static bool xbm_file_p (Lisp_Object); /* Indices of image specification fields in xbm_format, below. */ @@ -2270,10 +2238,10 @@ enum xbm_token }; -/* Return non-zero if OBJECT is a valid XBM-type image specification. +/* Return true if OBJECT is a valid XBM-type image specification. A valid specification is a list starting with the symbol `image' The rest of the list is a property list which must contain an - entry `:type xbm.. + entry `:type xbm'. If the specification specifies a file to load, it must contain an entry `:file FILENAME' where FILENAME is a string. @@ -2299,7 +2267,7 @@ enum xbm_token foreground and background of the frame on which the image is displayed is used. */ -static int +static bool xbm_image_p (Lisp_Object object) { struct image_keyword kw[XBM_LAST]; @@ -2557,7 +2525,7 @@ convert_mono_to_color_image (struct frame *f, struct image *img, static void Create_Pixmap_From_Bitmap_Data (struct frame *f, struct image *img, char *data, RGB_PIXEL_COLOR fg, RGB_PIXEL_COLOR bg, - int non_default_colors) + bool non_default_colors) { #ifdef HAVE_NTGUI img->pixmap @@ -2589,20 +2557,20 @@ Create_Pixmap_From_Bitmap_Data (struct frame *f, struct image *img, char *data, X versions. CONTENTS is a pointer to a buffer to parse; END is the buffer's end. Set *WIDTH and *HEIGHT to the width and height of the image. Return in *DATA the bitmap data allocated with xmalloc. - Value is non-zero if successful. DATA null means just test if - CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR - is non-zero, inhibit the call to image_error when the image size is - invalid (the bitmap remains unread). */ + Value is true if successful. DATA null means just test if + CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR, + inhibit the call to image_error when the image size is invalid (the + bitmap remains unread). */ -static int +static bool xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *end, int *width, int *height, char **data, - int inhibit_image_error) + bool inhibit_image_error) { unsigned char *s = contents; char buffer[BUFSIZ]; - int padding_p = 0; - int v10 = 0; + bool padding_p = 0; + bool v10 = 0; int bytes_per_line, i, nbytes; char *p; int value; @@ -2749,16 +2717,16 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e /* Load XBM image IMG which will be displayed on frame F from buffer - CONTENTS. END is the end of the buffer. Value is non-zero if + CONTENTS. END is the end of the buffer. Value is true if successful. */ -static int +static bool xbm_load_image (struct frame *f, struct image *img, unsigned char *contents, unsigned char *end) { - int rc; + bool rc; char *data; - int success_p = 0; + bool success_p = 0; rc = xbm_read_bitmap_data (f, contents, end, &img->width, &img->height, &data, 0); @@ -2766,7 +2734,7 @@ xbm_load_image (struct frame *f, struct image *img, unsigned char *contents, { unsigned long foreground = FRAME_FOREGROUND_PIXEL (f); unsigned long background = FRAME_BACKGROUND_PIXEL (f); - int non_default_colors = 0; + bool non_default_colors = 0; Lisp_Object value; eassert (img->width > 0 && img->height > 0); @@ -2807,9 +2775,9 @@ xbm_load_image (struct frame *f, struct image *img, unsigned char *contents, } -/* Value is non-zero if DATA looks like an in-memory XBM file. */ +/* Value is true if DATA looks like an in-memory XBM file. */ -static int +static bool xbm_file_p (Lisp_Object data) { int w, h; @@ -2821,12 +2789,12 @@ xbm_file_p (Lisp_Object data) /* Fill image IMG which is used on frame F with pixmap data. Value is - non-zero if successful. */ + true if successful. */ -static int +static bool xbm_load (struct frame *f, struct image *img) { - int success_p = 0; + bool success_p = 0; Lisp_Object file_name; eassert (xbm_image_p (img->spec)); @@ -2862,10 +2830,10 @@ xbm_load (struct frame *f, struct image *img) Lisp_Object data; unsigned long foreground = FRAME_FOREGROUND_PIXEL (f); unsigned long background = FRAME_BACKGROUND_PIXEL (f); - int non_default_colors = 0; + bool non_default_colors = 0; char *bits; - int parsed_p; - int in_memory_file_p = 0; + bool parsed_p; + bool in_memory_file_p = 0; /* See if data looks like an in-memory XBM file. */ data = image_spec_value (img->spec, QCdata, NULL); @@ -2874,7 +2842,6 @@ xbm_load (struct frame *f, struct image *img) /* Parse the image specification. */ memcpy (fmt, xbm_format, sizeof fmt); parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm); - (void) parsed_p; eassert (parsed_p); /* Get specified width, and height. */ @@ -2935,7 +2902,7 @@ xbm_load (struct frame *f, struct image *img) else bits = (char *) XBOOL_VECTOR (data)->data; -#ifdef WINDOWSNT +#ifdef HAVE_NTGUI { char *invertedBits; int nbytes, i; @@ -2979,9 +2946,8 @@ xbm_load (struct frame *f, struct image *img) #if defined (HAVE_XPM) || defined (HAVE_NS) -static int xpm_image_p (Lisp_Object object); -static int xpm_load (struct frame *f, struct image *img); -static int xpm_valid_color_symbols_p (Lisp_Object); +static bool xpm_image_p (Lisp_Object object); +static bool xpm_load (struct frame *f, struct image *img); #endif /* HAVE_XPM || HAVE_NS */ @@ -3047,8 +3013,8 @@ static const struct image_keyword xpm_format[XPM_LAST] = {":background", IMAGE_STRING_OR_NIL_VALUE, 0} }; -#ifdef HAVE_NTGUI -static int init_xpm_functions (void); +#if defined HAVE_NTGUI && defined WINDOWSNT +static bool init_xpm_functions (void); #else #define init_xpm_functions NULL #endif @@ -3079,10 +3045,6 @@ static struct image_type xpm_type = #ifdef ALLOC_XPM_COLORS -static void xpm_init_color_cache (struct frame *, XpmAttributes *); -static void xpm_free_color_cache (void); -static int xpm_lookup_color (struct frame *, char *, XColor *); -static int xpm_color_bucket (char *); static struct xpm_cached_color *xpm_cache_color (struct frame *, char *, XColor *, int); @@ -3189,10 +3151,10 @@ xpm_cache_color (struct frame *f, char *color_name, XColor *color, int bucket) /* Look up color COLOR_NAME for frame F in the color cache. If found, return the cached definition in *COLOR. Otherwise, make a new - entry in the cache and allocate the color. Value is zero if color + entry in the cache and allocate the color. Value is false if color allocation failed. */ -static int +static bool xpm_lookup_color (struct frame *f, char *color_name, XColor *color) { struct xpm_cached_color *p; @@ -3250,7 +3212,7 @@ xpm_free_colors (Display *dpy, Colormap cmap, Pixel *pixels, int npixels, void * #endif /* ALLOC_XPM_COLORS */ -#ifdef HAVE_NTGUI +#ifdef WINDOWSNT /* XPM library details. */ @@ -3261,7 +3223,7 @@ DEF_IMGLIB_FN (int, XpmReadFileToImage, (Display *, char *, xpm_XImage **, xpm_XImage **, XpmAttributes *)); DEF_IMGLIB_FN (void, XImageFree, (xpm_XImage *)); -static int +static bool init_xpm_functions (void) { HMODULE library; @@ -3276,14 +3238,21 @@ init_xpm_functions (void) return 1; } -#endif /* HAVE_NTGUI */ +#endif /* WINDOWSNT */ +#if defined HAVE_NTGUI && !defined WINDOWSNT +/* Glue for code below */ +#define fn_XpmReadFileToImage XpmReadFileToImage +#define fn_XpmCreateImageFromBuffer XpmCreateImageFromBuffer +#define fn_XImageFree XImageFree +#define fn_XpmFreeAttributes XpmFreeAttributes +#endif /* HAVE_NTGUI && !WINDOWSNT */ -/* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list +/* Value is true if COLOR_SYMBOLS is a valid color symbols list for XPM images. Such a list must consist of conses whose car and cdr are strings. */ -static int +static bool xpm_valid_color_symbols_p (Lisp_Object color_symbols) { while (CONSP (color_symbols)) @@ -3300,9 +3269,9 @@ xpm_valid_color_symbols_p (Lisp_Object color_symbols) } -/* Value is non-zero if OBJECT is a valid XPM image specification. */ +/* Value is true if OBJECT is a valid XPM image specification. */ -static int +static bool xpm_image_p (Lisp_Object object) { struct image_keyword fmt[XPM_LAST]; @@ -3359,11 +3328,11 @@ x_create_bitmap_from_xpm_data (struct frame *f, const char **bits) #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */ /* Load image IMG which will be displayed on frame F. Value is - non-zero if successful. */ + true if successful. */ #ifdef HAVE_XPM -static int +static bool xpm_load (struct frame *f, struct image *img) { int rc; @@ -3817,7 +3786,7 @@ xpm_str_to_color_key (const char *s) return -1; } -static int +static bool xpm_load_image (struct frame *f, struct image *img, const unsigned char *contents, @@ -3832,7 +3801,8 @@ xpm_load_image (struct frame *f, void (*put_color_table) (Lisp_Object, const unsigned char *, int, Lisp_Object); Lisp_Object (*get_color_table) (Lisp_Object, const unsigned char *, int); Lisp_Object frame, color_symbols, color_table; - int best_key, have_mask = 0; + int best_key; + bool have_mask = 0; XImagePtr ximg = NULL, mask_img = NULL; #define match() \ @@ -4052,11 +4022,11 @@ xpm_load_image (struct frame *f, #undef expect_ident } -static int +static bool xpm_load (struct frame *f, struct image *img) { - int success_p = 0; + bool success_p = 0; Lisp_Object file_name; /* If IMG->spec specifies a file name, create a non-file spec from it. */ @@ -4227,7 +4197,7 @@ lookup_rgb_color (struct frame *f, int r, int g, int b) #ifdef HAVE_X_WINDOWS XColor color; Colormap cmap; - int rc; + bool rc; #else COLORREF color; #endif @@ -4295,7 +4265,7 @@ lookup_pixel_color (struct frame *f, unsigned long pixel) { XColor color; Colormap cmap; - int rc; + bool rc; if (ct_colors_allocated_max <= ct_colors_allocated) return FRAME_FOREGROUND_PIXEL (f); @@ -4389,14 +4359,6 @@ init_color_table (void) Algorithms ***********************************************************************/ -static XColor *x_to_xcolors (struct frame *, struct image *, int); -static void x_from_xcolors (struct frame *, struct image *, XColor *); -static void x_detect_edges (struct frame *, struct image *, int[9], int); - -#ifdef HAVE_NTGUI -static void XPutPixel (XImagePtr , int, int, COLORREF); -#endif /* HAVE_NTGUI */ - /* Edge detection matrices for different edge-detection strategies. */ @@ -4422,12 +4384,12 @@ static int laplace_matrix[9] = { /* On frame F, return an array of XColor structures describing image IMG->pixmap. Each XColor structure has its pixel color set. RGB_P - non-zero means also fill the red/green/blue members of the XColor + means also fill the red/green/blue members of the XColor structures. Value is a pointer to the array of XColors structures, allocated with xmalloc; it must be freed by the caller. */ static XColor * -x_to_xcolors (struct frame *f, struct image *img, int rgb_p) +x_to_xcolors (struct frame *f, struct image *img, bool rgb_p) { int x, y; XColor *colors, *p; @@ -4803,9 +4765,9 @@ x_disable_image (struct frame *f, struct image *img) determine the background color of IMG. If it is a list '(R G B)', with R, G, and B being integers >= 0, take that as the color of the background. Otherwise, determine the background color of IMG - heuristically. Value is non-zero if successful. */ + heuristically. */ -static int +static void x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how) { XImagePtr_or_DC ximg; @@ -4817,7 +4779,8 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how) char *mask_img; int row_width; #endif /* HAVE_NTGUI */ - int x, y, rc, use_img_background; + int x, y; + bool rc, use_img_background; unsigned long bg = 0; if (img->mask) @@ -4833,7 +4796,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how) rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1, &mask_img, &img->mask); if (!rc) - return 0; + return; #endif /* !HAVE_NS */ /* Get the X image of IMG->pixmap. */ @@ -4923,8 +4886,6 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how) #endif /* HAVE_NTGUI */ Destroy_Image (ximg, prev); - - return 1; } @@ -4932,9 +4893,8 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how) PBM (mono, gray, color) ***********************************************************************/ -static int pbm_image_p (Lisp_Object object); -static int pbm_load (struct frame *f, struct image *img); -static int pbm_scan_number (unsigned char **, unsigned char *); +static bool pbm_image_p (Lisp_Object object); +static bool pbm_load (struct frame *f, struct image *img); /* The symbol `pbm' identifying images of this type. */ @@ -4989,9 +4949,9 @@ static struct image_type pbm_type = }; -/* Return non-zero if OBJECT is a valid PBM image specification. */ +/* Return true if OBJECT is a valid PBM image specification. */ -static int +static bool pbm_image_p (Lisp_Object object) { struct image_keyword fmt[PBM_LAST]; @@ -5043,51 +5003,13 @@ pbm_scan_number (unsigned char **s, unsigned char *end) } -#ifdef HAVE_NTGUI -#if 0 /* Unused. ++kfs */ - -/* Read FILE into memory. Value is a pointer to a buffer allocated - with xmalloc holding FILE's contents. Value is null if an error - occurred. *SIZE is set to the size of the file. */ - -static char * -pbm_read_file (Lisp_Object file, int *size) -{ - FILE *fp = NULL; - char *buf = NULL; - struct stat st; - - if (stat (SDATA (file), &st) == 0 - && (fp = fopen (SDATA (file), "rb")) != NULL - && 0 <= st.st_size && st.st_size <= min (PTRDIFF_MAX, SIZE_MAX) - && (buf = xmalloc (st.st_size), - fread (buf, 1, st.st_size, fp) == st.st_size)) - { - *size = st.st_size; - fclose (fp); - } - else - { - if (fp) - fclose (fp); - if (buf) - { - xfree (buf); - buf = NULL; - } - } - - return buf; -} -#endif -#endif /* HAVE_NTGUI */ - /* Load PBM image IMG for use on frame F. */ -static int +static bool pbm_load (struct frame *f, struct image *img) { - int raw_p, x, y; + bool raw_p; + int x, y; int width, height, max_color_idx = 0; XImagePtr ximg; Lisp_Object file, specified_file; @@ -5350,8 +5272,8 @@ pbm_load (struct frame *f, struct image *img) /* Function prototypes. */ -static int png_image_p (Lisp_Object object); -static int png_load (struct frame *f, struct image *img); +static bool png_image_p (Lisp_Object object); +static bool png_load (struct frame *f, struct image *img); /* The symbol `png' identifying images of this type. */ @@ -5391,8 +5313,8 @@ static const struct image_keyword png_format[PNG_LAST] = {":background", IMAGE_STRING_OR_NIL_VALUE, 0} }; -#ifdef HAVE_NTGUI -static int init_png_functions (void); +#if defined HAVE_NTGUI && defined WINDOWSNT +static bool init_png_functions (void); #else #define init_png_functions NULL #endif @@ -5409,9 +5331,9 @@ static struct image_type png_type = NULL }; -/* Return non-zero if OBJECT is a valid PNG image specification. */ +/* Return true if OBJECT is a valid PNG image specification. */ -static int +static bool png_image_p (Lisp_Object object) { struct image_keyword fmt[PNG_LAST]; @@ -5429,7 +5351,7 @@ png_image_p (Lisp_Object object) #ifdef HAVE_PNG -#ifdef HAVE_NTGUI +#ifdef WINDOWSNT /* PNG library details. */ DEF_IMGLIB_FN (png_voidp, png_get_io_ptr, (png_structp)); @@ -5463,7 +5385,7 @@ DEF_IMGLIB_FN (void, png_longjmp, (png_structp, int)); DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn, (png_structp, png_longjmp_ptr, size_t)); #endif /* libpng version >= 1.5 */ -static int +static bool init_png_functions (void) { HMODULE library; @@ -5529,7 +5451,7 @@ init_png_functions (void) #define fn_png_set_longjmp_fn png_set_longjmp_fn #endif /* libpng version >= 1.5 */ -#endif /* HAVE_NTGUI */ +#endif /* WINDOWSNT */ /* Possibly inefficient/inexact substitutes for _setjmp and _longjmp. Do not use sys_setjmp, as PNG supports only jmp_buf. The _longjmp @@ -5614,7 +5536,7 @@ png_read_from_file (png_structp png_ptr, png_bytep data, png_size_t length) } -/* Load PNG image IMG for use on frame F. Value is non-zero if +/* Load PNG image IMG for use on frame F. Value is true if successful. */ struct png_load_context @@ -5628,7 +5550,7 @@ struct png_load_context png_byte **rows; }; -static int +static bool png_load_body (struct frame *f, struct image *img, struct png_load_context *c) { Lisp_Object file, specified_file; @@ -5646,7 +5568,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c) int bit_depth, color_type, interlace_type; png_byte channels; png_uint_32 row_bytes; - int transparent_p; + bool transparent_p; struct png_memory_storage tbr; /* Data to be read */ /* Find out what file to load. */ @@ -5979,7 +5901,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c) return 1; } -static int +static bool png_load (struct frame *f, struct image *img) { struct png_load_context c; @@ -5989,7 +5911,7 @@ png_load (struct frame *f, struct image *img) #else /* HAVE_PNG */ #ifdef HAVE_NS -static int +static bool png_load (struct frame *f, struct image *img) { return ns_load_image (f, img, @@ -6009,8 +5931,8 @@ png_load (struct frame *f, struct image *img) #if defined (HAVE_JPEG) || defined (HAVE_NS) -static int jpeg_image_p (Lisp_Object object); -static int jpeg_load (struct frame *f, struct image *img); +static bool jpeg_image_p (Lisp_Object object); +static bool jpeg_load (struct frame *f, struct image *img); /* The symbol `jpeg' identifying images of this type. */ @@ -6050,8 +5972,8 @@ static const struct image_keyword jpeg_format[JPEG_LAST] = {":background", IMAGE_STRING_OR_NIL_VALUE, 0} }; -#ifdef HAVE_NTGUI -static int init_jpeg_functions (void); +#if defined HAVE_NTGUI && defined WINDOWSNT +static bool init_jpeg_functions (void); #else #define init_jpeg_functions NULL #endif @@ -6068,9 +5990,9 @@ static struct image_type jpeg_type = NULL }; -/* Return non-zero if OBJECT is a valid JPEG image specification. */ +/* Return true if OBJECT is a valid JPEG image specification. */ -static int +static bool jpeg_image_p (Lisp_Object object) { struct image_keyword fmt[JPEG_LAST]; @@ -6100,14 +6022,27 @@ jpeg_image_p (Lisp_Object object) #define __WIN32__ 1 #endif +/* rpcndr.h (via windows.h) and jpeglib.h both define boolean types. + Some versions of jpeglib try to detect whether rpcndr.h is loaded, + using the Windows boolean type instead of the jpeglib boolean type + if so. Cygwin jpeglib, however, doesn't try to detect whether its + headers are included along with windows.h, so under Cygwin, jpeglib + attempts to define a conflicting boolean type. Worse, forcing + Cygwin jpeglib headers to use the Windows boolean type doesn't work + because it created an ABI incompatibility between the + already-compiled jpeg library and the header interface definition. + + The best we can do is to define jpeglib's boolean type to a + different name. This name, jpeg_boolean, remains in effect through + the rest of image.c. +*/ +#if defined CYGWIN && defined HAVE_NTGUI +#define boolean jpeg_boolean +#endif #include #include -#ifdef HAVE_STLIB_H_1 -#define HAVE_STDLIB_H 1 -#endif - -#ifdef HAVE_NTGUI +#ifdef WINDOWSNT /* JPEG library details. */ DEF_IMGLIB_FN (void, jpeg_CreateDecompress, (j_decompress_ptr, int, size_t)); @@ -6119,7 +6054,7 @@ DEF_IMGLIB_FN (JDIMENSION, jpeg_read_scanlines, (j_decompress_ptr, JSAMPARRAY, J DEF_IMGLIB_FN (struct jpeg_error_mgr *, jpeg_std_error, (struct jpeg_error_mgr *)); DEF_IMGLIB_FN (boolean, jpeg_resync_to_restart, (j_decompress_ptr, int)); -static int +static bool init_jpeg_functions (void) { HMODULE library; @@ -6157,7 +6092,7 @@ jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo, int desired) #define fn_jpeg_std_error jpeg_std_error #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart -#endif /* HAVE_NTGUI */ +#endif /* WINDOWSNT */ struct my_jpeg_error_mgr { @@ -6389,7 +6324,7 @@ jpeg_file_src (j_decompress_ptr cinfo, FILE *fp) /* Load image IMG for use on frame F. Patterned after example.c from the JPEG lib. */ -static int +static bool jpeg_load_body (struct frame *f, struct image *img, struct my_jpeg_error_mgr *mgr) { @@ -6570,7 +6505,7 @@ jpeg_load_body (struct frame *f, struct image *img, return 1; } -static int +static bool jpeg_load (struct frame *f, struct image *img) { struct my_jpeg_error_mgr mgr; @@ -6580,7 +6515,7 @@ jpeg_load (struct frame *f, struct image *img) #else /* HAVE_JPEG */ #ifdef HAVE_NS -static int +static bool jpeg_load (struct frame *f, struct image *img) { return ns_load_image (f, img, @@ -6599,8 +6534,8 @@ jpeg_load (struct frame *f, struct image *img) #if defined (HAVE_TIFF) || defined (HAVE_NS) -static int tiff_image_p (Lisp_Object object); -static int tiff_load (struct frame *f, struct image *img); +static bool tiff_image_p (Lisp_Object object); +static bool tiff_load (struct frame *f, struct image *img); /* The symbol `tiff' identifying images of this type. */ @@ -6642,8 +6577,8 @@ static const struct image_keyword tiff_format[TIFF_LAST] = {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0} }; -#ifdef HAVE_NTGUI -static int init_tiff_functions (void); +#if defined HAVE_NTGUI && defined WINDOWSNT +static bool init_tiff_functions (void); #else #define init_tiff_functions NULL #endif @@ -6660,9 +6595,9 @@ static struct image_type tiff_type = NULL }; -/* Return non-zero if OBJECT is a valid TIFF image specification. */ +/* Return true if OBJECT is a valid TIFF image specification. */ -static int +static bool tiff_image_p (Lisp_Object object) { struct image_keyword fmt[TIFF_LAST]; @@ -6681,7 +6616,7 @@ tiff_image_p (Lisp_Object object) #include -#ifdef HAVE_NTGUI +#ifdef WINDOWSNT /* TIFF library details. */ DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetErrorHandler, (TIFFErrorHandler)); @@ -6696,7 +6631,7 @@ DEF_IMGLIB_FN (int, TIFFReadRGBAImage, (TIFF *, uint32, uint32, uint32 *, int)); DEF_IMGLIB_FN (void, TIFFClose, (TIFF *)); DEF_IMGLIB_FN (int, TIFFSetDirectory, (TIFF *, tdir_t)); -static int +static bool init_tiff_functions (void) { HMODULE library; @@ -6725,7 +6660,7 @@ init_tiff_functions (void) #define fn_TIFFReadRGBAImage TIFFReadRGBAImage #define fn_TIFFClose TIFFClose #define fn_TIFFSetDirectory TIFFSetDirectory -#endif /* HAVE_NTGUI */ +#endif /* WINDOWSNT */ /* Reading from a memory buffer for TIFF images Based on the PNG @@ -6866,10 +6801,10 @@ tiff_warning_handler (const char *title, const char *format, va_list ap) } -/* Load TIFF image IMG for use on frame F. Value is non-zero if +/* Load TIFF image IMG for use on frame F. Value is true if successful. */ -static int +static bool tiff_load (struct frame *f, struct image *img) { Lisp_Object file, specified_file; @@ -7034,7 +6969,7 @@ tiff_load (struct frame *f, struct image *img) #else /* HAVE_TIFF */ #ifdef HAVE_NS -static int +static bool tiff_load (struct frame *f, struct image *img) { return ns_load_image (f, img, @@ -7053,8 +6988,8 @@ tiff_load (struct frame *f, struct image *img) #if defined (HAVE_GIF) || defined (HAVE_NS) -static int gif_image_p (Lisp_Object object); -static int gif_load (struct frame *f, struct image *img); +static bool gif_image_p (Lisp_Object object); +static bool gif_load (struct frame *f, struct image *img); static void gif_clear_image (struct frame *f, struct image *img); /* The symbol `gif' identifying images of this type. */ @@ -7097,8 +7032,8 @@ static const struct image_keyword gif_format[GIF_LAST] = {":background", IMAGE_STRING_OR_NIL_VALUE, 0} }; -#ifdef HAVE_NTGUI -static int init_gif_functions (void); +#if defined HAVE_NTGUI && defined WINDOWSNT +static bool init_gif_functions (void); #else #define init_gif_functions NULL #endif @@ -7124,9 +7059,9 @@ gif_clear_image (struct frame *f, struct image *img) x_clear_image (f, img); } -/* Return non-zero if OBJECT is a valid GIF image specification. */ +/* Return true if OBJECT is a valid GIF image specification. */ -static int +static bool gif_image_p (Lisp_Object object) { struct image_keyword fmt[GIF_LAST]; @@ -7161,7 +7096,7 @@ gif_image_p (Lisp_Object object) #endif /* HAVE_NTGUI */ -#ifdef HAVE_NTGUI +#ifdef WINDOWSNT /* GIF library details. */ DEF_IMGLIB_FN (int, DGifCloseFile, (GifFileType *)); @@ -7169,7 +7104,7 @@ DEF_IMGLIB_FN (int, DGifSlurp, (GifFileType *)); DEF_IMGLIB_FN (GifFileType *, DGifOpen, (void *, InputFunc)); DEF_IMGLIB_FN (GifFileType *, DGifOpenFileName, (const char *)); -static int +static bool init_gif_functions (void) { HMODULE library; @@ -7191,7 +7126,7 @@ init_gif_functions (void) #define fn_DGifOpen DGifOpen #define fn_DGifOpenFileName DGifOpenFileName -#endif /* HAVE_NTGUI */ +#endif /* WINDOWSNT */ /* Reading a GIF image from memory Based on the PNG memory stuff to a certain extent. */ @@ -7223,7 +7158,7 @@ gif_read_from_memory (GifFileType *file, GifByteType *buf, int len) } -/* Load GIF image IMG for use on frame F. Value is non-zero if +/* Load GIF image IMG for use on frame F. Value is true if successful. */ static const int interlace_start[] = {0, 4, 2, 1}; @@ -7231,7 +7166,7 @@ static const int interlace_increment[] = {8, 8, 4, 2}; #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249 -static int +static bool gif_load (struct frame *f, struct image *img) { Lisp_Object file; @@ -7529,7 +7464,7 @@ gif_load (struct frame *f, struct image *img) #else /* !HAVE_GIF */ #ifdef HAVE_NS -static int +static bool gif_load (struct frame *f, struct image *img) { return ns_load_image (f, img, @@ -7548,8 +7483,8 @@ gif_load (struct frame *f, struct image *img) static Lisp_Object Qimagemagick; -static int imagemagick_image_p (Lisp_Object); -static int imagemagick_load (struct frame *, struct image *); +static bool imagemagick_image_p (Lisp_Object); +static bool imagemagick_load (struct frame *, struct image *); static void imagemagick_clear_image (struct frame *, struct image *); /* Indices of image specification fields in imagemagick_format. */ @@ -7594,8 +7529,8 @@ static struct image_keyword imagemagick_format[IMAGEMAGICK_LAST] = {":crop", IMAGE_DONT_CHECK_VALUE_TYPE, 0} }; -#ifdef HAVE_NTGUI -static int init_imagemagick_functions (void); +#if defined HAVE_NTGUI && defined WINDOWSNT +static bool init_imagemagick_functions (void); #else #define init_imagemagick_functions NULL #endif @@ -7622,11 +7557,11 @@ imagemagick_clear_image (struct frame *f, x_clear_image (f, img); } -/* Return non-zero if OBJECT is a valid IMAGEMAGICK image specification. Do +/* Return true if OBJECT is a valid IMAGEMAGICK image specification. Do this by calling parse_image_spec and supplying the keywords that identify the IMAGEMAGICK format. */ -static int +static bool imagemagick_image_p (Lisp_Object object) { struct image_keyword fmt[IMAGEMAGICK_LAST]; @@ -7678,9 +7613,9 @@ imagemagick_error (MagickWand *wand) be parsed; SIZE is the number of bytes of data; and FILENAME is either the file name or the image data. - Return non-zero if successful. */ + Return true if successful. */ -static int +static bool imagemagick_load_image (struct frame *f, struct image *img, unsigned char *contents, unsigned int size, char *filename) @@ -8018,14 +7953,14 @@ imagemagick_load_image (struct frame *f, struct image *img, } -/* Load IMAGEMAGICK image IMG for use on frame F. Value is non-zero if +/* Load IMAGEMAGICK image IMG for use on frame F. Value is true if successful. this function will go into the imagemagick_type structure, and the prototype thus needs to be compatible with that structure. */ -static int +static bool imagemagick_load (struct frame *f, struct image *img) { - int success_p = 0; + bool success_p = 0; Lisp_Object file_name; /* If IMG->spec specifies a file name, create a non-file spec from it. */ @@ -8104,11 +8039,11 @@ and `imagemagick-types-inhibit'. */) /* Function prototypes. */ -static int svg_image_p (Lisp_Object object); -static int svg_load (struct frame *f, struct image *img); +static bool svg_image_p (Lisp_Object object); +static bool svg_load (struct frame *f, struct image *img); -static int svg_load_image (struct frame *, struct image *, - unsigned char *, ptrdiff_t); +static bool svg_load_image (struct frame *, struct image *, + unsigned char *, ptrdiff_t); /* The symbol `svg' identifying images of this type. */ @@ -8148,8 +8083,8 @@ static const struct image_keyword svg_format[SVG_LAST] = {":background", IMAGE_STRING_OR_NIL_VALUE, 0} }; -#ifdef HAVE_NTGUI -static int init_svg_functions (void); +#if defined HAVE_NTGUI && defined WINDOWSNT +static bool init_svg_functions (void); #else #define init_svg_functions NULL #endif @@ -8169,11 +8104,11 @@ static struct image_type svg_type = }; -/* Return non-zero if OBJECT is a valid SVG image specification. Do +/* Return true if OBJECT is a valid SVG image specification. Do this by calling parse_image_spec and supplying the keywords that identify the SVG format. */ -static int +static bool svg_image_p (Lisp_Object object) { struct image_keyword fmt[SVG_LAST]; @@ -8188,7 +8123,7 @@ svg_image_p (Lisp_Object object) #include -#ifdef HAVE_NTGUI +#ifdef WINDOWSNT /* SVG library functions. */ DEF_IMGLIB_FN (RsvgHandle *, rsvg_handle_new); @@ -8212,7 +8147,7 @@ DEF_IMGLIB_FN (void, g_error_free); Lisp_Object Qgdk_pixbuf, Qglib, Qgobject; -static int +static bool init_svg_functions (void) { HMODULE library, gdklib, glib, gobject; @@ -8266,16 +8201,15 @@ init_svg_functions (void) #define fn_g_type_init g_type_init #define fn_g_object_unref g_object_unref #define fn_g_error_free g_error_free -#endif /* !HAVE_NTGUI */ +#endif /* !WINDOWSNT */ -/* Load SVG image IMG for use on frame F. Value is non-zero if - successful. this function will go into the svg_type structure, and - the prototype thus needs to be compatible with that structure. */ +/* Load SVG image IMG for use on frame F. Value is true if + successful. */ -static int +static bool svg_load (struct frame *f, struct image *img) { - int success_p = 0; + bool success_p = 0; Lisp_Object file_name; /* If IMG->spec specifies a file name, create a non-file spec from it. */ @@ -8328,8 +8262,8 @@ svg_load (struct frame *f, struct image *img) Uses librsvg to do most of the image processing. - Returns non-zero when successful. */ -static int + Returns true when successful. */ +static bool svg_load_image (struct frame *f, /* Pointer to emacs frame structure. */ struct image *img, /* Pointer to emacs image structure. */ unsigned char *contents, /* String containing the SVG XML data to be parsed. */ @@ -8496,8 +8430,8 @@ svg_load_image (struct frame *f, /* Pointer to emacs frame structure. * #ifdef HAVE_GHOSTSCRIPT -static int gs_image_p (Lisp_Object object); -static int gs_load (struct frame *f, struct image *img); +static bool gs_image_p (Lisp_Object object); +static bool gs_load (struct frame *f, struct image *img); static void gs_clear_image (struct frame *f, struct image *img); /* Keyword symbols. */ @@ -8566,10 +8500,10 @@ gs_clear_image (struct frame *f, struct image *img) } -/* Return non-zero if OBJECT is a valid Ghostscript image +/* Return true if OBJECT is a valid Ghostscript image specification. */ -static int +static bool gs_image_p (Lisp_Object object) { struct image_keyword fmt[GS_LAST]; @@ -8606,10 +8540,10 @@ gs_image_p (Lisp_Object object) } -/* Load Ghostscript image IMG for use on frame F. Value is non-zero +/* Load Ghostscript image IMG for use on frame F. Value is true if successful. */ -static int +static bool gs_load (struct frame *f, struct image *img) { uprintmax_t printnum1, printnum2; @@ -8883,12 +8817,24 @@ lookup_image_type (Lisp_Object type) return NULL; } +/* Reset image_types before dumping. + Called from Fdump_emacs. */ + +void +reset_image_types (void) +{ + while (image_types) + { + struct image_type *next = image_types->next; + xfree (image_types); + image_types = next; + } +} + void syms_of_image (void) { - /* Initialize this only once, since that's what we do with Vimage_types - and they are supposed to be in sync. Initializing here gives correct - operation on GNU/Linux of calling dump-emacs after loading some images. */ + /* Initialize this only once; it will be reset before dumping. */ image_types = NULL; /* Must be defined now because we're going to update it below, while