Move devices away from static init of procs.

65 files changed, 2347 insertions, 2149 deletions

diff --git a/devices/gdev3852.c b/devices/gdev3852.c
index 1b3377b2d..e39c17111 100644
--- a/devices/gdev3852.c
+++ b/devices/gdev3852.c
@@ -39,12 +39,26 @@ Modified by L. Peter Deutsch <ghost@aladdin.com> 1999-01-10 to remove _ss
 /* Should = 96 (KMG) */
 #define LINE_SIZE ((X_DPI * 86 / 10 + 63) / 64 * 8)
 
+static int
+jetp3852_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, output_page, gdev_prn_bg_output_page);
+    set_dev_proc(dev, map_rgb_color, gdev_pcl_3bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_pcl_3bit_map_color_rgb);
+
+    return 0;
+}
+
 /* The device descriptor */
 static dev_proc_print_page(jetp3852_print_page);
 /* Since the 'print_page' does not change the device, this device can print in the background */
 static gx_device_procs jetp3852_procs =
-  prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-    gdev_pcl_3bit_map_rgb_color, gdev_pcl_3bit_map_color_rgb);
+  devprocs_initialize(jetp3852_initialize);
 const gx_device_printer far_data gs_jetp3852_device =
   prn_device(jetp3852_procs, "jetp3852",
         86,				/* width_10ths, 8.6" (?) */
diff --git a/devices/gdev4693.c b/devices/gdev4693.c
index baa975c5c..302bc191f 100644
--- a/devices/gdev4693.c
+++ b/devices/gdev4693.c
@@ -22,10 +22,24 @@ static dev_proc_print_page(t4693d_print_page);
 static dev_proc_map_rgb_color(gdev_t4693d_map_rgb_color);
 static dev_proc_map_color_rgb(gdev_t4693d_map_color_rgb);
 
+static int
+t4693d_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, output_page, gdev_prn_bg_output_page);
+    set_dev_proc(dev, map_rgb_color, gdev_t4693d_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_t4693d_map_color_rgb);
+
+    return 0;
+}
+
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static gx_device_procs t4693d_procs =
-        prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                gdev_t4693d_map_rgb_color, gdev_t4693d_map_color_rgb);
+        devprocs_initialize(t4693d_initialize);
 
 #define t4693d_prn_device(name,depth,max_rgb) {prn_device_body( \
         gx_device_printer,t4693d_procs,name, \
diff --git a/devices/gdevbit.c b/devices/gdevbit.c
index 8808c0239..d8347bc63 100644
--- a/devices/gdevbit.c
+++ b/devices/gdevbit.c
@@ -57,74 +57,21 @@ static dev_proc_put_image(bit_put_image);
 static dev_proc_dev_spec_op(bit_dev_spec_op);
 dev_proc_get_color_comp_index(gx_default_DevRGB_get_color_comp_index);
 
-#define bit_procs(encode_color)\
-{	gdev_prn_open,\
-        gx_default_get_initial_matrix,\
-        NULL,	/* sync_output */\
-        /* Since the print_page doesn't alter the device, this device can print in the background */\
-        gdev_prn_bg_output_page,\
-        gdev_prn_close,\
-        encode_color,	/* map_rgb_color */\
-        bit_map_color_rgb,	/* map_color_rgb */\
-        NULL,	/* fill_rectangle */\
-        NULL,	/* tile_rectangle */\
-        NULL,	/* copy_mono */\
-        NULL,	/* copy_color */\
-        NULL,	/* draw_line */\
-        NULL,	/* get_bits */\
-        bit_get_params,\
-        bit_put_params,\
-        encode_color,	/* map_cmyk_color */\
-        NULL,	/* get_xfont_procs */\
-        NULL,	/* get_xfont_device */\
-        NULL,	/* map_rgb_alpha_color */\
-        gx_page_device_get_page_device,	/* get_page_device */\
-        NULL,	/* get_alpha_bits */\
-        NULL,	/* copy_alpha */\
-        NULL,	/* get_band */\
-        NULL,	/* copy_rop */\
-        NULL,	/* fill_path */\
-        NULL,	/* stroke_path */\
-        NULL,	/* fill_mask */\
-        NULL,	/* fill_trapezoid */\
-        NULL,	/* fill_parallelogram */\
-        NULL,	/* fill_triangle */\
-        NULL,	/* draw_thin_line */\
-        NULL,	/* begin_image */\
-        NULL,	/* image_data */\
-        NULL,	/* end_image */\
-        NULL,	/* strip_tile_rectangle */\
-        NULL,	/* strip_copy_rop */\
-        NULL,	/* get_clipping_box */\
-        NULL,	/* begin_typed_image */\
-        NULL,	/* get_bits_rectangle */\
-        NULL,	/* map_color_rgb_alpha */\
-        NULL,	/* create_compositor */\
-        NULL,	/* get_hardware_params */\
-        NULL,	/* text_begin */\
-        NULL,	/* initialize */\
-        NULL,	/* begin_transparency_group */\
-        NULL,	/* end_transparency_group */\
-        NULL,	/* begin_transparency_mask */\
-        NULL,	/* end_transparency_mask */\
-        NULL,	/* discard_transparency_layer */\
-        NULL,	/* get_color_mapping_procs */\
-        NULL,	/* get_color_comp_index */\
-        encode_color,		/* encode_color */\
-        bit_map_color_rgb,	/* decode_color */\
-        NULL,   /* pattern_manage */\
-        NULL,   /* fill_rectangle_hl_color */\
-        NULL,   /* include_color_space */\
-        NULL,   /* fill_linear_color_scanline */\
-        NULL,   /* fill_linear_color_trapezoid */\
-        NULL,   /* fill_linear_color_triangle */\
-        NULL,   /* update_spot_equivalent_colors */\
-        NULL,   /* ret_devn_params */\
-        NULL,   /* fillpage */\
-        NULL,   /* push_transparency_state */\
-        NULL,   /* pop_transparency_state */\
-        NULL,   /* put_image */\
-        bit_dev_spec_op\
+static int
+bit_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_color_rgb, bit_map_color_rgb);
+    set_dev_proc(dev, get_params, bit_get_params);
+    set_dev_proc(dev, put_params, bit_put_params);
+    set_dev_proc(dev, decode_color, bit_map_color_rgb);
+    set_dev_proc(dev, dev_spec_op, bit_dev_spec_op);
+
+    return 0;
 }
 
 /*
@@ -144,8 +91,24 @@ struct gx_device_bit_s {
 };
 typedef struct gx_device_bit_s gx_device_bit;
 
+static int
+bitmono_initialize(gx_device *dev)
+{
+    int code = bit_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, bit_mono_map_color);
+    set_dev_proc(dev, map_cmyk_color, bit_mono_map_color);
+    set_dev_proc(dev, encode_color, bit_mono_map_color);
+
+    return 0;
+}
+
 static const gx_device_procs bitmono_procs =
-bit_procs(bit_mono_map_color);
+    devprocs_initialize(bitmono_initialize);
+
 const gx_device_bit gs_bit_device =
 {prn_device_body(gx_device_bit, bitmono_procs, "bit",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -154,8 +117,24 @@ const gx_device_bit gs_bit_device =
                  1, 1, 1, 0, 2, 1, bit_print_page)
 };
 
+static int
+bitrgb_initialize(gx_device *dev)
+{
+    int code = bit_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, bitrgb_rgb_map_rgb_color);
+    set_dev_proc(dev, map_cmyk_color, bitrgb_rgb_map_rgb_color);
+    set_dev_proc(dev, encode_color, bitrgb_rgb_map_rgb_color);
+
+    return 0;
+}
+
 static const gx_device_procs bitrgb_procs =
-bit_procs(bitrgb_rgb_map_rgb_color);
+    devprocs_initialize(bitrgb_initialize);
+
 const gx_device_bit gs_bitrgb_device =
 {prn_device_body(gx_device_bit, bitrgb_procs, "bitrgb",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -164,8 +143,23 @@ const gx_device_bit gs_bitrgb_device =
                  3, 4, 1, 1, 2, 2, bit_print_page)
 };
 
+static int
+bitcmyk_initialize(gx_device *dev)
+{
+    int code = bit_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, bit_map_cmyk_color);
+    set_dev_proc(dev, map_cmyk_color, bit_map_cmyk_color);
+    set_dev_proc(dev, encode_color, bit_map_cmyk_color);
+
+    return 0;
+}
+
 static const gx_device_procs bitcmyk_procs =
-bit_procs(bit_map_cmyk_color);
+    devprocs_initialize(bitcmyk_initialize);
 const gx_device_bit gs_bitcmyk_device =
 {prn_device_body(gx_device_bit, bitcmyk_procs, "bitcmyk",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -174,75 +168,32 @@ const gx_device_bit gs_bitcmyk_device =
                  4, 4, 1, 1, 2, 2, bit_print_page)
 };
 
+static int
+bitrgbtags_initialize(gx_device *dev)
+{
+    int code = bit_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, bittag_open);
+    set_dev_proc(dev, map_rgb_color, bittag_rgb_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, bittag_map_color_rgb);
+    set_dev_proc(dev, get_params, gdev_prn_get_params);
+    set_dev_proc(dev, put_params, bittag_put_params);
+    set_dev_proc(dev, map_cmyk_color, bittag_rgb_map_rgb_color);
+    set_dev_proc(dev, get_color_mapping_procs, bittag_get_color_mapping_procs);
+    set_dev_proc(dev, get_color_comp_index, gx_default_DevRGB_get_color_comp_index);
+    set_dev_proc(dev, encode_color, bittag_rgb_map_rgb_color);
+    set_dev_proc(dev, decode_color, bittag_map_color_rgb);
+    set_dev_proc(dev, fillpage, bittag_fillpage);
+    set_dev_proc(dev, put_image, bit_put_image);
+
+    return 0;
+}
+
 static const gx_device_procs bitrgbtags_procs =
-    {
-        bittag_open,                        /* open_device */
-        gx_default_get_initial_matrix,        /* initial_matrix */
-        ((void *)0),                        /* sync_output */
-        gdev_prn_output_page,                 /* output page */
-        gdev_prn_close,                       /* close_device */
-        bittag_rgb_map_rgb_color,             /* map rgb color */
-        bittag_map_color_rgb,                 /* map color rgb */
-        ((void *)0),                        /* fill_rectangle */
-        ((void *)0),                        /* tile rectangle */
-        ((void *)0),                        /* copy mono */
-        ((void *)0),                        /* copy color */
-        ((void *)0),                        /* obsolete draw line */
-        ((void *)0),                        /* get_bits */
-        gdev_prn_get_params,                  /* get params */
-        bittag_put_params,                    /* put params */
-        bittag_rgb_map_rgb_color,             /* map_cmyk_color */
-        ((void *)0),                        /* get_xfonts */
-        ((void *)0),                        /* get_xfont_device */
-        ((void *)0),                        /* map_rgb_alpha_color */
-        gx_page_device_get_page_device,       /* get_page_device */
-        ((void *)0),                        /* get_alpha_bits */
-        ((void *)0),                        /* copy_alpha */
-        ((void *)0),                        /* get_band */
-        ((void *)0),                        /* copy_rop */
-        ((void *)0),                       /* fill_path */
-        ((void *)0),                       /* stroke_path */
-        ((void *)0),                       /* fill_mask */
-        ((void *)0),                        /* fill_trapezoid */
-        ((void *)0),                        /* fill_parallelogram */
-        ((void *)0),                        /* fill_triangle */
-        ((void *)0),                        /* draw_thin_line */
-        ((void *)0),                        /* begin_image */
-        ((void *)0),                        /* image_data */
-        ((void *)0),                        /* end_image */
-        ((void *)0),                        /* strip_tile_rectangle */
-        ((void *)0),                        /* strip_copy_rop */
-        ((void *)0),                        /* get_clipping_box */
-        ((void *)0),                        /* begin_typed_image */
-        ((void *)0),                        /* get_bits_rectangle */
-        ((void *)0),                        /* map_color_rgb_alpha */
-        ((void *)0),                       /* create_compositor */
-        ((void *)0),                       /* get_hardware_params */
-        ((void *)0),                       /* text_begin */
-        ((void *)0),                       /* initialize */
-        ((void *)0),                       /* begin_transparency_group */
-        ((void *)0),                       /* end_transparency_group */
-        ((void *)0),                       /* begin_transparency_mask */
-        ((void *)0),                       /* end_transparency_mask */
-        ((void *)0),                       /* discard_transparency_layer */
-        bittag_get_color_mapping_procs,      /* get_color_mapping_procs */
-        gx_default_DevRGB_get_color_comp_index, /* get_color_comp_index */
-        bittag_rgb_map_rgb_color,           /* encode_color */
-        bittag_map_color_rgb,               /* decode_color */
-        ((void *)0),                        /* pattern_manage */
-        ((void *)0),                        /* fill_rectangle_hl_color */
-        ((void *)0),                        /* include_color_space */
-        ((void *)0),                        /* fill_linear_color_scanline */
-        ((void *)0),                        /* fill_linear_color_trapezoid */
-        ((void *)0),                        /* fill_linear_color_triangle */
-        ((void *)0),                        /* update_spot_equivalent_colors */
-        ((void *)0),                        /* ret_devn_params */
-        bittag_fillpage,                    /* fillpage */
-        ((void *)0),                        /* push_transparency_state */
-        ((void *)0),                        /* pop_transparency_state */
-        bit_put_image,                      /* put_image */
-        bit_dev_spec_op                     /* dev_spec_op */
-    };
+    devprocs_initialize(bitrgbtags_initialize);
 
 const gx_device_bit gs_bitrgbtags_device =
     {
diff --git a/devices/gdevbj10.c b/devices/gdevbj10.c
index 9468552a4..4d411500c 100644
--- a/devices/gdevbj10.c
+++ b/devices/gdevbj10.c
@@ -106,9 +106,22 @@ static dev_proc_open_device(bj200_open);
 
 static dev_proc_print_page(bj10e_print_page);
 
-static gx_device_procs prn_bj200_procs =
 /* Since the print_page doesn't alter the device, this device can print in the background */
-  prn_procs(bj200_open, gdev_prn_bg_output_page, gdev_prn_close);
+static int
+bj200_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, bj200_open);
+
+    return 0;
+}
+
+static gx_device_procs prn_bj200_procs =
+    devprocs_initialize(bj200_initialize);
 
 const gx_device_printer far_data gs_bj200_device =
   prn_device(prn_bj200_procs, "bj200",
@@ -142,8 +155,21 @@ const gx_device_printer far_data gs_bj200_device =
 
 static dev_proc_open_device(bj10e_open);
 
+static int
+bj10e_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, bj10e_open);
+
+    return 0;
+}
+
 static gx_device_procs prn_bj10e_procs =
-  prn_procs(bj10e_open, gdev_prn_output_page, gdev_prn_close);
+    devprocs_initialize(bj10e_initialize);
 
 const gx_device_printer far_data gs_bj10e_device =
   prn_device(prn_bj10e_procs, "bj10e",
diff --git a/devices/gdevbmp.c b/devices/gdevbmp.c
index 52a133745..fb4c75f36 100644
--- a/devices/gdevbmp.c
+++ b/devices/gdevbmp.c
@@ -37,8 +37,8 @@ prn_device(prn_bg_procs, "bmpmono",	/* The print_page proc is compatible with al
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static const gx_device_procs bmpgray_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                gx_default_gray_map_rgb_color, gx_default_gray_map_color_rgb);
+    devprocs_initialize(gdev_prn_initialize_gray_bg);
+
 const gx_device_printer gs_bmpgray_device = {
   prn_device_body(gx_device_printer, bmpgray_procs, "bmpgray",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -56,9 +56,9 @@ const gx_device_printer gs_bmpgray_device = {
     gdev_prn_get_params, gdev_prn_put_params,\
     p_map_cmyk_color, NULL, NULL, NULL, gx_page_device_get_page_device
 
-static const gx_device_procs bmpsep1_procs = {
-    bmp_cmyk_procs(cmyk_1bit_map_color_rgb, cmyk_1bit_map_cmyk_color)
-};
+static const gx_device_procs bmpsep1_procs =
+    devprocs_initialize(gdev_prn_initialize_cmyk1_bg);
+
 const gx_device_printer gs_bmpsep1_device = {
   prn_device_body(gx_device_printer, bmpsep1_procs, "bmpsep1",
         DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -68,10 +68,9 @@ const gx_device_printer gs_bmpsep1_device = {
 };
 
 /* 8-bit-per-plane separated CMYK color. */
+static const gx_device_procs bmpsep8_procs =
+    devprocs_initialize(gdev_prn_initialize_cmyk8_bg);
 
-static const gx_device_procs bmpsep8_procs = {
-    bmp_cmyk_procs(cmyk_8bit_map_color_rgb, cmyk_8bit_map_cmyk_color)
-};
 const gx_device_printer gs_bmpsep8_device = {
   prn_device_body(gx_device_printer, bmpsep8_procs, "bmpsep8",
         DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -83,9 +82,22 @@ const gx_device_printer gs_bmpsep8_device = {
 /* 4-bit planar (EGA/VGA-style) color. */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+bmpsep16_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk8_bg(dev);
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, pc_4bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pc_4bit_map_color_rgb);
+
+    return 0;
+}
+
 static const gx_device_procs bmp16_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                pc_4bit_map_rgb_color, pc_4bit_map_color_rgb);
+    devprocs_initialize(bmpsep16_initialize);
+
 const gx_device_printer gs_bmp16_device = {
   prn_device_body(gx_device_printer, bmp16_procs, "bmp16",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -98,9 +110,22 @@ const gx_device_printer gs_bmp16_device = {
 /* (Uses a fixed palette of 3,3,2 bits.) */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+bmp256_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, pc_8bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pc_8bit_map_color_rgb);
+
+    return 0;
+}
+
 static const gx_device_procs bmp256_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                pc_8bit_map_rgb_color, pc_8bit_map_color_rgb);
+    devprocs_initialize(bmp256_initialize);
+
 const gx_device_printer gs_bmp256_device = {
   prn_device_body(gx_device_printer, bmp256_procs, "bmp256",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -112,9 +137,22 @@ const gx_device_printer gs_bmp256_device = {
 /* 24-bit color. */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+bmp16m_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, bmp_map_16m_rgb_color);
+    set_dev_proc(dev, map_color_rgb, bmp_map_16m_color_rgb);
+
+    return 0;
+}
+
 static const gx_device_procs bmp16m_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                bmp_map_16m_rgb_color, bmp_map_16m_color_rgb);
+    devprocs_initialize(bmp16m_initialize);
+
 const gx_device_printer gs_bmp16m_device =
 prn_device(bmp16m_procs, "bmp16m",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -123,10 +161,9 @@ prn_device(bmp16m_procs, "bmp16m",
            24, bmp_print_page);
 
 /* 32-bit CMYK color (outside the BMP specification). */
+static const gx_device_procs bmp32b_procs =
+    devprocs_initialize(gdev_prn_initialize_cmyk8_bg);
 
-static const gx_device_procs bmp32b_procs = {
-    bmp_cmyk_procs(cmyk_8bit_map_color_rgb, gx_default_cmyk_map_cmyk_color)
-};
 const gx_device_printer gs_bmp32b_device =
 prn_device(bmp32b_procs, "bmp32b",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
diff --git a/devices/gdevccr.c b/devices/gdevccr.c
index 451cb82c0..d4906c99c 100644
--- a/devices/gdevccr.c
+++ b/devices/gdevccr.c
@@ -96,10 +96,23 @@ static dev_proc_map_color_rgb(ccr_map_color_rgb);
 static dev_proc_print_page(ccr_print_page);
 
 /* The device procedures */
+static int
+ccr_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, ccr_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, ccr_map_color_rgb);
+
+    return 0;
+}
+
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static gx_device_procs ccr_procs =
-    prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                    ccr_map_rgb_color, ccr_map_color_rgb);
+    devprocs_initialize(ccr_initialize);
 
 /* The device descriptors themselves */
 gx_device_ccr far_data gs_ccr_device =
diff --git a/devices/gdevcdj.c b/devices/gdevcdj.c
index dc014077a..733c09219 100644
--- a/devices/gdevcdj.c
+++ b/devices/gdevcdj.c
@@ -454,115 +454,217 @@ typedef struct {
 }
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
-#define hp_colour_procs(proc_colour_open, proc_get_params, proc_put_params) {\
-        proc_colour_open,\
-        gx_default_get_initial_matrix,\
-        gx_default_sync_output,\
-        gdev_prn_bg_output_page,\
-        gdev_prn_close,\
-        gdev_pcl_map_rgb_color,\
-        gdev_pcl_map_color_rgb,\
-        NULL,	/* fill_rectangle */\
-        NULL,	/* tile_rectangle */\
-        NULL,	/* copy_mono */\
-        NULL,	/* copy_color */\
-        NULL,	/* draw_line */\
-        gx_default_get_bits,\
-        proc_get_params,\
-        proc_put_params\
+static int
+hp_colour_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, gdev_pcl_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_pcl_map_color_rgb);
+    set_dev_proc(dev, get_params, cdj_get_params);
+    set_dev_proc(dev, put_params, cdj_put_params);
+
+    return 0;
 }
 
-/* Since the print_page doesn't alter the device, this device can print in the background */
-#define cmyk_colour_procs(proc_colour_open, proc_get_params, proc_put_params) {\
-        proc_colour_open,\
-        gx_default_get_initial_matrix,\
-        gx_default_sync_output,\
-        gdev_prn_bg_output_page,\
-        gdev_prn_close,\
-        NULL /* map_rgb_color */,\
-        NULL /* map_color_rgb */,\
-        NULL /* fill_rectangle */,\
-        NULL /* tile_rectangle */,\
-        NULL /* copy_mono */,\
-        NULL /* copy_color */,\
-        NULL /* draw_line */,\
-        gx_default_get_bits,\
-        proc_get_params,\
-        proc_put_params,\
-        gdev_cmyk_map_cmyk_color,\
-        NULL,	/* get_xfont_procs */\
-        NULL,	/* get_xfont_device */\
-        NULL,	/* map_rgb_alpha_color */\
-        NULL,	/* get_page_device */\
-        NULL,	/* get_alpha_bits */\
-        NULL,	/* copy_alpha */\
-        NULL,	/* get_band */\
-        NULL,	/* copy_rop */\
-        NULL,	/* fill_path */\
-        NULL,	/* stroke_path */\
-        NULL,	/* fill_mask */\
-        NULL,	/* fill_trapezoid */\
-        NULL,	/* fill_parallelogram */\
-        NULL,	/* fill_triangle */\
-        NULL,	/* draw_thin_line */\
-        NULL,	/* begin_image */\
-        NULL,	/* image_data */\
-        NULL,	/* end_image */\
-        NULL,	/* strip_tile_rectangle */\
-        NULL,	/* strip_copy_rop */\
-        NULL,	/* get_clipping_box */\
-        NULL,	/* begin_typed_image */\
-        NULL,	/* get_bits_rectangle */\
-        NULL,	/* map_color_rgb_alpha */\
-        NULL,	/* create_compositor */\
-        NULL,	/* get_hardware_params */\
-        NULL,	/* text_begin */\
-        NULL,	/* initialize */\
-        NULL,	/* begin_transparency_group */\
-        NULL,	/* end_transparency_group */\
-        NULL,	/* begin_transparency_mask */\
-        NULL,	/* end_transparency_mask */\
-        NULL,	/* discard_transparency_layer */\
-        NULL,	/* get_color_mapping_procs */\
-        NULL,	/* get_color_comp_index */\
-        gdev_cmyk_map_cmyk_color,	/* encode_color */\
-        gdev_cmyk_map_color_cmyk	/* decode_color */\
+static int
+cdj500_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, dj500c_open);
+
+    return 0;
 }
 
 static gx_device_procs cdj500_procs =
-hp_colour_procs(dj500c_open, cdj_get_params, cdj_put_params);
+    devprocs_initialize(cdj500_initialize);
+
+static int
+cdj550_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, dj550c_open);
+
+    return 0;
+}
 
 static gx_device_procs cdj550_procs =
-hp_colour_procs(dj550c_open, cdj_get_params, cdj_put_params);
+    devprocs_initialize(cdj550_initialize);
 
 #ifdef USE_CDJ550_CMYK
+static int
+cdj550cmyk_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, dj550c_open);
+    set_dev_proc(dev, get_params, cdj_get_params);
+    set_dev_proc(dev, put_params, cdj_put_params);
+    set_dev_proc(dev, map_cmyk_color, gdev_cmyk_map_cmyk_color);
+    set_dev_proc(dev, encode_color, gdev_cmyk_map_cmyk_color);
+    set_dev_proc(dev, decode_color, gdev_cmyk_map_color_cmyk);
+
+    return 0;
+}
+
 static gx_device_procs cdj550cmyk_procs =
-cmyk_colour_procs(dj550c_open, cdj_get_params, cdj_put_params);
+    devprocs_initialize(cdj550cmyk_initialize);
 #endif
 
+static int
+dj505j_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, dj505j_open);
+
+    return 0;
+}
+
 static gx_device_procs dj505j_procs =
-hp_colour_procs(dj505j_open, cdj_get_params, cdj_put_params);
+    devprocs_initialize(dj505j_initialize);
+
+static int
+dnj650c_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, dnj650c_open);
+
+    return 0;
+}
 
 static gx_device_procs dnj650c_procs =
-hp_colour_procs(dnj650c_open, cdj_get_params, cdj_put_params);
+    devprocs_initialize(dnj650c_initialize);
+
+static int
+lj4dith_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, lj4dith_open);
+
+    return 0;
+}
 
 static gx_device_procs lj4dith_procs =
-hp_colour_procs(lj4dith_open, cdj_get_params, cdj_put_params);
+    devprocs_initialize(lj4dith_initialize);
+
+static int
+pj_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pj_open);
+    set_dev_proc(dev, get_params, gdev_prn_get_params);
+    set_dev_proc(dev, put_params, pj_put_params);
+
+    return 0;
+}
 
 static gx_device_procs pj_procs =
-hp_colour_procs(pj_open, gdev_prn_get_params, pj_put_params);
+    devprocs_initialize(pj_initialize);
+
+static int
+pjxl_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pjxl_open);
+    set_dev_proc(dev, get_params, pjxl_get_params);
+    set_dev_proc(dev, put_params, pjxl_put_params);
+
+    return 0;
+}
 
 static gx_device_procs pjxl_procs =
-hp_colour_procs(pjxl_open, pjxl_get_params, pjxl_put_params);
+    devprocs_initialize(pjxl_initialize);
+
+static int
+pjxl300_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pjxl300_open);
+    set_dev_proc(dev, get_params, pjxl_get_params);
+    set_dev_proc(dev, put_params, pjxl_put_params);
+
+    return 0;
+}
 
 static gx_device_procs pjxl300_procs =
-hp_colour_procs(pjxl300_open, pjxl_get_params, pjxl_put_params);
+    devprocs_initialize(pjxl300_initialize);
+
+static int
+bjc_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, bjc_open);
+    set_dev_proc(dev, get_params, bjc_get_params);
+    set_dev_proc(dev, put_params, bjc_put_params);
+    set_dev_proc(dev, map_cmyk_color, gdev_cmyk_map_cmyk_color);
+    set_dev_proc(dev, encode_color, gdev_cmyk_map_cmyk_color);
+    set_dev_proc(dev, decode_color, gdev_cmyk_map_color_cmyk);
+
+    return 0;
+}
 
 static gx_device_procs bjc_procs =
-cmyk_colour_procs(bjc_open, bjc_get_params, bjc_put_params);
+    devprocs_initialize(bjc_initialize);
+
+static int
+escp_initialize(gx_device *dev)
+{
+    int code = hp_colour_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, escp_open);
+    set_dev_proc(dev, get_params, ep_get_params);
+    set_dev_proc(dev, put_params, ep_put_params);
+
+    return 0;
+}
 
 static gx_device_procs escp_procs =
-hp_colour_procs(escp_open, ep_get_params, ep_put_params);
+    devprocs_initialize(escp_initialize);
 
 gx_device_cdj far_data gs_cdjmono_device =
 cdj_device(cdj500_procs, "cdjmono", 300, 300, 1,
diff --git a/devices/gdevcfax.c b/devices/gdevcfax.c
index cd3dc15cc..9ffead664 100644
--- a/devices/gdevcfax.c
+++ b/devices/gdevcfax.c
@@ -28,9 +28,22 @@ static dev_proc_close_device(cfax_prn_close);
 /* an additional "end of document" signature after the last */
 /* "end page" signature */
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+cfax_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, close_device, cfax_prn_close);
+    set_dev_proc(dev, get_params, gdev_fax_get_params);
+    set_dev_proc(dev, put_params, gdev_fax_put_params);
+
+    return 0;
+}
 static const gx_device_procs gdev_cfax_std_procs =
-    prn_params_procs(gdev_prn_open, gdev_prn_bg_output_page, cfax_prn_close,
-                     gdev_fax_get_params, gdev_fax_put_params);
+    devprocs_initialize(cfax_initialize);
 
 const gx_device_fax gs_cfax_device = {
     FAX_DEVICE_BODY(gx_device_fax, gdev_cfax_std_procs, "cfax", cfax_print_page)
diff --git a/devices/gdevchameleon.c b/devices/gdevchameleon.c
index 20abe218f..7f529e127 100644
--- a/devices/gdevchameleon.c
+++ b/devices/gdevchameleon.c
@@ -59,75 +59,28 @@ struct gx_device_chameleon_s {
 };
 typedef struct gx_device_chameleon_s gx_device_chameleon;
 
+static int
+chameleon_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, chameleon_rgb_encode_color);
+    set_dev_proc(dev, map_color_rgb, chameleon_rgb_decode_color);
+    set_dev_proc(dev, get_params, chameleon_get_params);
+    set_dev_proc(dev, put_params, chameleon_put_params);
+    set_dev_proc(dev, map_cmyk_color, chameleon_rgb_encode_color);
+    set_dev_proc(dev, encode_color, chameleon_rgb_encode_color);
+    set_dev_proc(dev, decode_color, chameleon_rgb_decode_color);
+    set_dev_proc(dev, dev_spec_op, chameleon_spec_op);
+
+    return 0;
+}
+
 static const gx_device_procs chameleon_procs =
-{	gdev_prn_open,
-        gx_default_get_initial_matrix,
-        NULL,	/* sync_output */
-        /* Since the print_page doesn't alter the device, this device can print in the background */
-        gdev_prn_bg_output_page,
-        gdev_prn_close,
-        chameleon_rgb_encode_color,	/* map_rgb_color */
-        chameleon_rgb_decode_color,	/* map_color_rgb */
-        NULL,	/* fill_rectangle */
-        NULL,	/* tile_rectangle */
-        NULL,	/* copy_mono */
-        NULL,	/* copy_color */
-        NULL,	/* draw_line */
-        NULL,	/* get_bits */
-        chameleon_get_params,
-        chameleon_put_params,
-        chameleon_rgb_encode_color,	/* map_cmyk_color */
-        NULL,	/* get_xfont_procs */
-        NULL,	/* get_xfont_device */
-        NULL,	/* map_rgb_alpha_color */
-        gx_page_device_get_page_device,	/* get_page_device */
-        NULL,	/* get_alpha_bits */
-        NULL,	/* copy_alpha */
-        NULL,	/* get_band */
-        NULL,	/* copy_rop */
-        NULL,	/* fill_path */
-        NULL,	/* stroke_path */
-        NULL,	/* fill_mask */
-        NULL,	/* fill_trapezoid */
-        NULL,	/* fill_parallelogram */
-        NULL,	/* fill_triangle */
-        NULL,	/* draw_thin_line */
-        NULL,	/* begin_image */
-        NULL,	/* image_data */
-        NULL,	/* end_image */
-        NULL,	/* strip_tile_rectangle */
-        NULL,	/* strip_copy_rop */
-        NULL,	/* get_clipping_box */
-        NULL,	/* begin_typed_image */
-        NULL,	/* get_bits_rectangle */
-        NULL,	/* map_color_rgb_alpha */
-        NULL,	/* create_compositor */
-        NULL,	/* get_hardware_params */
-        NULL,	/* text_begin */
-        NULL,	/* finish_copydevice */
-        NULL,	/* begin_transparency_group */
-        NULL,	/* end_transparency_group */
-        NULL,	/* begin_transparency_mask */
-        NULL,	/* end_transparency_mask */
-        NULL,	/* discard_transparency_layer */
-        NULL,	/* get_color_mapping_procs */
-        NULL,	/* get_color_comp_index */
-        chameleon_rgb_encode_color,/* encode_color */
-        chameleon_rgb_decode_color, /* decode_color */
-        NULL,   /* pattern_manage */
-        NULL,   /* fill_rectangle_hl_color */
-        NULL,   /* include_color_space */
-        NULL,   /* fill_linear_color_scanline */
-        NULL,   /* fill_linear_color_trapezoid */
-        NULL,   /* fill_linear_color_triangle */
-        NULL,   /* update_spot_equivalent_colors */
-        NULL,   /* ret_devn_params */
-        NULL,   /* fillpage */
-        NULL,   /* push_transparency_state */
-        NULL,   /* pop_transparency_state */
-        NULL,   /* put_image */
-        chameleon_spec_op   /* dev_spec_op */
-};
+    devprocs_initialize(chameleon_initialize);
 
 const gx_device_chameleon gs_chameleon_device =
 {prn_device_body(gx_device_chameleon, chameleon_procs, "chameleon",
diff --git a/devices/gdevclj.c b/devices/gdevclj.c
index 5edac41ef..a423c6f26 100644
--- a/devices/gdevclj.c
+++ b/devices/gdevclj.c
@@ -515,32 +515,37 @@ xit:
 }
 
 /* CLJ device methods */
-#define CLJ_PROCS(get_params, put_params)\
-    gdev_prn_open,                  /* open_device */\
-    clj_get_initial_matrix,         /* get_initial matrix */\
-    NULL,	                    /* sync_output */\
-/* Since the print_page doesn't alter the device, this device can print in the background */\
-    gdev_prn_bg_output_page,        /* output_page */\
-    gdev_prn_close,                 /* close_device */\
-    gdev_pcl_3bit_map_rgb_color,    /* map_rgb_color */\
-    gdev_pcl_3bit_map_color_rgb,    /* map_color_rgb */\
-    NULL,	                    /* fill_rectangle */\
-    NULL,	                    /* tile_rectangle */\
-    NULL,	                    /* copy_mono */\
-    NULL,	                    /* copy_color */\
-    NULL,	                    /* obsolete draw_line */\
-    NULL,	                    /* get_bits */\
-    get_params, 	            /* get_params */\
-    put_params,                     /* put_params */\
-    NULL,	                    /* map_cmyk_color */\
-    NULL,	                    /* get_xfont_procs */\
-    NULL,	                    /* get_xfont_device */\
-    NULL,	                    /* map_rgb_alpha_color */\
-    gx_page_device_get_page_device  /* get_page_device */
-
-static gx_device_procs cljet5_procs = {
-    CLJ_PROCS(clj_get_params, clj_put_params)
-};
+static int
+clj_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_initial_matrix, clj_get_initial_matrix);
+    set_dev_proc(dev, map_rgb_color, gdev_pcl_3bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_pcl_3bit_map_color_rgb);
+
+    return 0;
+}
+
+static int
+cljet5_initialize(gx_device *dev)
+{
+    int code = clj_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, clj_get_params);
+    set_dev_proc(dev, put_params, clj_put_params);
+
+    return 0;
+}
+
+static gx_device_procs cljet5_procs =
+    devprocs_initialize(cljet5_initialize);
 
 /* CLJ device structure */
 #define CLJ_DEVICE_BODY(procs, dname, rotated)\
@@ -677,9 +682,22 @@ clj_pr_put_params(
 }
 
 /* CLJ device methods -- se above for CLJ_PROCS */
-static gx_device_procs cljet5pr_procs = {
-    CLJ_PROCS(clj_pr_get_params, clj_pr_put_params)
-};
+static int
+cljet5pr_initialize(gx_device *dev)
+{
+    int code = clj_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, clj_pr_get_params);
+    set_dev_proc(dev, put_params, clj_pr_put_params);
+
+    return 0;
+}
+
+static gx_device_procs cljet5pr_procs =
+    devprocs_initialize(cljet5pr_initialize);
 
 /* CLJ device structure -- see above for CLJ_DEVICE_BODY */
 gx_device_clj gs_cljet5pr_device = {
diff --git a/devices/gdevcljc.c b/devices/gdevcljc.c
index bf8a4b821..7f0f2d3cf 100644
--- a/devices/gdevcljc.c
+++ b/devices/gdevcljc.c
@@ -85,8 +85,7 @@ out:
 /* CLJ device methods */
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static gx_device_procs cljc_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb);
+    devprocs_initialize(gdev_prn_initialize_rgb_bg);
 
 /* the CLJ device */
 const gx_device_printer gs_cljet5c_device =
diff --git a/devices/gdevcmykog.c b/devices/gdevcmykog.c
index ff9919661..6caec93ee 100644
--- a/devices/gdevcmykog.c
+++ b/devices/gdevcmykog.c
@@ -718,73 +718,26 @@ prn_done:
 
 /* Finally, the device definition itself */
 
-#define device_procs(get_color_mapping_procs)\
-{       cmykog_open,			/* open device */\
-        gx_default_get_initial_matrix,	/* initialize matrix */\
-        NULL,                           /* sync_output */\
-        gdev_prn_bg_output_page,        /* output_page */\
-        cmykog_close,                   /* close */\
-        NULL,                           /* map_rgb_color - not used */\
-        NULL,                           /* map_color_rgb - not used */\
-        NULL,                           /* fill_rectangle */\
-        NULL,                           /* tile_rectangle */\
-        NULL,                           /* copy_mono */\
-        NULL,                           /* copy_color */\
-        NULL,                           /* draw_line */\
-        NULL,                           /* get_bits */\
-        gx_devn_prn_get_params,         /* get_params */\
-        cmykog_put_params,              /* put_params */\
-        NULL,                           /* map_cmyk_color - not used */\
-        NULL,                           /* get_xfont_procs */\
-        NULL,                           /* get_xfont_device */\
-        NULL,                           /* map_rgb_alpha_color */\
-        gx_page_device_get_page_device, /* get_page_device */\
-        NULL,                           /* get_alpha_bits */\
-        NULL,                           /* copy_alpha */\
-        NULL,                           /* get_band */\
-        NULL,                           /* copy_rop */\
-        NULL,                           /* fill_path */\
-        NULL,                           /* stroke_path */\
-        NULL,                           /* fill_mask */\
-        NULL,                           /* fill_trapezoid */\
-        NULL,                           /* fill_parallelogram */\
-        NULL,                           /* fill_triangle */\
-        NULL,                           /* draw_thin_line */\
-        NULL,                           /* begin_image */\
-        NULL,                           /* image_data */\
-        NULL,                           /* end_image */\
-        NULL,                           /* strip_tile_rectangle */\
-        NULL,                           /* strip_copy_rop */\
-        NULL,                           /* get_clipping_box */\
-        NULL,                           /* begin_typed_image */\
-        NULL,                           /* get_bits_rectangle */\
-        NULL,                           /* map_color_rgb_alpha */\
-        NULL,                           /* create_compositor */\
-        NULL,                           /* get_hardware_params */\
-        NULL,                           /* text_begin */\
-        NULL,                           /* initialize */\
-        NULL,                           /* begin_transparency_group */\
-        NULL,                           /* end_transparency_group */\
-        NULL,                           /* begin_transparency_mask */\
-        NULL,                           /* end_transparency_mask */\
-        NULL,                           /* discard_transparency_layer */\
-        gx_devn_prn_get_color_mapping_procs,/* get_color_mapping_procs */\
-        cmykog_get_color_comp_index,    /* get_color_comp_index */\
-        gx_devn_prn_encode_color,       /* encode_color */\
-        gx_devn_prn_decode_color,       /* decode_color */\
-        NULL,                           /* pattern_manage */\
-        NULL,                           /* fill_rectangle_hl_color */\
-        NULL,				/* include_color_space */\
-        NULL,				/* fill_linear_color_scanline */\
-        NULL,				/* fill_linear_color_trapezoid */\
-        NULL,				/* fill_linear_color_triangle */\
-        NULL,                           /* update_spot_equivalent_colors */\
-        gx_devn_prn_ret_devn_params,    /* ret_devn_params */\
-        NULL,                           /* fillpage */\
-        NULL,                           /* push_transparency_state */\
-        NULL,                           /* pop_transparency_state */\
-        NULL,                           /* put_image */\
-        cmykog_dev_spec_op                 /* dev_spec_op */\
+static int
+psdcmykog_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, cmykog_open);
+    set_dev_proc(dev, close_device, cmykog_close);
+    set_dev_proc(dev, get_params, gx_devn_prn_get_params);
+    set_dev_proc(dev, put_params, cmykog_put_params);
+    set_dev_proc(dev, get_color_mapping_procs, gx_devn_prn_get_color_mapping_procs);
+    set_dev_proc(dev, get_color_comp_index, cmykog_get_color_comp_index);
+    set_dev_proc(dev, encode_color, gx_devn_prn_encode_color);
+    set_dev_proc(dev, decode_color, gx_devn_prn_decode_color);
+    set_dev_proc(dev, ret_devn_params, gx_devn_prn_ret_devn_params);
+    set_dev_proc(dev, dev_spec_op, cmykog_dev_spec_op);
+
+    return 0;
 }
 
 fixed_colorant_name DevCMYKOGComponents[] = {
@@ -819,7 +772,8 @@ fixed_colorant_name DevCMYKOGComponents[] = {
 /*
  * PSDCMYKOG 8bits
  */
-static const gx_device_procs cmykog_procs = device_procs(get_cmykog_spot_color_mapping_procs);
+static const gx_device_procs cmykog_procs =
+    devprocs_initialize(psdcmykog_initialize);
 
 const gx_device_cmykog gs_psdcmykog_device =
 {
diff --git a/devices/gdevdfax.c b/devices/gdevdfax.c
index d113fd077..658199b05 100644
--- a/devices/gdevdfax.c
+++ b/devices/gdevdfax.c
@@ -42,8 +42,22 @@ struct gx_device_dfax_s {
 typedef struct gx_device_dfax_s gx_device_dfax;
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+dfax_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, dfax_prn_open);
+    set_dev_proc(dev, output_page, gdev_prn_bg_output_page_seekable);
+
+    return 0;
+}
+
 static gx_device_procs dfax_procs =
-  prn_procs(dfax_prn_open, gdev_prn_bg_output_page_seekable, gdev_prn_close);
+    devprocs_initialize(dfax_initialize);
 
 gx_device_dfax far_data gs_dfaxlow_device =
 {   prn_device_std_body(gx_device_dfax, dfax_procs, "dfaxlow",
diff --git a/devices/gdevdjet.c b/devices/gdevdjet.c
index 402e8aaa3..d7103f283 100644
--- a/devices/gdevdjet.c
+++ b/devices/gdevdjet.c
@@ -115,14 +115,41 @@ static dev_proc_get_params(hpjet_get_params);
 static dev_proc_put_params(hpjet_put_params);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+hpjet_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hpjet_open);
+    set_dev_proc(dev, close_device, hpjet_close);
+    set_dev_proc(dev, get_params, hpjet_get_params);
+    set_dev_proc(dev, put_params, hpjet_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs prn_hp_procs =
-prn_params_procs(hpjet_open, gdev_prn_bg_output_page, hpjet_close,
-                 hpjet_get_params, hpjet_put_params);
+    devprocs_initialize(hpjet_initialize);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+ljet4pjl_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hpjet_open);
+    set_dev_proc(dev, close_device, ljet4pjl_close);
+
+    return 0;
+}
 static gx_device_procs prn_ljet4pjl_procs =
-prn_params_procs(hpjet_open, gdev_prn_bg_output_page, ljet4pjl_close,
-                 gdev_prn_get_params, gdev_prn_put_params);
+    devprocs_initialize(ljet4pjl_initialize);
 
 typedef struct gx_device_hpjet_s gx_device_hpjet;
 
diff --git a/devices/gdevdjtc.c b/devices/gdevdjtc.c
index 34bb030d2..a1630a722 100644
--- a/devices/gdevdjtc.c
+++ b/devices/gdevdjtc.c
@@ -40,9 +40,21 @@
 static dev_proc_print_page(djet500c_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+djet500c_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return 0;
+
+    set_dev_proc(dev, map_rgb_color, gdev_pcl_3bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_pcl_3bit_map_color_rgb);
+
+    return 0;
+}
 static gx_device_procs djet500c_procs =
-  prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-    gdev_pcl_3bit_map_rgb_color, gdev_pcl_3bit_map_color_rgb);
+  devprocs_initialize(djet500c_initialize);
 
 const gx_device_printer far_data gs_djet500c_device =
   prn_device(djet500c_procs, "djet500c",
diff --git a/devices/gdevdsp.c b/devices/gdevdsp.c
index 8991bd813..f502f8542 100644
--- a/devices/gdevdsp.c
+++ b/devices/gdevdsp.c
@@ -105,76 +105,11 @@ static dev_proc_ret_devn_params(display_ret_devn_params);
 static dev_proc_dev_spec_op(display_spec_op);
 static dev_proc_fill_rectangle_hl_color(display_fill_rectangle_hl_color);
 
+extern dev_proc_open_device(clist_open);
+extern dev_proc_close_device(clist_close);
+
 static const gx_device_procs display_procs =
-{
-    display_open,
-    display_get_initial_matrix,
-    display_sync_output,
-    display_output_page,
-    display_close,
-    gx_default_w_b_map_rgb_color,
-    gx_default_w_b_map_color_rgb,
-    NULL, /* display_fill_rectangle - will be inserted later */
-    NULL,				/* tile rectangle */
-    NULL, /* display_copy_mono - will be inserted later */
-    NULL, /* display_copy_color - will be inserted later */
-    NULL,				/* draw line */
-    NULL, /* display_get_bits - will be inserted later */
-    display_get_params,
-    display_put_params,
-    gx_default_cmyk_map_cmyk_color, 	/* map_cmyk_color */
-    gx_default_get_xfont_procs,
-    NULL,				/* get_xfont_device */
-    NULL,				/* map_rgb_alpha_color */
-    gx_page_device_get_page_device,
-    /* extra entries */
-    NULL,				/* get_alpha_bits */
-    NULL,				/* copy_alpha */
-    NULL,				/* get_band */
-    NULL,				/* copy_rop */
-    NULL,				/* fill_path */
-    NULL,				/* stroke_path */
-    NULL,				/* fill_mask */
-    NULL,				/* fill_trapezoid */
-    NULL,				/* fill_parallelogram */
-    NULL,				/* fill_triangle */
-    NULL,				/* draw_thin_line */
-    NULL,				/* begin_image */
-    NULL,				/* image_data */
-    NULL,				/* end_image */
-    NULL,				/* strip_tile_rectangle */
-    NULL,				/* strip_copy_rop */
-    NULL,				/* get_clipping_box */
-    NULL,				/* begin_typed_image */
-    NULL,				/* get_bits_rectangle */
-    NULL,				/* map_color_rgb_alpha */
-    NULL,				/* create_compositor */
-    NULL,				/* get_hardware_params */
-    NULL,				/* text_begin */
-    display_initialize,		        /* initialize */
-    NULL,				/* begin_transparency_group */
-    NULL,				/* end_transparency_group */
-    NULL,				/* begin_transparency_mask */
-    NULL,				/* end_transparency_mask */
-    NULL,				/* discard_transparency_layer */
-    NULL,				/* get_color_mapping_procs */
-    NULL,				/* get_color_comp_index */
-    NULL,           			/* encode_color */
-    NULL,           			/* decode_color */
-    NULL,                          	/* pattern_manage */
-    display_fill_rectangle_hl_color,	/* fill_rectangle_hl_color */\
-    NULL,				/* include_color_space */\
-    NULL,				/* fill_linear_color_scanline */\
-    NULL,				/* fill_linear_color_trapezoid */\
-    NULL,				/* fill_linear_color_triangle */\
-    display_update_spot_equivalent_colors, /* update_spot_equivalent_colors */
-    display_ret_devn_params,		/* ret_devn_params */\
-    NULL,                        /* fillpage */\
-    NULL,                        /* push_transparency_state */\
-    NULL,                        /* pop_transparency_state */\
-    NULL,                        /* put_image */\
-    display_spec_op              /* dev_spec_op */\
-};
+    devprocs_initialize(display_initialize);
 
 /* GC descriptor */
 public_st_device_display();
@@ -1217,6 +1152,23 @@ display_initialize(gx_device *dev)
 {
     gx_device_display *ddev = (gx_device_display *) dev;
 
+    set_dev_proc(dev, open_device, display_open);
+    set_dev_proc(dev, get_initial_matrix, display_get_initial_matrix);
+    set_dev_proc(dev, sync_output, display_sync_output);
+    set_dev_proc(dev, output_page, display_output_page);
+    set_dev_proc(dev, close_device, display_close);
+    set_dev_proc(dev, map_rgb_color, gx_default_w_b_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gx_default_w_b_map_color_rgb);
+    set_dev_proc(dev, get_params, display_get_params);
+    set_dev_proc(dev, put_params, display_put_params);
+    set_dev_proc(dev, map_cmyk_color, gx_default_cmyk_map_cmyk_color);
+    set_dev_proc(dev, get_xfont_procs, gx_default_get_xfont_procs);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, fill_rectangle_hl_color, display_fill_rectangle_hl_color);
+    set_dev_proc(dev, update_spot_equivalent_colors, display_update_spot_equivalent_colors);
+    set_dev_proc(dev, ret_devn_params, display_ret_devn_params);
+    set_dev_proc(dev, dev_spec_op, display_spec_op);
+
     /* Mark the new instance as closed. */
     ddev->is_open = false;
 
@@ -1493,7 +1445,7 @@ display_free_bitmap(gx_device_display * ddev)
         gx_device_clist_common * const pcldev = &pclist_dev->common;
         gx_device_clist_reader * const pcrdev = &pclist_dev->reader;
         /* Close cmd list device & point to the storage */
-        (*gs_clist_device_procs.close_device)( (gx_device *)pcldev );
+        clist_close( (gx_device *)pcldev );
         ddev->buf = NULL;
         ddev->buffer_space = 0;
 
@@ -1750,8 +1702,11 @@ display_alloc_bitmap(gx_device_display * ddev, gx_device * param_dev)
                                       &display_buf_procs,
                                       ddev->orig_procs.dev_spec_op,
                                       MIN_BUFFER_SPACE);
-        if (ccode >= 0)
+        if (ccode >= 0) {
             ddev->procs = gs_clist_device_procs;
+            /* Hacky - we know this can't fail. */
+            clist_open((gx_device *)ddev);
+        }
     } else {
         /* Set up as PageMode. */
         gx_device *bdev = (gx_device *)ddev;
diff --git a/devices/gdevepsc.c b/devices/gdevepsc.c
index 5818eac8a..427ab9e50 100644
--- a/devices/gdevepsc.c
+++ b/devices/gdevepsc.c
@@ -143,9 +143,22 @@ epson_map_color_rgb(gx_device * dev, gx_color_index color,
 static dev_proc_print_page(epsc_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+epson_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, epson_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, epson_map_color_rgb);
+
+    return 0;
+}
+
 static gx_device_procs epson_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                epson_map_rgb_color, epson_map_color_rgb);
+    devprocs_initialize(epson_initialize);
 
 const gx_device_printer far_data gs_epsonc_device =
 prn_device(epson_procs, "epsonc",
diff --git a/devices/gdevfax.c b/devices/gdevfax.c
index f85d8392f..03396f33c 100644
--- a/devices/gdevfax.c
+++ b/devices/gdevfax.c
@@ -27,9 +27,23 @@ static dev_proc_print_page(faxg4_print_page);
 
 /* Define procedures that adjust the paper size. */
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+fax_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, gdev_prn_open);
+    set_dev_proc(dev, get_params, gdev_fax_get_params);
+    set_dev_proc(dev, put_params, gdev_fax_put_params);
+
+    return 0;
+}
+
 const gx_device_procs gdev_fax_std_procs =
-    prn_params_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                     gdev_fax_get_params, gdev_fax_put_params);
+    devprocs_initialize(fax_initialize);
 
 #define FAX_DEVICE(dname, print_page)\
 {\
diff --git a/devices/gdevfpng.c b/devices/gdevfpng.c
index 81fd7b49a..0cc4fd701 100644
--- a/devices/gdevfpng.c
+++ b/devices/gdevfpng.c
@@ -107,78 +107,24 @@ fpng_dev_spec_op(gx_device *pdev, int dev_spec_op, void *data, int size)
 /* 24-bit color. */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
-static const gx_device_procs fpng_procs =
+static int
+fpng_initialize(gx_device *dev)
 {
-        gdev_prn_open,
-        NULL,	/* get_initial_matrix */
-        NULL,	/* sync_output */
-        gdev_prn_bg_output_page,
-        gdev_prn_close,
-        gx_default_rgb_map_rgb_color,
-        gx_default_rgb_map_color_rgb,
-        NULL,	/* fill_rectangle */
-        NULL,	/* tile_rectangle */
-        NULL,	/* copy_mono */
-        NULL,	/* copy_color */
-        NULL,	/* draw_line */
-        NULL,	/* get_bits */
-        fpng_get_params,
-        fpng_put_params,
-        NULL,	/* map_cmyk_color */
-        NULL,	/* get_xfont_procs */
-        NULL,	/* get_xfont_device */
-        NULL,	/* map_rgb_alpha_color */
-        gx_page_device_get_page_device,
-        NULL,	/* get_alpha_bits */
-        NULL,	/* copy_alpha */
-        NULL,	/* get_band */
-        NULL,	/* copy_rop */
-        NULL,	/* fill_path */
-        NULL,	/* stroke_path */
-        NULL,	/* fill_mask */
-        NULL,	/* fill_trapezoid */
-        NULL,	/* fill_parallelogram */
-        NULL,	/* fill_triangle */
-        NULL,	/* draw_thin_line */
-        NULL,	/* begin_image */
-        NULL,	/* image_data */
-        NULL,	/* end_image */
-        NULL,	/* strip_tile_rectangle */
-        NULL,	/* strip_copy_rop, */
-        NULL,	/* get_clipping_box */
-        NULL,	/* begin_typed_image */
-        NULL,	/* get_bits_rectangle */
-        NULL,	/* map_color_rgb_alpha */
-        NULL,	/* create_compositor */
-        NULL,	/* get_hardware_params */
-        NULL,	/* text_begin */
-        NULL,	/* initialize */
-        NULL,	/* begin_transparency_group */
-        NULL,	/* end_transparency_group */
-        NULL,	/* begin_transparency_mask */
-        NULL,	/* end_transparency_mask */
-        NULL,  /* discard_transparency_layer */
-        NULL,  /* get_color_mapping_procs */
-        NULL,  /* get_color_comp_index */
-        NULL,  /* encode_color */
-        NULL,  /* decode_color */
-        NULL,  /* pattern_manage */
-        NULL,  /* fill_rectangle_hl_color */
-        NULL,  /* include_color_space */
-        NULL,  /* fill_linear_color_scanline */
-        NULL,  /* fill_linear_color_trapezoid */
-        NULL,  /* fill_linear_color_triangle */
-        NULL,  /* update_spot_equivalent_colors */
-        NULL,  /* ret_devn_params */
-        NULL,  /* fillpage */
-        NULL,  /* push_transparency_state */
-        NULL,  /* pop_transparency_state */
-        NULL,  /* put_image */
-        fpng_dev_spec_op,  /* dev_spec_op */
-        NULL,  /* copy plane */
-        gx_default_get_profile, /* get_profile */
-        gx_default_set_graphics_type_tag /* set_graphics_type_tag */
-};
+    int code = gdev_prn_initialize_rgb_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, fpng_get_params);
+    set_dev_proc(dev, put_params, fpng_put_params);
+    set_dev_proc(dev, dev_spec_op, fpng_dev_spec_op);
+
+    return 0;
+}
+
+static const gx_device_procs fpng_procs =
+    devprocs_initialize(fpng_initialize);
+
 const gx_device_fpng gs_fpng_device =
 {prn_device_body(gx_device_fpng, fpng_procs, "fpng",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
diff --git a/devices/gdevhl7x.c b/devices/gdevhl7x.c
index c2f1eaa1c..bebfc78d3 100644
--- a/devices/gdevhl7x.c
+++ b/devices/gdevhl7x.c
@@ -248,9 +248,22 @@ static dev_proc_close_device(hl7x0_close);
 static dev_proc_print_page(hl720_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+hl7x0_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hl7x0_open);
+    set_dev_proc(dev, close_device, hl7x0_close);
+
+    return 0;
+}
+
 static const gx_device_procs prn_hl_procs =
-  prn_params_procs(hl7x0_open, gdev_prn_bg_output_page, hl7x0_close,
-                   gdev_prn_get_params, gdev_prn_put_params);
+    devprocs_initialize(hl7x0_initialize);
 
 const gx_device_printer far_data gs_hl7x0_device =
   prn_device(prn_hl_procs, "hl7x0",
diff --git a/devices/gdevicov.c b/devices/gdevicov.c
index 91e98d6ea..765e0fc08 100644
--- a/devices/gdevicov.c
+++ b/devices/gdevicov.c
@@ -167,29 +167,7 @@ static int cov_write_page_ink(gx_device_printer *pdev, gp_file *file)
 }
 
 static const gx_device_procs cov_procs =
-{
-    gdev_prn_open,
-    NULL,			/* get_initial_matrix */
-    NULL,			/* sync_output */
-    /* Since the print_page doesn't alter the device, this device can print in the background */
-    gdev_prn_bg_output_page,
-    gdev_prn_close,
-    NULL,			/* map_rgb_color */
-    cmyk_8bit_map_color_rgb,
-    NULL,			/* fill_rectangle */
-    NULL,			/* tile_rectangle */
-    NULL,			/* copy_mono */
-    NULL,			/* copy_color */
-    NULL,			/* draw_line */
-    NULL,			/* get_bits */
-    gdev_prn_get_params,
-    gdev_prn_put_params,
-    cmyk_8bit_map_cmyk_color,
-    NULL,			/* get_xfont_procs */
-    NULL,			/* get_xfont_device */
-    NULL,			/* map_rgb_alpha_color */
-    gx_page_device_get_page_device
-};
+    devprocs_initialize(gdev_prn_initialize_cmyk8_bg);
 
 const gx_device_printer gs_inkcov_device = prn_device(
     cov_procs, "inkcov",
@@ -204,4 +182,3 @@ const gx_device_printer gs_ink_cov_device = prn_device(
     75, 75,	/* dpi */
     0, 0, 0, 0,	/* margins */
     32, cov_write_page_ink);
-
diff --git a/devices/gdevifno.c b/devices/gdevifno.c
index 22d5837fd..7c1496e07 100644
--- a/devices/gdevifno.c
+++ b/devices/gdevifno.c
@@ -81,10 +81,24 @@ gs_private_st_suffix_add1_final(st_inferno_device, inferno_device,
         "inferno_device", inferno_device_enum_ptrs, inferno_device_reloc_ptrs,
                           gx_device_finalize, st_device_printer, p9color);
 
+static int
+inferno_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, inferno_open);
+    set_dev_proc(dev, close_device, inferno_close);
+    set_dev_proc(dev, map_rgb_color, inferno_rgb2cmap);
+    set_dev_proc(dev, map_color_rgb, inferno_cmap2rgb);
+
+    return 0;
+}
+
 static const gx_device_procs inferno_procs =
-        prn_color_params_procs(inferno_open, gdev_prn_output_page, inferno_close,
-                inferno_rgb2cmap, inferno_cmap2rgb,
-                gdev_prn_get_params, gdev_prn_put_params);
+        devprocs_initialize(inferno_initialize);
 
 inferno_device far_data gs_inferno_device =
 { prn_device_stype_body(inferno_device, inferno_procs, "inferno",
diff --git a/devices/gdevijs.c b/devices/gdevijs.c
index cdb861436..6aab72371 100644
--- a/devices/gdevijs.c
+++ b/devices/gdevijs.c
@@ -100,52 +100,8 @@ static dev_proc_fill_mask(gsijs_fill_mask);
 static dev_proc_fill_path(gsijs_fill_path);
 static dev_proc_stroke_path(gsijs_stroke_path);
 
-static const gx_device_procs gsijs_procs = {
-        gsijs_open,
-        NULL,	/* get_initial_matrix */
-        NULL,	/* sync_output */
-        gsijs_output_page,
-        gsijs_close,
-        gx_default_rgb_map_rgb_color,
-        gx_default_rgb_map_color_rgb,
-        NULL,	/* fill_rectangle */
-        NULL,	/* tile_rectangle */
-        NULL,	/* copy_mono */
-        NULL,	/* copy_color */
-        NULL,	/* draw_line */
-        NULL,	/* get_bits */
-        gsijs_get_params,
-        gsijs_put_params,
-        NULL,	/* map_cmyk_color */
-        NULL,	/* get_xfont_procs */
-        NULL,	/* get_xfont_device */
-        NULL,	/* map_rgb_alpha_color */
-        gx_page_device_get_page_device,
-        NULL,	/* get_alpha_bits */
-        NULL,	/* copy_alpha */
-        NULL,	/* get_band */
-        NULL,	/* copy_rop */
-        NULL,	/* fill_path */
-        NULL,	/* stroke_path */
-        NULL,	/* fill_mask */
-        NULL,	/* fill_trapezoid */
-        NULL,	/* fill_parallelogram */
-        NULL,	/* fill_triangle */
-        NULL,	/* draw_thin_line */
-        NULL,	/* begin_image */
-        NULL,	/* image_data */
-        NULL,	/* end_image */
-        NULL,	/* strip_tile_rectangle */
-        NULL,	/* strip_copy_rop, */
-        NULL,	/* get_clipping_box */
-        NULL,	/* begin_typed_image */
-        NULL,	/* get_bits_rectangle */
-        NULL,	/* map_color_rgb_alpha */
-        NULL,	/* create_compositor */
-        NULL,	/* get_hardware_params */
-        NULL,	/* text_begin */
-        gsijs_initialize
-};
+static const gx_device_procs gsijs_procs =
+    devprocs_initialize(gsijs_initialize);
 
 typedef struct gx_device_ijs_s gx_device_ijs;
 
@@ -938,6 +894,14 @@ gsijs_initialize(gx_device *dev)
     if(code < 0)
         return code;
 
+    set_dev_proc(dev, open_device, gsijs_open);
+    set_dev_proc(dev, output_page, gsijs_output_page);
+    set_dev_proc(dev, close_device, gsijs_close);
+    set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gx_default_rgb_map_color_rgb);
+    set_dev_proc(dev, get_params, gsijs_get_params);
+    set_dev_proc(dev, put_params, gsijs_put_params);
+
     if (!ijsdev->ColorSpace) {
         ijsdev->ColorSpace = gs_malloc(ijsdev->memory, sizeof(rgb), 1,
                                        "gsijs_initialize");
diff --git a/devices/gdevimgn.c b/devices/gdevimgn.c
index 1abde2944..16a0b19d6 100644
--- a/devices/gdevimgn.c
+++ b/devices/gdevimgn.c
@@ -228,8 +228,22 @@ static dev_proc_open_device(imagen_prn_open);
 static dev_proc_close_device(imagen_prn_close);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+imagen_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, imagen_prn_open);
+    set_dev_proc(dev, close_device, imagen_prn_close);
+
+    return 0;
+}
+
 gx_device_procs imagen_procs =
-        prn_procs(imagen_prn_open, gdev_prn_bg_output_page, imagen_prn_close);
+    devprocs_initialize(imagen_initialize);
 
 #define ppdev ((gx_device_printer *)pdev)
 
diff --git a/devices/gdevjpeg.c b/devices/gdevjpeg.c
index eee3abd0d..5c50163f5 100644
--- a/devices/gdevjpeg.c
+++ b/devices/gdevjpeg.c
@@ -63,30 +63,23 @@ static dev_proc_map_cmyk_color(jpegcmyk_map_cmyk_color);
 
 /* 24-bit color */
 
-static const gx_device_procs jpeg_procs =
+static int
+jpeg_initialize(gx_device *dev)
 {
-    gdev_prn_open,
-    jpeg_get_initial_matrix,	/* get_initial_matrix */
-    NULL,			/* sync_output */
-/* Since the print_page doesn't alter the device, this device can print in the background */
-    gdev_prn_bg_output_page,
-    gdev_prn_close,
-    gx_default_rgb_map_rgb_color,/* map_rgb_color */
-    gx_default_rgb_map_color_rgb,
-    NULL,			/* fill_rectangle */
-    NULL,			/* tile_rectangle */
-    NULL,			/* copy_mono */
-    NULL,			/* copy_color */
-    NULL,			/* draw_line */
-    NULL,			/* get_bits */
-    jpeg_get_params,
-    jpeg_put_params,
-    NULL,
-    NULL,			/* get_xfont_procs */
-    NULL,			/* get_xfont_device */
-    NULL,			/* map_rgb_alpha_color */
-    gx_page_device_get_page_device
-};
+    int code = gdev_prn_initialize_rgb_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_initial_matrix, jpeg_get_initial_matrix);
+    set_dev_proc(dev, get_params, jpeg_get_params);
+    set_dev_proc(dev, put_params, jpeg_put_params);
+
+    return 0;
+}
+
+static const gx_device_procs jpeg_procs =
+    devprocs_initialize(jpeg_initialize);
 
 const gx_device_jpeg gs_jpeg_device =
 {prn_device_std_body(gx_device_jpeg, jpeg_procs, "jpeg",
@@ -101,30 +94,23 @@ const gx_device_jpeg gs_jpeg_device =
 
 /* 8-bit gray */
 
-static const gx_device_procs jpeggray_procs =
+static int
+jpeggray_initialize(gx_device *dev)
 {
-    gdev_prn_open,
-    jpeg_get_initial_matrix,	/* get_initial_matrix */
-    NULL,			/* sync_output */
-/* Since the print_page doesn't alter the device, this device can print in the background */
-    gdev_prn_bg_output_page,
-    gdev_prn_close,
-    gx_default_gray_map_rgb_color,/* map_rgb_color */
-    gx_default_gray_map_color_rgb,
-    NULL,			/* fill_rectangle */
-    NULL,			/* tile_rectangle */
-    NULL,			/* copy_mono */
-    NULL,			/* copy_color */
-    NULL,			/* draw_line */
-    NULL,			/* get_bits */
-    jpeg_get_params,
-    jpeg_put_params,
-    NULL,
-    NULL,			/* get_xfont_procs */
-    NULL,			/* get_xfont_device */
-    NULL,			/* map_rgb_alpha_color */
-    gx_page_device_get_page_device
-};
+    int code = gdev_prn_initialize_gray_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_initial_matrix, jpeg_get_initial_matrix);
+    set_dev_proc(dev, get_params, jpeg_get_params);
+    set_dev_proc(dev, put_params, jpeg_put_params);
+
+    return 0;
+}
+
+static const gx_device_procs jpeggray_procs =
+    devprocs_initialize(jpeggray_initialize);
 
 const gx_device_jpeg gs_jpeggray_device =
 {prn_device_body(gx_device_jpeg, jpeggray_procs, "jpeggray",
@@ -138,31 +124,28 @@ const gx_device_jpeg gs_jpeggray_device =
  { 0.0, 0.0 },                   /* translation 0 */
  GX_DOWNSCALER_PARAMS_DEFAULTS
 };
+
 /* 32-bit CMYK */
 
+static int
+jpegcmyk_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_initial_matrix, jpeg_get_initial_matrix);
+    set_dev_proc(dev, map_color_rgb, jpegcmyk_map_color_rgb);
+    set_dev_proc(dev, get_params, jpeg_get_params);
+    set_dev_proc(dev, put_params, jpeg_put_params);
+    set_dev_proc(dev, map_cmyk_color, jpegcmyk_map_cmyk_color);
+
+    return 0;
+}
+
 static const gx_device_procs jpegcmyk_procs =
-{	gdev_prn_open,
-        gx_default_get_initial_matrix,
-/* Since the print_page doesn't alter the device, this device can print in the background */
-        NULL,	/* sync_output */
-        gdev_prn_bg_output_page,
-        gdev_prn_close,
-        NULL,
-        jpegcmyk_map_color_rgb,
-        NULL,	/* fill_rectangle */
-        NULL,	/* tile_rectangle */
-        NULL,	/* copy_mono */
-        NULL,	/* copy_color */
-        NULL,	/* draw_line */
-        NULL,	/* get_bits */
-        jpeg_get_params,
-        jpeg_put_params,
-        jpegcmyk_map_cmyk_color,
-        NULL,	/* get_xfont_procs */
-        NULL,	/* get_xfont_device */
-        NULL,	/* map_rgb_alpha_color */
-        gx_page_device_get_page_device	/* get_page_device */
-};
+    devprocs_initialize(jpegcmyk_initialize);
 
 const gx_device_jpeg gs_jpegcmyk_device =
 {prn_device_std_body(gx_device_jpeg, jpegcmyk_procs, "jpegcmyk",
@@ -578,4 +561,3 @@ jpeg_print_page(gx_device_printer * pdev, gp_file * prn_stream)
     gs_free_object(mem, in, "jpeg_print_page(in)");
     return code;
 }
-
diff --git a/devices/gdevl31s.c b/devices/gdevl31s.c
index 9a32d434e..049d39029 100644
--- a/devices/gdevl31s.c
+++ b/devices/gdevl31s.c
@@ -79,9 +79,21 @@ static dev_proc_print_page_copies(lj3100sw_print_page_copies);
 static dev_proc_close_device(lj3100sw_close);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+lj3100sw_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, close_device, lj3100sw_close);
+
+    return 0;
+}
+
 static gx_device_procs prn_lj3100sw_procs =
-    prn_params_procs(gdev_prn_open, gdev_prn_bg_output_page, lj3100sw_close,
-             gdev_prn_get_params, gdev_prn_put_params);
+    devprocs_initialize(lj3100sw_initialize);
 
 /* workaround to emulate the missing prn_device_margins_copies macro */
 #define gx_default_print_page_copies lj3100sw_print_page_copies
diff --git a/devices/gdevlj56.c b/devices/gdevlj56.c
index ed022c0c3..dfca02c98 100644
--- a/devices/gdevlj56.c
+++ b/devices/gdevlj56.c
@@ -42,8 +42,22 @@ static dev_proc_close_device(ljet5_close);
 static dev_proc_print_page(ljet5_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+ljet5_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, ljet5_open);
+    set_dev_proc(dev, close_device, ljet5_close);
+
+    return 0;
+}
+
 static const gx_device_procs ljet5_procs =
-prn_procs(ljet5_open, gdev_prn_bg_output_page, ljet5_close);
+    devprocs_initialize(ljet5_initialize);
 
 const gx_device_printer gs_lj5mono_device =
 prn_device(ljet5_procs, "lj5mono",
@@ -53,10 +67,22 @@ prn_device(ljet5_procs, "lj5mono",
            1, ljet5_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+lj5gray_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, ljet5_open);
+    set_dev_proc(dev, close_device, ljet5_close);
+
+    return 0;
+}
+
 static const gx_device_procs lj5gray_procs =
-prn_color_procs(ljet5_open, gdev_prn_bg_output_page, ljet5_close,
-                gx_default_gray_map_rgb_color,
-                gx_default_gray_map_color_rgb);
+    devprocs_initialize(lj5gray_initialize);
 
 const gx_device_printer gs_lj5gray_device = {
     prn_device_body(gx_device_printer, lj5gray_procs, "lj5gray",
diff --git a/devices/gdevlxm.c b/devices/gdevlxm.c
index 4f9bfca17..757ed9524 100644
--- a/devices/gdevlxm.c
+++ b/devices/gdevlxm.c
@@ -40,9 +40,22 @@ static dev_proc_put_params(lxm_put_params);
 
 /* set up dispatch table.  I follow gdevdjet in using gdev_prn_output_page */
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+lxm5700m_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, lxm_get_params);
+    set_dev_proc(dev, put_params, lxm_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs lxm5700m_procs =
-    prn_params_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                     lxm_get_params, lxm_put_params);
+    devprocs_initialize(lxm5700m_initialize);
 
 /* The device descriptors */
 
diff --git a/devices/gdevmgr.c b/devices/gdevmgr.c
index 40ff63733..5ef6b2700 100644
--- a/devices/gdevmgr.c
+++ b/devices/gdevmgr.c
@@ -66,17 +66,70 @@ static dev_proc_print_page(cmgrN_print_page);
 
 /* The device procedures */
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+mgr_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, gdev_mgr_open);
+
+    return 0;
+}
+
+static int
+mgrN_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, gdev_mgr_open);
+
+    return 0;
+}
+
+static int
+cmgr4_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, gdev_mgr_open);
+    set_dev_proc(dev, map_rgb_color, pc_4bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pc_4bit_map_color_rgb);
+
+    return 0;
+}
+
+static int
+cmgr8_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, gdev_mgr_open);
+    set_dev_proc(dev, map_rgb_color, mgr_8bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, mgr_8bit_map_color_rgb);
+
+    return 0;
+}
+
 static gx_device_procs mgr_procs =
-    prn_procs(gdev_mgr_open, gdev_prn_bg_output_page, gdev_prn_close);
+    devprocs_initialize(mgr_initialize);
 static gx_device_procs mgrN_procs =
-    prn_color_procs(gdev_mgr_open, gdev_prn_bg_output_page, gdev_prn_close,
-        gx_default_gray_map_rgb_color, gx_default_gray_map_color_rgb);
+    devprocs_initialize(mgrN_initialize);
 static gx_device_procs cmgr4_procs =
-    prn_color_procs(gdev_mgr_open, gdev_prn_bg_output_page, gdev_prn_close,
-        pc_4bit_map_rgb_color, pc_4bit_map_color_rgb);
+    devprocs_initialize(cmgr4_initialize);
 static gx_device_procs cmgr8_procs =
-    prn_color_procs(gdev_mgr_open, gdev_prn_bg_output_page, gdev_prn_close,
-        mgr_8bit_map_rgb_color, mgr_8bit_map_color_rgb);
+    devprocs_initialize(cmgr8_initialize);
 
 /* The device descriptors themselves */
 gx_device_mgr far_data gs_mgrmono_device =
diff --git a/devices/gdevmiff.c b/devices/gdevmiff.c
index 7919f7a5e..255f3b1fa 100644
--- a/devices/gdevmiff.c
+++ b/devices/gdevmiff.c
@@ -28,8 +28,8 @@ static dev_proc_print_page(miff24_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static const gx_device_procs miff24_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb);
+    devprocs_initialize(gdev_prn_initialize_rgb_bg);
+
 const gx_device_printer gs_miff24_device =
 prn_device(miff24_procs, "miff24",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
diff --git a/devices/gdevn533.c b/devices/gdevn533.c
index aa4ebef3b..1fbf88cb7 100644
--- a/devices/gdevn533.c
+++ b/devices/gdevn533.c
@@ -46,8 +46,23 @@ static dev_proc_open_device(nwp533_open);
 static dev_proc_print_page(nwp533_print_page);
 static dev_proc_close_device(nwp533_close);
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+nwp533_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, nwp533_open);
+    set_dev_proc(dev, output_page, gdev_prn_bg_output_page_seekable);
+    set_dev_proc(dev, close_device, nwp533_close);
+
+    return 0;
+}
+
 static gx_device_procs nwp533_procs =
-  prn_procs(nwp533_open, gdev_prn_bg_output_page_seekable, nwp533_close);
+    devprocs_initialize(mwp533_initialize);
 
 const gx_device_printer far_data gs_nwp533_device =
   prn_device(nwp533_procs, "nwp533",
diff --git a/devices/gdevocr.c b/devices/gdevocr.c
index cd1efeb14..6557faf71 100644
--- a/devices/gdevocr.c
+++ b/devices/gdevocr.c
@@ -50,12 +50,25 @@ struct gx_device_ocr_s {
 };
 
 /* 8-bit gray bitmap -> UTF8 OCRd text */
+static int
+ocr_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, ocr_open);
+    set_dev_proc(dev, close_device, ocr_close);
+    set_dev_proc(dev, get_params, ocr_get_params);
+    set_dev_proc(dev, put_params, ocr_put_params);
+
+    return 0;
+}
 
 static const gx_device_procs ocr_procs =
-prn_color_params_procs(ocr_open, gdev_prn_bg_output_page, ocr_close,
-                       gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb,
-                       ocr_get_params, ocr_put_params);
+    devprocs_initialize(ocr_initialize);
+
 const gx_device_ocr gs_ocr_device =
 {
     prn_device_body(gx_device_ocr, ocr_procs, "ocr",
@@ -67,12 +80,25 @@ const gx_device_ocr gs_ocr_device =
 };
 
 /* 8-bit gray bitmap -> HTML OCRd text */
+static int
+hocr_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, ocr_open);
+    set_dev_proc(dev, close_device, hocr_close);
+    set_dev_proc(dev, get_params, ocr_get_params);
+    set_dev_proc(dev, put_params, ocr_put_params);
+
+    return 0;
+}
 
 static const gx_device_procs hocr_procs =
-prn_color_params_procs(ocr_open, gdev_prn_bg_output_page, hocr_close,
-                       gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb,
-                       ocr_get_params, ocr_put_params);
+    devprocs_initialize(hocr_initialize);
+
 const gx_device_ocr gs_hocr_device =
 {
     prn_device_body(gx_device_ocr, hocr_procs, "hocr",
diff --git a/devices/gdevpbm.c b/devices/gdevpbm.c
index d5e0736e4..46c92064c 100644
--- a/devices/gdevpbm.c
+++ b/devices/gdevpbm.c
@@ -140,35 +140,121 @@ static dev_proc_print_page(pnmcmyk_print_page);
 
 /* The device procedures */
 
-/* See gdevprn.h for the template for the following. */
-#define pgpm_procs(p_open, p_get_params, p_map_rgb_color, p_map_color_rgb, p_map_cmyk_color) {\
-        p_open, NULL, NULL, ppm_output_page, gdev_prn_close,\
-        p_map_rgb_color, p_map_color_rgb, NULL, NULL, NULL, NULL, NULL, NULL,\
-        p_get_params, ppm_put_params,\
-        p_map_cmyk_color, NULL, NULL, NULL, gx_page_device_get_page_device\
+static int
+pbm_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, put_params, ppm_put_params);
+    set_dev_proc(dev, output_page, ppm_output_page);
+
+    return 0;
+}
+
+static int
+ppm_initialize(gx_device *dev)
+{
+    int code = pbm_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, ppm_get_params);
+    set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, ppm_map_color_rgb);
+    set_dev_proc(dev, open_device, ppm_open);
+
+    return 0;
+}
+
+static int
+pgm_initialize(gx_device *dev)
+{
+    int code = pbm_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, pgm_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pgm_map_color_rgb);
+    set_dev_proc(dev, open_device, ppm_open);
+
+    return 0;
+}
+
+static int
+pnm_initialize(gx_device *dev)
+{
+    int code = ppm_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, ppm_map_rgb_color);
+
+    return 0;
+}
+
+static int
+pkm_initialize(gx_device *dev)
+{
+    int code = ppm_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, NULL);
+    set_dev_proc(dev, map_color_rgb, cmyk_1bit_map_color_rgb);
+    set_dev_proc(dev, map_cmyk_color, cmyk_1bit_map_cmyk_color);
+
+    return 0;
+}
+
+static int
+pam_initialize(gx_device *dev)
+{
+    int code = ppm_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, NULL);
+    set_dev_proc(dev, map_color_rgb, cmyk_8bit_map_color_rgb);
+    set_dev_proc(dev, map_cmyk_color, cmyk_8bit_map_cmyk_color);
+
+    return 0;
+}
+
+static int
+pnmcmyk_initialize(gx_device *dev)
+{
+    int code = pam_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pnmcmyk_open);
+
+    return 0;
 }
 
 static const gx_device_procs pbm_procs =
-    pgpm_procs(gdev_prn_open, gdev_prn_get_params,
-               gdev_prn_map_rgb_color, gdev_prn_map_color_rgb, NULL);
+    devprocs_initialize(pbm_initialize);
 static const gx_device_procs pgm_procs =
-    pgpm_procs(ppm_open, gdev_prn_get_params,
-               pgm_map_rgb_color, pgm_map_color_rgb, NULL);
+    devprocs_initialize(pgm_initialize);
 static const gx_device_procs ppm_procs =
-    pgpm_procs(ppm_open, ppm_get_params,
-               gx_default_rgb_map_rgb_color, ppm_map_color_rgb, NULL);
+    devprocs_initialize(ppm_initialize);
 static const gx_device_procs pnm_procs =
-    pgpm_procs(ppm_open, ppm_get_params,
-               ppm_map_rgb_color, ppm_map_color_rgb, NULL);
+    devprocs_initialize(pnm_initialize);
 static const gx_device_procs pkm_procs =
-    pgpm_procs(ppm_open, ppm_get_params,
-               NULL, cmyk_1bit_map_color_rgb, cmyk_1bit_map_cmyk_color);
+    devprocs_initialize(pkm_initialize);
 static const gx_device_procs pam_procs =
-    pgpm_procs(ppm_open, ppm_get_params,
-               NULL, cmyk_8bit_map_color_rgb, cmyk_8bit_map_cmyk_color);
+    devprocs_initialize(pam_initialize);
 static const gx_device_procs pnmcmyk_procs =
-    pgpm_procs(pnmcmyk_open, ppm_get_params,
-               NULL, cmyk_8bit_map_color_rgb, cmyk_8bit_map_cmyk_color);
+    devprocs_initialize(pnmcmyk_initialize);
 
 /* The device descriptors themselves */
 const gx_device_pbm gs_pbm_device =
diff --git a/devices/gdevpcx.c b/devices/gdevpcx.c
index 3486f9800..53c71f7cf 100644
--- a/devices/gdevpcx.c
+++ b/devices/gdevpcx.c
@@ -37,8 +37,8 @@ static dev_proc_print_page(pcxmono_print_page);
 /* Use the default RGB->color map, so we get black=0, white=1. */
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static const gx_device_procs pcxmono_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                gx_default_map_rgb_color, gx_default_map_color_rgb);
+    devprocs_initialize(gdev_prn_initialize_mono_bg);
+
 const gx_device_printer gs_pcxmono_device =
 prn_device(pcxmono_procs, "pcxmono",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -52,8 +52,8 @@ static dev_proc_print_page(pcx256_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static const gx_device_procs pcxgray_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-              gx_default_gray_map_rgb_color, gx_default_gray_map_color_rgb);
+    devprocs_initialize(gdev_prn_initialize_gray_bg);
+
 const gx_device_printer gs_pcxgray_device =
 {prn_device_body(gx_device_printer, pcxgray_procs, "pcxgray",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -67,9 +67,23 @@ const gx_device_printer gs_pcxgray_device =
 static dev_proc_print_page(pcx16_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+pcx16_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return 0;
+
+    set_dev_proc(dev, map_rgb_color, pc_4bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pc_4bit_map_color_rgb);
+
+    return 0;
+}
+
 static const gx_device_procs pcx16_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                pc_4bit_map_rgb_color, pc_4bit_map_color_rgb);
+    devprocs_initialize(pcx16_initialize);
+
 const gx_device_printer gs_pcx16_device =
 {prn_device_body(gx_device_printer, pcx16_procs, "pcx16",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -82,9 +96,23 @@ const gx_device_printer gs_pcx16_device =
 /* (Uses a fixed palette of 3,3,2 bits.) */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+pcx256_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return 0;
+
+    set_dev_proc(dev, map_rgb_color, pc_8bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pc_8bit_map_color_rgb);
+
+    return 0;
+}
+
 static const gx_device_procs pcx256_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                pc_8bit_map_rgb_color, pc_8bit_map_color_rgb);
+    devprocs_initialize(pcx256_initialize);
+
 const gx_device_printer gs_pcx256_device =
 {prn_device_body(gx_device_printer, pcx256_procs, "pcx256",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -99,8 +127,8 @@ static dev_proc_print_page(pcx24b_print_page);
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static const gx_device_procs pcx24b_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb);
+    devprocs_initialize(gdev_prn_initialize_rgb_bg);
+
 const gx_device_printer gs_pcx24b_device =
 prn_device(pcx24b_procs, "pcx24b",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -113,29 +141,8 @@ prn_device(pcx24b_procs, "pcx24b",
 static dev_proc_print_page(pcxcmyk_print_page);
 
 static const gx_device_procs pcxcmyk_procs =
-{
-    gdev_prn_open,
-    NULL,			/* get_initial_matrix */
-    NULL,			/* sync_output */
-/* Since the print_page doesn't alter the device, this device can print in the background */
-    gdev_prn_bg_output_page,
-    gdev_prn_close,
-    NULL,			/* map_rgb_color */
-    cmyk_1bit_map_color_rgb,
-    NULL,			/* fill_rectangle */
-    NULL,			/* tile_rectangle */
-    NULL,			/* copy_mono */
-    NULL,			/* copy_color */
-    NULL,			/* draw_line */
-    NULL,			/* get_bits */
-    gdev_prn_get_params,
-    gdev_prn_put_params,
-    cmyk_1bit_map_cmyk_color,
-    NULL,			/* get_xfont_procs */
-    NULL,			/* get_xfont_device */
-    NULL,			/* map_rgb_alpha_color */
-    gx_page_device_get_page_device
-};
+    devprocs_initialize(gdev_prn_initialize_cmyk1_bg);
+
 const gx_device_printer gs_pcxcmyk_device =
 {prn_device_body(gx_device_printer, pcxcmyk_procs, "pcxcmyk",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
diff --git a/devices/gdevpdfimg.c b/devices/gdevpdfimg.c
index 7d04755b5..420cad2b7 100644
--- a/devices/gdevpdfimg.c
+++ b/devices/gdevpdfimg.c
@@ -57,15 +57,25 @@ int PCLm_close(gx_device * pdev);
 
 
 /* ------ The pdfimage8 device ------ */
+static int
+pdfimage8_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pdf_image_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, pdf_image_close);
+    set_dev_proc(dev, get_params, pdf_image_get_params_downscale);
+    set_dev_proc(dev, put_params, pdf_image_put_params_downscale);
+
+    return 0;
+}
 
 static const gx_device_procs pdfimage8_procs =
-prn_color_params_procs(pdf_image_open,
-                       gdev_prn_output_page_seekable,
-                       pdf_image_close,
-                       gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb,
-                       pdf_image_get_params_downscale,
-                       pdf_image_put_params_downscale);
+    devprocs_initialize(pdfimage8_initialize);
 
 const gx_device_pdf_image gs_pdfimage8_device = {
     prn_device_body(gx_device_pdf_image,
@@ -86,15 +96,25 @@ const gx_device_pdf_image gs_pdfimage8_device = {
 };
 
 /* ------ The pdfimage24 device ------ */
+static int
+pdfimage24_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_rgb(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pdf_image_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, pdf_image_close);
+    set_dev_proc(dev, get_params, pdf_image_get_params_downscale);
+    set_dev_proc(dev, put_params, pdf_image_put_params_downscale);
+
+    return 0;
+}
 
 static const gx_device_procs pdfimage24_procs =
-prn_color_params_procs(pdf_image_open,
-                       gdev_prn_output_page_seekable,
-                       pdf_image_close,
-                       gx_default_rgb_map_rgb_color,
-                       gx_default_rgb_map_color_rgb,
-                       pdf_image_get_params_downscale,
-                       pdf_image_put_params_downscale);
+    devprocs_initialize(pdfimage24_initialize);
 
 const gx_device_pdf_image gs_pdfimage24_device = {
     prn_device_body(gx_device_pdf_image,
@@ -115,13 +135,25 @@ const gx_device_pdf_image gs_pdfimage24_device = {
 };
 
 /* ------ The pdfimage32 device ------ */
+static int
+pdfimage32_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk8(dev);
 
-static const gx_device_procs pdfimage32_procs = {
-    pdf_image_open, NULL, NULL, gdev_prn_output_page_seekable, pdf_image_close,
-    NULL, cmyk_8bit_map_color_cmyk, NULL, NULL, NULL, NULL, NULL, NULL,
-    pdf_image_get_params_downscale_cmyk, pdf_image_put_params_downscale_cmyk,
-    cmyk_8bit_map_cmyk_color, NULL, NULL, NULL, gx_page_device_get_page_device
-};
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pdf_image_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, pdf_image_close);
+    set_dev_proc(dev, get_params, pdf_image_get_params_downscale_cmyk);
+    set_dev_proc(dev, put_params, pdf_image_put_params_downscale_cmyk);
+
+    return 0;
+}
+
+static const gx_device_procs pdfimage32_procs =
+    devprocs_initialize(pdfimage32_initialize);
 
 const gx_device_pdf_image gs_pdfimage32_device = {
     prn_device_body(gx_device_pdf_image,
@@ -1099,17 +1131,27 @@ pdf_image_put_params_downscale_cmyk_ets(gx_device * dev, gs_param_list * plist)
 }
 
 /* ------ The PCLm device ------ */
+static int
+PCLm_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_rgb(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, PCLm_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, PCLm_close);
+    set_dev_proc(dev, get_params, pdf_image_get_params_downscale);
+    set_dev_proc(dev, put_params, pdf_image_put_params_downscale);
+
+    return 0;
+}
 
 static dev_proc_print_page(PCLm_print_page);
 
 static const gx_device_procs PCLm_procs =
-prn_color_params_procs(PCLm_open,
-                       gdev_prn_output_page_seekable,
-                       PCLm_close,
-                       gx_default_rgb_map_rgb_color,
-                       gx_default_rgb_map_color_rgb,
-                       pdf_image_get_params_downscale,
-                       pdf_image_put_params_downscale);
+    devprocs_initialize(PCLm_initialize);
 
 const gx_device_pdf_image gs_PCLm_device = {
     prn_device_body(gx_device_pdf_image,
diff --git a/devices/gdevpdfocr.c b/devices/gdevpdfocr.c
index afc73ff2a..aea5010f2 100644
--- a/devices/gdevpdfocr.c
+++ b/devices/gdevpdfocr.c
@@ -142,15 +142,25 @@ pdfocr_get_params_downscale(gx_device * dev, gs_param_list * plist)
 }
 
 /* ------ The pdfocr8 device ------ */
+static int
+pdfocr8_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pdf_ocr_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, pdf_ocr_close);
+    set_dev_proc(dev, get_params, pdfocr_get_params_downscale);
+    set_dev_proc(dev, put_params, pdfocr_put_params_downscale);
+
+    return 0;
+}
 
 static const gx_device_procs pdfocr8_procs =
-prn_color_params_procs(pdf_ocr_open,
-                       gdev_prn_output_page_seekable,
-                       pdf_ocr_close,
-                       gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb,
-                       pdfocr_get_params_downscale,
-                       pdfocr_put_params_downscale);
+    devprocs_initialize(pdfocr8_initialize);
 
 const gx_device_pdf_image gs_pdfocr8_device = {
     prn_device_body(gx_device_pdf_image,
@@ -171,15 +181,25 @@ const gx_device_pdf_image gs_pdfocr8_device = {
 };
 
 /* ------ The pdfocr24 device ------ */
+static int
+pdfocr24_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pdf_ocr_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, pdf_ocr_close);
+    set_dev_proc(dev, get_params, pdfocr_get_params_downscale);
+    set_dev_proc(dev, put_params, pdfocr_put_params_downscale);
+
+    return 0;
+}
 
 static const gx_device_procs pdfocr24_procs =
-prn_color_params_procs(pdf_ocr_open,
-                       gdev_prn_output_page_seekable,
-                       pdf_ocr_close,
-                       gx_default_rgb_map_rgb_color,
-                       gx_default_rgb_map_color_rgb,
-                       pdfocr_get_params_downscale,
-                       pdfocr_put_params_downscale);
+    devprocs_initialize(pdfocr24_initialize);
 
 const gx_device_pdf_image gs_pdfocr24_device = {
     prn_device_body(gx_device_pdf_image,
@@ -200,13 +220,25 @@ const gx_device_pdf_image gs_pdfocr24_device = {
 };
 
 /* ------ The pdfocr32 device ------ */
+static int
+pdfocr32_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk8(dev);
 
-static const gx_device_procs pdfocr32_procs = {
-    pdf_ocr_open, NULL, NULL, gdev_prn_output_page_seekable, pdf_ocr_close,
-    NULL, cmyk_8bit_map_color_cmyk, NULL, NULL, NULL, NULL, NULL, NULL,
-    pdfocr_get_params_downscale_cmyk, pdfocr_put_params_downscale_cmyk,
-    cmyk_8bit_map_cmyk_color, NULL, NULL, NULL, gx_page_device_get_page_device
-};
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pdf_ocr_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, pdf_ocr_close);
+    set_dev_proc(dev, get_params, pdfocr_get_params_downscale_cmyk);
+    set_dev_proc(dev, put_params, pdfocr_put_params_downscale_cmyk);
+
+    return 0;
+}
+
+static const gx_device_procs pdfocr32_procs =
+    devprocs_initialize(pdfocr32_initialize);
 
 const gx_device_pdf_image gs_pdfocr32_device = {
     prn_device_body(gx_device_pdf_image,
diff --git a/devices/gdevpe.c b/devices/gdevpe.c
index b4d462f38..5a47397f0 100644
--- a/devices/gdevpe.c
+++ b/devices/gdevpe.c
@@ -50,22 +50,19 @@ dev_proc_close_device(pe_close);
 dev_proc_fill_rectangle(pe_fill_rectangle);
 dev_proc_copy_mono(pe_copy_mono);
 
-static gx_device_procs pe_procs =
-{	pe_open,
-        NULL,			/* get_initial_matrix */
-        NULL,			/* sync_output */
-        NULL,			/* output_page */
-        pe_close,
-        NULL,			/* map_rgb_color */
-        NULL,			/* map_color_rgb */
-        pe_fill_rectangle,
-        NULL,			/* tile_rectangle */
-        pe_copy_mono,
-        NULL			/* copy_color */
-};
+static int
+pe_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, pe_open);
+    set_dev_proc(dev, close_device, pe_close);
+    set_dev_proc(dev, fill_rectangle, pe_fill_rectangle);
+    set_dev_proc(dev, copy_mono, pe_copy_mono);
+
+    return 0;
+}
 
 gx_device_pe far_data gs_pe_device =
-{	std_device_std_body(gx_device_pe, &pe_procs, "pe",
+{	std_device_std_body(gx_device_pe, pe_initialize, "pe",
           XSIZE, YSIZE, XPPI, YPPI),
          { 0 },		/* std_procs */
         DEFAULT_ADDRESS, DEFAULT_REGISTERS
diff --git a/devices/gdevperm.c b/devices/gdevperm.c
index e8e65d1b3..98c4a191a 100644
--- a/devices/gdevperm.c
+++ b/devices/gdevperm.c
@@ -57,66 +57,26 @@ struct gx_device_perm_s {
 };
 typedef struct gx_device_perm_s gx_device_perm_t;
 
-static const gx_device_procs perm_procs = {
-    gdev_prn_open,
-    NULL,
-/* Since the print_page doesn't alter the device, this device can print in the background */
-    NULL,
-    gdev_prn_bg_output_page,
-    gdev_prn_close,
-    NULL,
-    NULL,
-    NULL,				/* fill_rectangle */
-    NULL,				/* tile_rectangle */
-    NULL,				/* copy_mono */
-    NULL,				/* copy_color */
-    NULL,				/* draw_line */
-    NULL,				/* get_bits */
-    perm_get_params,		        /* get_params */
-    perm_put_params,		        /* put_params */
-    NULL,				/* map_cmyk_color - not used */
-    NULL,				/* get_xfont_procs */
-    NULL,				/* get_xfont_device */
-    NULL,				/* map_rgb_alpha_color */
-    gx_page_device_get_page_device,	/* get_page_device */
-    NULL,				/* get_alpha_bits */
-    NULL,				/* copy_alpha */
-    NULL,				/* get_band */
-    NULL,				/* copy_rop */
-    NULL,				/* fill_path */
-    NULL,				/* stroke_path */
-    NULL,				/* fill_mask */
-    NULL,				/* fill_trapezoid */
-    NULL,				/* fill_parallelogram */
-    NULL,				/* fill_triangle */
-    NULL,				/* draw_thin_line */
-    NULL,				/* begin_image */
-    NULL,				/* image_data */
-    NULL,				/* end_image */
-    NULL,				/* strip_tile_rectangle */
-    NULL,				/* strip_copy_rop */
-    NULL,				/* get_clipping_box */
-    NULL,				/* begin_typed_image */
-    NULL,				/* get_bits_rectangle */
-    NULL,				/* map_color_rgb_alpha */
-    NULL,				/* create_compositor */
-    NULL,				/* get_hardware_params */
-    NULL,				/* text_begin */
-    NULL,				/* initialize */
-    NULL,				/* begin_transparency_group */
-    NULL,				/* end_transparency_group */
-    NULL,				/* begin_transparency_mask */
-    NULL,				/* end_transparency_mask */
-    NULL,				/* discard_transparency_layer */
-    perm_get_color_mapping_procs,	/* get_color_mapping_procs */
-    perm_get_color_comp_index,
-    perm_encode_color,		/* encode_color */
-    perm_decode_color		/* decode_color */
+static int
+perm_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
 
-};
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, perm_get_params);
+    set_dev_proc(dev, put_params, perm_put_params);
+    set_dev_proc(dev, get_color_mapping_procs, perm_get_color_mapping_procs);
+    set_dev_proc(dev, get_color_comp_index, perm_get_color_comp_index);
+    set_dev_proc(dev, encode_color, perm_encode_color);
+    set_dev_proc(dev, decode_color, perm_decode_color);
+
+    return 0;
+}
 
 const gx_device_perm_t gs_perm_device = {
-    prn_device_body_extended(gx_device_perm_t, perm_procs, "permute",
+    prn_device_body_extended(gx_device_perm_t, perm_initialize, "permute",
         DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, 72, 72,
         0, 0, 0, 0,
         GX_DEVICE_COLOR_MAX_COMPONENTS, 4,
diff --git a/devices/gdevphex.c b/devices/gdevphex.c
index 7afc6ba3b..25efd75db 100644
--- a/devices/gdevphex.c
+++ b/devices/gdevphex.c
@@ -1007,19 +1007,27 @@ static	const HFUNCS	htable[ MAXHTONE ] = {
 *	The definition is based on GS macros, the only real stuff that we
 *	define here are the photoex_ functions.
 */
-static	const gx_device_procs photoex_device_procs = prn_color_params_procs_enc_dec(
-
-        photoex_open,					/* Opens the device						*/
-/* Since the print_page doesn't alter the device, this device can print in the background */
-        gdev_prn_bg_output_page,
-        gdev_prn_close,
-        photoex_map_rgb_color,			/* Maps an RGB pixel to device colour	*/
-        photoex_map_color_rgb,			/* Maps device colour back to RGB		*/
-        photoex_get_params,				/* Gets device parameters				*/
-        photoex_put_params,				/* Puts device parameters				*/
-        photoex_encode_color,
-        photoex_decode_color
-);
+static int
+photoex_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, photoex_open);
+    set_dev_proc(dev, map_rgb_color, photoex_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, photoex_map_color_rgb);
+    set_dev_proc(dev, get_params, photoex_get_params);
+    set_dev_proc(dev, put_params, photoex_put_params);
+    set_dev_proc(dev, encode_color, photoex_encode_color);
+    set_dev_proc(dev, decode_color, photoex_decode_color);
+
+    return 0;
+}
+
+static	const gx_device_procs photoex_device_procs =
+    devprocs_initialize(photoex_initialize);
 
 /*
 *	Device descriptor structure - this is what GhostScript looks
diff --git a/devices/gdevpjet.c b/devices/gdevpjet.c
index 8df438f5d..6fa7e2a27 100644
--- a/devices/gdevpjet.c
+++ b/devices/gdevpjet.c
@@ -30,9 +30,23 @@ static dev_proc_print_page(paintjet_print_page);
 static dev_proc_print_page(pjetxl_print_page);
 static int pj_common_print_page(gx_device_printer *, gp_file *, int, const char *);
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+paintjet_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, gdev_pcl_3bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_pcl_3bit_map_color_rgb);
+
+    return 0;
+}
+
 static gx_device_procs paintjet_procs =
-  prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-    gdev_pcl_3bit_map_rgb_color, gdev_pcl_3bit_map_color_rgb);
+  devprocs_initialize(paintjet_initialize);
+
 const gx_device_printer far_data gs_lj250_device =
   prn_device(paintjet_procs, "lj250",
         85,				/* width_10ths, 8.5" */
@@ -49,8 +63,8 @@ const gx_device_printer far_data gs_paintjet_device =
         3, paintjet_print_page);
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static gx_device_procs pjetxl_procs =
-  prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-    gdev_pcl_3bit_map_rgb_color, gdev_pcl_3bit_map_color_rgb);
+  devprocs_initialize(paintjet_initialize);
+
 const gx_device_printer far_data gs_pjetxl_device =
   prn_device(pjetxl_procs, "pjetxl",
         85,				/* width_10ths, 8.5" */
diff --git a/devices/gdevplan.c b/devices/gdevplan.c
index 0f1d07de3..9e100610c 100644
--- a/devices/gdevplan.c
+++ b/devices/gdevplan.c
@@ -77,89 +77,98 @@ static int planr_print_page(gx_device_printer * pdev, gp_file * pstream);
 
 /* The device procedures */
 
-/* See gdevprn.h for the template for the following. */
-#define pgpm_procs(p_color_rgb, encode_color, decode_color) {\
-        plan_open,\
-        NULL, /* get_initial_matrix */ \
-        NULL, /* sync output */ \
-        /* Since the print_page doesn't alter the device, this device can print in the background */\
-        gdev_prn_bg_output_page, \
-        plan_close,\
-        NULL, /* map_rgb_color */ \
-        p_color_rgb, /* map_color_rgb */ \
-        NULL, /* fill_rectangle */ \
-        NULL, /* tile_rectangle */ \
-        NULL, /* copy_mono */ \
-        NULL, /* copy_color */ \
-        NULL, /* draw_line */ \
-        NULL, /* get_bits */ \
-        gdev_prn_get_params, \
-        gdev_prn_put_params,\
-        NULL, /* map_cmyk_color */ \
-        NULL, /* get_xfont_procs */ \
-        NULL, /* get_xfont_device */ \
-        NULL, /* map_rgb_alpha_color */ \
-        gx_page_device_get_page_device, \
-        NULL,   /* get_alpha_bits */\
-        NULL,   /* copy_alpha */\
-        NULL,   /* get_band */\
-        NULL,   /* copy_rop */\
-        NULL,   /* fill_path */\
-        NULL,   /* stroke_path */\
-        NULL,   /* fill_mask */\
-        NULL,   /* fill_trapezoid */\
-        NULL,   /* fill_parallelogram */\
-        NULL,   /* fill_triangle */\
-        NULL,   /* draw_thin_line */\
-        NULL,   /* begin_image */\
-        NULL,   /* image_data */\
-        NULL,   /* end_image */\
-        NULL,   /* strip_tile_rectangle */\
-        NULL,   /* strip_copy_rop */\
-        NULL,   /* get_clipping_box */\
-        NULL,   /* begin_typed_image */\
-        NULL,   /* get_bits_rectangle */\
-        NULL,   /* map_color_rgb_alpha */\
-        NULL,   /* create_compositor */\
-        NULL,   /* get_hardware_params */\
-        NULL,   /* text_begin */\
-        NULL,   /* initialize */\
-        NULL,   /* begin_transparency_group */\
-        NULL,   /* end_transparency_group */\
-        NULL,   /* begin_transparency_mask */\
-        NULL,   /* end_transparency_mask */\
-        NULL,   /* discard_transparency_layer */\
-        NULL,   /* get_color_mapping_procs */\
-        NULL,   /* get_color_comp_index */\
-        encode_color, /* encode_color */\
-        decode_color, /* decode_color */\
-        NULL,   /* pattern_manage */\
-        NULL,   /* fill_rectangle_hl_color */\
-        NULL,   /* include_color_space */\
-        NULL,   /* fill_linear_color_scanline */\
-        NULL,   /* fill_linear_color_trapezoid */\
-        NULL,   /* fill_linear_color_triangle */\
-        NULL,	/* update spot */\
-        NULL,   /* DevN params */\
-        NULL,   /* fill page */\
-        NULL,   /* push_transparency_state */\
-        NULL,   /* pop_transparency_state */\
-        NULL,   /* put_image */\
-        NULL    /* dev_spec_op */\
+static int
+plan_base_initialize(gx_device *dev,
+                     dev_proc_map_color_rgb(map_color_rgb),
+                     dev_proc_encode_color(encode_color),
+                     dev_proc_decode_color(decode_color))
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, plan_open);
+    set_dev_proc(dev, close_device, plan_close);
+    set_dev_proc(dev, map_color_rgb, map_color_rgb);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, encode_color, encode_color);
+    set_dev_proc(dev, decode_color, decode_color);
+
+    return 0;
+}
+
+static int
+planm_initialize(gx_device *dev)
+{
+    return plan_base_initialize(dev,
+                                gdev_prn_map_color_rgb,
+                                gdev_prn_map_rgb_color,
+                                gdev_prn_map_color_rgb);
 }
 
 static const gx_device_procs planm_procs =
-  pgpm_procs(gdev_prn_map_color_rgb, gdev_prn_map_rgb_color, gdev_prn_map_color_rgb);
+    devprocs_initialize(planm_initialize);
+
+static int
+plang_initialize(gx_device *dev)
+{
+    return plan_base_initialize(dev,
+                                plang_decode_color,
+                                plang_encode_color,
+                                plang_decode_color);
+}
+
 static const gx_device_procs plang_procs =
-  pgpm_procs(plang_decode_color, plang_encode_color, plang_decode_color);
+    devprocs_initialize(plang_initialize);
+
+static int
+plan_initialize(gx_device *dev)
+{
+    return plan_base_initialize(dev,
+                                plan_decode_color,
+                                gx_default_rgb_map_rgb_color,
+                                plan_decode_color);
+}
+
 static const gx_device_procs plan_procs =
-  pgpm_procs(plan_decode_color, gx_default_rgb_map_rgb_color, plan_decode_color);
+    devprocs_initialize(plan_initialize);
+
+static int
+planc_initialize(gx_device *dev)
+{
+    return plan_base_initialize(dev,
+                                planc_map_color_rgb,
+                                planc_encode_color,
+                                planc_decode_color);
+}
+
 static const gx_device_procs planc_procs =
-  pgpm_procs(planc_map_color_rgb, planc_encode_color, planc_decode_color);
+    devprocs_initialize(planc_initialize);
+
+static int
+plank_initialize(gx_device *dev)
+{
+    return plan_base_initialize(dev,
+                                planc_map_color_rgb,
+                                planc_encode_color,
+                                planc_decode_color);
+}
+
 static const gx_device_procs plank_procs =
-  pgpm_procs(planc_map_color_rgb, planc_encode_color, planc_decode_color);
+    devprocs_initialize(plank_initialize);
+
+static int
+planr_initialize(gx_device *dev)
+{
+    return plan_base_initialize(dev,
+                                plan_decode_color,
+                                gx_default_rgb_map_rgb_color,
+                                plan_decode_color);
+}
+
 static const gx_device_procs planr_procs =
-  pgpm_procs(plan_decode_color, gx_default_rgb_map_rgb_color, plan_decode_color);
+    devprocs_initialize(planr_initialize);
 
 /* Macro for generating device descriptors. */
 #define plan_prn_device(procs, dev_name, num_comp, depth, max_gray, max_rgb, print_page) \
diff --git a/devices/gdevplib.c b/devices/gdevplib.c
index fe9aa33db..20f21471e 100644
--- a/devices/gdevplib.c
+++ b/devices/gdevplib.c
@@ -267,87 +267,103 @@ static int plibk_print_page(gx_device_printer * pdev, gp_file * pstream);
 
 /* The device procedures */
 
-/* See gdevprn.h for the template for the following. */
-#define pgpm_procs(p_color_rgb, p_encode_color, p_decode_color) {\
-        plib_open,\
-        NULL, /* get_initial_matrix */ \
-        NULL, /* sync output */ \
-        /* Since the print_page doesn't alter the device, this device can print in the background */\
-        gdev_prn_bg_output_page, \
-        plib_close,\
-        NULL, /* map_rgb_color */ \
-        p_color_rgb, /* map_color_rgb */ \
-        NULL, /* fill_rectangle */ \
-        NULL, /* tile_rectangle */ \
-        NULL, /* copy_mono */ \
-        NULL, /* copy_color */ \
-        NULL, /* draw_line */ \
-        NULL, /* get_bits */ \
-        gdev_prn_get_params, \
-        plib_put_params,\
-        NULL, /* map_cmyk_color */ \
-        NULL, /* get_xfont_procs */ \
-        NULL, /* get_xfont_device */ \
-        NULL, /* map_rgb_alpha_color */ \
-        gx_page_device_get_page_device, \
-        NULL,   /* get_alpha_bits */\
-        NULL,   /* copy_alpha */\
-        NULL,   /* get_band */\
-        NULL,   /* copy_rop */\
-        NULL,   /* fill_path */\
-        NULL,   /* stroke_path */\
-        NULL,   /* fill_mask */\
-        NULL,   /* fill_trapezoid */\
-        NULL,   /* fill_parallelogram */\
-        NULL,   /* fill_triangle */\
-        NULL,   /* draw_thin_line */\
-        NULL,   /* begin_image */\
-        NULL,   /* image_data */\
-        NULL,   /* end_image */\
-        NULL,   /* strip_tile_rectangle */\
-        NULL,   /* strip_copy_rop */\
-        NULL,   /* get_clipping_box */\
-        NULL,   /* begin_typed_image */\
-        NULL,   /* get_bits_rectangle */\
-        NULL,   /* map_color_rgb_alpha */\
-        NULL,   /* create_compositor */\
-        NULL,   /* get_hardware_params */\
-        NULL,   /* text_begin */\
-        NULL,   /* initialize */\
-        NULL,   /* begin_transparency_group */\
-        NULL,   /* end_transparency_group */\
-        NULL,   /* begin_transparency_mask */\
-        NULL,   /* end_transparency_mask */\
-        NULL,   /* discard_transparency_layer */\
-        NULL,   /* get_color_mapping_procs */\
-        NULL,   /* get_color_comp_index */\
-        p_encode_color, /* encode_color */\
-        p_decode_color, /* decode_color */\
-        NULL,   /* pattern_manage */\
-        NULL,   /* fill_rectangle_hl_color */\
-        NULL,   /* include_color_space */\
-        NULL,   /* fill_linear_color_scanline */\
-        NULL,   /* fill_linear_color_trapezoid */\
-        NULL,   /* fill_linear_color_triangle */\
-        NULL,	/* update spot */\
-        NULL,   /* DevN params */\
-        NULL,   /* fill page */\
-        NULL,   /* push_transparency_state */\
-        NULL,   /* pop_transparency_state */\
-        NULL,   /* put_image */\
-        NULL    /* dev_spec_op */\
+static int
+plib_base_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, plib_open);
+    set_dev_proc(dev, close_device, plib_close);
+    set_dev_proc(dev, put_params, plib_put_params);
+
+    return 0;
+}
+
+static int
+plibm_initialize(gx_device *dev)
+{
+    int code = plib_base_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, encode_color, gdev_prn_map_rgb_color);
+    set_dev_proc(dev, decode_color, gdev_prn_map_color_rgb);
+
+    return 0;
+}
+
+static int
+plibg_initialize(gx_device *dev)
+{
+    int code = plib_base_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, encode_color, plibg_encode_color);
+    set_dev_proc(dev, decode_color, plibg_decode_color);
+
+    return 0;
+}
+
+static int
+plib_initialize(gx_device *dev)
+{
+    int code = plib_base_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, encode_color, gx_default_rgb_map_rgb_color);
+    set_dev_proc(dev, decode_color, plib_decode_color);
+
+    return 0;
+}
+
+static int
+plibc_initialize(gx_device *dev)
+{
+    int code = plib_base_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_color_rgb, plibc_map_color_rgb);
+    set_dev_proc(dev, encode_color, plibc_encode_color);
+    set_dev_proc(dev, decode_color, plibc_decode_color);
+
+    return 0;
+}
+
+static int
+plibk_initialize(gx_device *dev)
+{
+    int code = plib_base_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_color_rgb, plibc_map_color_rgb);
+    set_dev_proc(dev, encode_color, plibc_encode_color);
+    set_dev_proc(dev, decode_color, plibc_decode_color);
+
+    return 0;
 }
 
 static const gx_device_procs plibm_procs =
-  pgpm_procs(NULL, gdev_prn_map_rgb_color, gdev_prn_map_color_rgb);
+    devprocs_initialize(plibm_initialize);
 static const gx_device_procs plibg_procs =
-  pgpm_procs(NULL, plibg_encode_color, plibg_decode_color);
+    devprocs_initialize(plibg_initialize);
 static const gx_device_procs plib_procs =
-  pgpm_procs(NULL, gx_default_rgb_map_rgb_color, plib_decode_color);
+    devprocs_initialize(plib_initialize);
 static const gx_device_procs plibc_procs =
-  pgpm_procs(plibc_map_color_rgb, plibc_encode_color, plibc_decode_color);
+    devprocs_initialize(plibc_initialize);
 static const gx_device_procs plibk_procs =
-  pgpm_procs(plibc_map_color_rgb, plibc_encode_color, plibc_decode_color);
+    devprocs_initialize(plibk_initialize);
 
 /* Macro for generating device descriptors. */
 /* Ideally we'd use something like:
diff --git a/devices/gdevpng.c b/devices/gdevpng.c
index 6eb32c366..df1ebafe9 100644
--- a/devices/gdevpng.c
+++ b/devices/gdevpng.c
@@ -105,9 +105,23 @@ const gx_device_png gs_pngmono_device =
 /* 4-bit planar (EGA/VGA-style) color. */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+png16_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, pc_4bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pc_4bit_map_color_rgb);
+
+    return 0;
+}
+
 static const gx_device_procs png16_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                pc_4bit_map_rgb_color, pc_4bit_map_color_rgb);
+  devprocs_initialize(png16_initialize);
+
 const gx_device_png gs_png16_device = {
   prn_device_body(gx_device_png, png16_procs, "png16",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -121,9 +135,23 @@ const gx_device_png gs_png16_device = {
 /* (Uses a fixed palette of 3,3,2 bits.) */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+png256_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, pc_8bit_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, pc_8bit_map_color_rgb);
+
+    return 0;
+}
+
 static const gx_device_procs png256_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                pc_8bit_map_rgb_color, pc_8bit_map_color_rgb);
+  devprocs_initialize(png256_initialize);
+
 const gx_device_png gs_png256_device = {
   prn_device_body(gx_device_png, png256_procs, "png256",
            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -136,11 +164,23 @@ const gx_device_png gs_png256_device = {
 /* 8-bit gray */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+pnggray_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, png_get_params_downscale);
+    set_dev_proc(dev, put_params, png_put_params_downscale);
+
+    return 0;
+}
+
 static const gx_device_procs pnggray_procs =
-prn_color_params_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                       gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb,
-                       png_get_params_downscale, png_put_params_downscale);
+  devprocs_initialize(pnggray_initialize);
+
 const gx_device_png gs_pnggray_device =
 {prn_device_body(gx_device_png, pnggray_procs, "pnggray",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -153,12 +193,23 @@ const gx_device_png gs_pnggray_device =
 /* Monochrome (with error diffusion) */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+pngmonod_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_rgb_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, png_get_params_downscale_mfs);
+    set_dev_proc(dev, put_params, png_put_params_downscale_mfs);
+
+    return 0;
+}
+
 static const gx_device_procs pngmonod_procs =
-prn_color_params_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                       gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb,
-                       png_get_params_downscale_mfs,
-                       png_put_params_downscale_mfs);
+  devprocs_initialize(pngmonod_initialize);
+
 const gx_device_png gs_pngmonod_device =
 {prn_device_body(gx_device_png, pngmonod_procs, "pngmonod",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -171,11 +222,23 @@ const gx_device_png gs_pngmonod_device =
 /* 24-bit color. */
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+png16m_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_rgb_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, png_get_params_downscale);
+    set_dev_proc(dev, put_params, png_put_params_downscale);
+
+    return 0;
+}
+
 static const gx_device_procs png16m_procs =
-prn_color_params_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                       gx_default_rgb_map_rgb_color,
-                       gx_default_rgb_map_color_rgb,
-                       png_get_params_downscale, png_put_params_downscale);
+  devprocs_initialize(png16m_initialize);
+
 const gx_device_png gs_png16m_device =
 {prn_device_body(gx_device_png, png16m_procs, "png16m",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -189,8 +252,8 @@ const gx_device_png gs_png16m_device =
 
 /* Since the print_page doesn't alter the device, this device can print in the background */
 static const gx_device_procs png48_procs =
-prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-                gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb);
+  devprocs_initialize(gdev_prn_initialize_rgb_bg);
+
 const gx_device_png gs_png48_device =
 {prn_device_body(gx_device_png, png48_procs, "png48",
                  DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
@@ -215,76 +278,34 @@ struct gx_device_pngalpha_s {
     gx_downscaler_params downscale;
     int background;
 };
-static const gx_device_procs pngalpha_procs =
+
+static int
+pngalpha_initialize(gx_device *dev)
 {
-        pngalpha_open,
-        NULL,	/* get_initial_matrix */
-        NULL,	/* sync_output */
-        /* Since the print_page doesn't alter the device, this device can print in the background */
-        gdev_prn_bg_output_page,
-        gdev_prn_close,
-        pngalpha_encode_color,	/* map_rgb_color */
-        pngalpha_decode_color,  /* map_color_rgb */
-        NULL,   /* fill_rectangle */
-        NULL,	/* tile_rectangle */
-        NULL,	/* copy_mono */
-        NULL,	/* copy_color */
-        NULL,	/* draw_line */
-        NULL,	/* get_bits */
-        pngalpha_get_params,
-        pngalpha_put_params,
-        NULL,	/* map_cmyk_color */
-        NULL,	/* get_xfont_procs */
-        NULL,	/* get_xfont_device */
-        NULL,	/* map_rgb_alpha_color */
-        gx_page_device_get_page_device,
-        NULL,	/* get_alpha_bits */
-        pngalpha_copy_alpha,
-        NULL,	/* get_band */
-        NULL,	/* copy_rop */
-        NULL,	/* fill_path */
-        NULL,	/* stroke_path */
-        NULL,	/* fill_mask */
-        NULL,	/* fill_trapezoid */
-        NULL,	/* fill_parallelogram */
-        NULL,	/* fill_triangle */
-        NULL,	/* draw_thin_line */
-        NULL,	/* begin_image */
-        NULL,	/* image_data */
-        NULL,	/* end_image */
-        NULL,	/* strip_tile_rectangle */
-        NULL,	/* strip_copy_rop, */
-        NULL,	/* get_clipping_box */
-        NULL,	/* begin_typed_image */
-        NULL,	/* get_bits_rectangle */
-        NULL,	/* map_color_rgb_alpha */
-        NULL,	/* create_compositor */
-        NULL,	/* get_hardware_params */
-        NULL,	/* text_begin */
-        NULL,	/* initialize */
-        NULL, 	/* begin_transparency_group */
-        NULL, 	/* end_transparency_group */
-        NULL, 	/* begin_transparency_mask */
-        NULL, 	/* end_transparency_mask */
-        NULL, 	/* discard_transparency_layer */
-        gx_default_DevRGB_get_color_mapping_procs,
-        gx_default_DevRGB_get_color_comp_index,
-        pngalpha_encode_color,
-        pngalpha_decode_color,
-        NULL, 	/* pattern_manage */
-        NULL, 	/* fill_rectangle_hl_color */
-        NULL, 	/* include_color_space */
-        NULL, 	/* fill_linear_color_scanline */
-        NULL, 	/* fill_linear_color_trapezoid */
-        NULL, 	/* fill_linear_color_triangle */
-        NULL, 	/* update_spot_equivalent_colors */
-        NULL, 	/* ret_devn_params */
-        pngalpha_fillpage,
-        NULL,	/* push_transparency_state */
-        NULL,	/* pop_transparency_state */
-        pngalpha_put_image,
-        pngalpha_spec_op               /* dev_spec_op */\
-};
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pngalpha_open);
+    set_dev_proc(dev, map_rgb_color, pngalpha_encode_color);
+    set_dev_proc(dev, map_color_rgb, pngalpha_decode_color);
+    set_dev_proc(dev, encode_color, pngalpha_encode_color);
+    set_dev_proc(dev, decode_color, pngalpha_decode_color);
+    set_dev_proc(dev, get_params, pngalpha_get_params);
+    set_dev_proc(dev, put_params, pngalpha_put_params);
+    set_dev_proc(dev, copy_alpha, pngalpha_copy_alpha);
+    set_dev_proc(dev, get_color_mapping_procs, gx_default_DevRGB_get_color_mapping_procs);
+    set_dev_proc(dev, get_color_comp_index, gx_default_DevRGB_get_color_comp_index);
+    set_dev_proc(dev, fillpage, pngalpha_fillpage);
+    set_dev_proc(dev, put_image, pngalpha_put_image);
+    set_dev_proc(dev, dev_spec_op, pngalpha_spec_op);
+
+    return 0;
+}
+
+static const gx_device_procs pngalpha_procs =
+    devprocs_initialize(pngalpha_initialize);
 
 const gx_device_pngalpha gs_pngalpha_device = {
         std_device_part1_(gx_device_pngalpha, &pngalpha_procs, "pngalpha",
diff --git a/devices/gdevpsd.c b/devices/gdevpsd.c
index 669cfb4d1..a4593d80c 100644
--- a/devices/gdevpsd.c
+++ b/devices/gdevpsd.c
@@ -148,77 +148,28 @@ gs_private_st_composite_final(st_psd_device, psd_device,
     "psd_device", psd_device_enum_ptrs, psd_device_reloc_ptrs,
     psd_device_finalize);
 
-/*
- * Macro definition for psd device procedures
- */
-#define device_procs(get_color_mapping_procs, params)\
-{	psd_prn_open,\
-        gx_default_get_initial_matrix,\
-        NULL,				/* sync_output */\
-        /* Since the print_page doesn't alter the device, this device can print in the background */\
-        gdev_prn_bg_output_page,		/* output_page */\
-        psd_prn_close,			/* close */\
-        NULL,				/* map_rgb_color - not used */\
-        psd_map_color_rgb,		/* map_color_rgb */\
-        NULL,				/* fill_rectangle */\
-        NULL,				/* tile_rectangle */\
-        NULL,				/* copy_mono */\
-        NULL,				/* copy_color */\
-        NULL,				/* draw_line */\
-        NULL,				/* get_bits */\
-        psd_get_##params,		/* get_params */\
-        psd_put_##params,		/* put_params */\
-        NULL,				/* map_cmyk_color - not used */\
-        NULL,				/* get_xfont_procs */\
-        NULL,				/* get_xfont_device */\
-        NULL,				/* map_rgb_alpha_color */\
-        gx_page_device_get_page_device,	/* get_page_device */\
-        NULL,				/* get_alpha_bits */\
-        NULL,				/* copy_alpha */\
-        NULL,				/* get_band */\
-        NULL,				/* copy_rop */\
-        NULL,				/* fill_path */\
-        NULL,				/* stroke_path */\
-        NULL,				/* fill_mask */\
-        NULL,				/* fill_trapezoid */\
-        NULL,				/* fill_parallelogram */\
-        NULL,				/* fill_triangle */\
-        NULL,				/* draw_thin_line */\
-        NULL,				/* begin_image */\
-        NULL,				/* image_data */\
-        NULL,				/* end_image */\
-        NULL,				/* strip_tile_rectangle */\
-        NULL,				/* strip_copy_rop */\
-        NULL,				/* get_clipping_box */\
-        NULL,				/* begin_typed_image */\
-        NULL,				/* get_bits_rectangle */\
-        NULL,				/* map_color_rgb_alpha */\
-        NULL,				/* create_compositor */\
-        NULL,				/* get_hardware_params */\
-        NULL,				/* text_begin */\
-        NULL,				/* initialize */\
-        NULL,				/* begin_transparency_group */\
-        NULL,				/* end_transparency_group */\
-        NULL,				/* begin_transparency_mask */\
-        NULL,				/* end_transparency_mask */\
-        NULL,				/* discard_transparency_layer */\
-        get_color_mapping_procs,	/* get_color_mapping_procs */\
-        psd_get_color_comp_index,	/* get_color_comp_index */\
-        gx_devn_prn_encode_color,	/* encode_color */\
-        gx_devn_prn_decode_color,	/* decode_color */\
-        NULL,				/* pattern_manage */\
-        NULL,				/* fill_rectangle_hl_color */\
-        NULL,				/* include_color_space */\
-        NULL,				/* fill_linear_color_scanline */\
-        NULL,				/* fill_linear_color_trapezoid */\
-        NULL,				/* fill_linear_color_triangle */\
-        gx_devn_prn_update_spot_equivalent_colors, /* update_spot_equivalent_colors */\
-        gx_devn_prn_ret_devn_params, /* ret_devn_params */\
-        NULL,                       /* fillpage */\
-        NULL,                       /* push_transparency_state */\
-        NULL,                       /* pop_transparency_state */\
-        NULL,                       /* put_image */\
-        psd_spec_op                 /* dev_spec_op */\
+static int
+psd_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, psd_prn_open);
+    set_dev_proc(dev, close_device, psd_prn_close);
+    set_dev_proc(dev, map_color_rgb, psd_map_color_rgb);
+    set_dev_proc(dev, get_params, psd_get_params);
+    set_dev_proc(dev, put_params, psd_put_params);
+    set_dev_proc(dev, get_color_mapping_procs, get_psdrgb_color_mapping_procs);
+    set_dev_proc(dev, get_color_comp_index, psd_get_color_comp_index);
+    set_dev_proc(dev, encode_color, gx_devn_prn_encode_color);
+    set_dev_proc(dev, decode_color, gx_devn_prn_decode_color);
+    set_dev_proc(dev, update_spot_equivalent_colors, gx_devn_prn_update_spot_equivalent_colors);
+    set_dev_proc(dev, ret_devn_params, gx_devn_prn_ret_devn_params);
+    set_dev_proc(dev, dev_spec_op, psd_spec_op);
+
+    return 0;
 }
 
 #define psd_device_body(procs, dname, ncomp, pol, depth, mg, mc, sl, cn)\
@@ -244,7 +195,7 @@ gs_private_st_composite_final(st_psd_device, psd_device,
  * PSD device with RGB process color model.
  */
 static const gx_device_procs spot_rgb_procs =
-    device_procs(get_psdrgb_color_mapping_procs, params);
+    devprocs_initialize(psd_initialize);
 
 const psd_device gs_psdrgb_device =
 {
@@ -291,8 +242,22 @@ const psd_device gs_psdrgb16_device =
 /*
  * PSD device with CMYK process color model and spot color support.
  */
-static const gx_device_procs spot_cmyk_procs
-        = device_procs(get_psd_color_mapping_procs, params_cmyk);
+static int
+psdcmyk_initialize(gx_device *dev)
+{
+    int code = psd_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, psd_get_params_cmyk);
+    set_dev_proc(dev, put_params, psd_put_params_cmyk);
+    set_dev_proc(dev, get_color_mapping_procs, get_psd_color_mapping_procs);
+
+    return 0;
+}
+static const gx_device_procs spot_cmyk_procs =
+    devprocs_initialize(psdcmyk_initialize);
 
 const psd_device gs_psdcmyk_device =
 {
diff --git a/devices/gdevrinkj.c b/devices/gdevrinkj.c
index ca7b7966c..10e8f5c75 100644
--- a/devices/gdevrinkj.c
+++ b/devices/gdevrinkj.c
@@ -126,67 +126,26 @@ typedef struct rinkj_device_s {
     char setup_fn[256];
 } rinkj_device;
 
-/*
- * Macro definition for DeviceN procedures
- */
-#define device_procs(get_color_mapping_procs)\
-{	gdev_prn_open,\
-        gx_default_get_initial_matrix,\
-        NULL,				/* sync_output */\
-        /* Since the print_page doesn't alter the device, this device can print in the background */\
-        gdev_prn_bg_output_page,		/* output_page */\
-        rinkj_close_device,		/* close */\
-        NULL,				/* map_rgb_color - not used */\
-        rinkj_map_color_rgb,		/* map_color_rgb */\
-        NULL,				/* fill_rectangle */\
-        NULL,				/* tile_rectangle */\
-        NULL,				/* copy_mono */\
-        NULL,				/* copy_color */\
-        NULL,				/* draw_line */\
-        NULL,				/* get_bits */\
-        rinkj_get_params,		/* get_params */\
-        rinkj_put_params,		/* put_params */\
-        NULL,				/* map_cmyk_color - not used */\
-        NULL,				/* get_xfont_procs */\
-        NULL,				/* get_xfont_device */\
-        NULL,				/* map_rgb_alpha_color */\
-        gx_page_device_get_page_device,	/* get_page_device */\
-        NULL,				/* get_alpha_bits */\
-        NULL,				/* copy_alpha */\
-        NULL,				/* get_band */\
-        NULL,				/* copy_rop */\
-        NULL,				/* fill_path */\
-        NULL,				/* stroke_path */\
-        NULL,				/* fill_mask */\
-        NULL,				/* fill_trapezoid */\
-        NULL,				/* fill_parallelogram */\
-        NULL,				/* fill_triangle */\
-        NULL,				/* draw_thin_line */\
-        NULL,				/* begin_image */\
-        NULL,				/* image_data */\
-        NULL,				/* end_image */\
-        NULL,				/* strip_tile_rectangle */\
-        NULL,				/* strip_copy_rop */\
-        NULL,				/* get_clipping_box */\
-        NULL,				/* begin_typed_image */\
-        NULL,				/* get_bits_rectangle */\
-        NULL,				/* map_color_rgb_alpha */\
-        NULL,				/* create_compositor */\
-        NULL,				/* get_hardware_params */\
-        NULL,				/* text_begin */\
-        NULL,				/* initialize */\
-        NULL,				/* begin_transparency_group */\
-        NULL,				/* end_transparency_group */\
-        NULL,				/* begin_transparency_mask */\
-        NULL,				/* end_transparency_mask */\
-        NULL,				/* discard_transparency_layer */\
-        get_color_mapping_procs,	/* get_color_mapping_procs */\
-        rinkj_get_color_comp_index,	/* get_color_comp_index */\
-        rinkj_encode_color,		/* encode_color */\
-        rinkj_decode_color		/* decode_color */\
+static int
+spot_cmyk_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, gdev_prn_open);
+    set_dev_proc(dev, output_page, gdev_prn_bg_output_page);
+    set_dev_proc(dev, close_device, rinkj_close_device);
+    set_dev_proc(dev, map_color_rgb, rinkj_map_color_rgb);
+    set_dev_proc(dev, get_params, rinkj_get_params);
+    set_dev_proc(dev, put_params, rinkj_put_params);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, get_color_mapping_procs, get_rinkj_color_mapping_procs);
+    set_dev_proc(dev, get_color_comp_index, rinkj_get_color_comp_index);
+    set_dev_proc(dev, encode_color, rinkj_encode_color);
+    set_dev_proc(dev, decode_color, rinkj_decode_color);
+
+    return 0;
 }
 
-static const gx_device_procs spot_cmyk_procs = device_procs(get_rinkj_color_mapping_procs);
+static const gx_device_procs spot_cmyk_procs =
+    devprocs_initialize(spot_cmyk_initialize);
 
 const rinkj_device gs_rinkj_device =
 {
diff --git a/devices/gdevsnfb.c b/devices/gdevsnfb.c
index 6ffc7ba46..99ee99cb6 100644
--- a/devices/gdevsnfb.c
+++ b/devices/gdevsnfb.c
@@ -27,8 +27,25 @@ typedef	long	off_t;
 static dev_proc_open_device(sonyfb_open);
 static dev_proc_output_page(sonyfb_output_page);
 static dev_proc_close_device(sonyfb_close);
+
+static int
+sonyfb_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, sonyfb_open);
+    set_dev_proc(dev, output_page, sonyfb_output_page);
+    set_dev_proc(dev, close_device, sonyfb_close);
+
+    return 0;
+}
+
 static gx_device_procs sonyfb_procs =
-  prn_procs(sonyfb_open, sonyfb_output_page, sonyfb_close);
+    devprocs_initialize(sonyfb_initialize);
+
 const gx_device_printer far_data gs_sonyfb_device =
   prn_device(sonyfb_procs, "sonyfb",
         102.4,				/* width_10ths */
diff --git a/devices/gdevstc.c b/devices/gdevstc.c
index 5d8bf4254..47794f27f 100644
--- a/devices/gdevstc.c
+++ b/devices/gdevstc.c
@@ -130,25 +130,24 @@ static dev_proc_map_color_rgb(stc_map_color_cmyk10);
 /***
  *** Table of Device-Procedures
  ***/
-static gx_device_procs stcolor_procs = {
-        stc_open,
-        gx_default_get_initial_matrix,
-        gx_default_sync_output,
-        /* Since the print_page doesn't alter the device, this device can print in the background */
-        gdev_prn_bg_output_page,
-        stc_close,
-        NULL,
-        stc_map_color_cmyk,
-        NULL,   /* fill_rectangle */
-        NULL,   /* tile_rectangle */
-        NULL,   /* copy_mono */
-        NULL,   /* copy_color */
-        NULL,   /* draw_line */
-        gx_default_get_bits,
-        stc_get_params,
-        stc_put_params,
-        stc_map_cmyk_color
-};
+static int
+stcolor_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, stc_open);
+    set_dev_proc(dev, get_initial_matrix, gx_default_get_initial_matrix);
+    set_dev_proc(dev, sync_output, gx_default_sync_output);
+    set_dev_proc(dev, output_page, gdev_prn_bg_output_page);
+    set_dev_proc(dev, close_device, stc_close);
+    set_dev_proc(dev, map_color_rgb, stc_map_color_cmyk);
+    set_dev_proc(dev, get_bits, gx_default_get_bits);
+    set_dev_proc(dev, get_params, stc_get_params);
+    set_dev_proc(dev, put_params, stc_put_params);
+    set_dev_proc(dev, map_cmyk_color, stc_map_cmyk_color);
+
+    return 0;
+}
+static gx_device_procs stcolor_procs =
+    devprocs_initialize(stcolor_initialize);
 
 /***
  *** A local dummy-array for extvals
diff --git a/devices/gdevtfax.c b/devices/gdevtfax.c
index d7abc954c..0dd916aa6 100644
--- a/devices/gdevtfax.c
+++ b/devices/gdevtfax.c
@@ -54,10 +54,27 @@ struct gx_device_tfax_s {
 typedef struct gx_device_tfax_s gx_device_tfax;
 
 /* Define procedures that adjust the paper size. */
-static const gx_device_procs gdev_tfax_std_procs =
 /* FIXME: From initial analysis this is NOT safe for bg_printing, but might be fixable */
-    prn_params_procs(tfax_open, gdev_prn_output_page_seekable, tfax_close,
-                     tfax_get_params, tfax_put_params);
+static int
+tfax_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tfax_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tfax_close);
+    set_dev_proc(dev, get_params, tfax_get_params);
+    set_dev_proc(dev, put_params, tfax_put_params);
+
+    return 0;
+}
+
+
+static const gx_device_procs gdev_tfax_std_procs =
+    devprocs_initialize(tfax_initialize);
 
 #define TFAX_DEVICE(dname, print_page, compr)\
 {\
diff --git a/devices/gdevtfnx.c b/devices/gdevtfnx.c
index e7c7f0fe4..9a316362e 100644
--- a/devices/gdevtfnx.c
+++ b/devices/gdevtfnx.c
@@ -39,14 +39,45 @@ static dev_proc_print_page(tiff_rgb_print_page);
 
 /* FIXME: From initial analysis this is NOT safe for bg_printing, but might be fixable */
 
+static int
+tiff12_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_rgb(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params);
+    set_dev_proc(dev, put_params, tiff_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs tiff12_procs =
-prn_color_params_procs(tiff_open, gdev_prn_output_page_seekable, tiff_close,
-                gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb,
-                tiff_get_params, tiff_put_params);
+    devprocs_initialize(tiff12_initialize);
+
+static int
+tiff24_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_rgb(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params);
+    set_dev_proc(dev, put_params, tiff_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs tiff24_procs =
-prn_color_params_procs(tiff_open, gdev_prn_output_page_seekable, tiff_close,
-                gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb,
-                tiff_get_params, tiff_put_params);
+    devprocs_initialize(tiff24_initialize);
 
 const gx_device_tiff gs_tiff12nc_device = {
     prn_device_std_body(gx_device_tiff, tiff12_procs, "tiff12nc",
diff --git a/devices/gdevtknk.c b/devices/gdevtknk.c
index 7ea923269..0b8a54b57 100644
--- a/devices/gdevtknk.c
+++ b/devices/gdevtknk.c
@@ -32,9 +32,22 @@ static dev_proc_map_rgb_color(tekink_map_rgb_color);
 static dev_proc_map_color_rgb(tekink_map_color_rgb);
 static dev_proc_print_page(tekink_print_page);
 /* Since the print_page doesn't alter the device, this device can print in the background */
+static int
+tekink_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_bg(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, tekink_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, tekink_map_color_rgb);
+
+    return 0;
+}
+
 static gx_device_procs tekink_procs =
-    prn_color_procs(gdev_prn_open, gdev_prn_bg_output_page, gdev_prn_close,
-        tekink_map_rgb_color, tekink_map_color_rgb);
+    devprocs_initialize(tekink_initialize);
 
 /*
    Device descriptor for the Tek 4696.
diff --git a/devices/gdevtrac.c b/devices/gdevtrac.c
index 8dc5bf70c..e42b4d5b2 100644
--- a/devices/gdevtrac.c
+++ b/devices/gdevtrac.c
@@ -602,8 +602,40 @@ trace_text_begin(gx_device * dev, gs_gstate * pgs,
 
 /* ---------------- The device definition ---------------- */
 
-#define TRACE_DEVICE_BODY(dname, ncomp, depth, map_rgb_color, map_color_rgb, map_cmyk_color, map_rgb_alpha_color)\
-    std_device_dci_body(gx_device, 0, dname,\
+static int
+tr_base_initialize(gx_device *dev,
+                   dev_proc_map_rgb_color((*map_rgb_color)),
+                   dev_proc_map_color_rgb((*map_color_rgb)),
+                   dev_proc_map_cmyk_color((*map_cmyk_color)),
+                   dev_proc_map_rgb_alpha_color((*map_rgb_alpha_color)))
+{
+    set_dev_proc(dev, map_rgb_color, map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, trace_fill_rectangle);
+    set_dev_proc(dev, copy_mono, trace_copy_mono);
+    set_dev_proc(dev, copy_color, trace_copy_color);
+    set_dev_proc(dev, map_cmyk_color, map_cmyk_color);
+    set_dev_proc(dev, map_rgb_alpha_color, map_rgb_alpha_color);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, copy_alpha, trace_copy_alpha);
+    set_dev_proc(dev, fill_path, trace_fill_path);
+    set_dev_proc(dev, stroke_path, trace_stroke_path);
+    set_dev_proc(dev, fill_mask, trace_fill_mask);
+    set_dev_proc(dev, fill_trapezoid, trace_fill_trapezoid);
+    set_dev_proc(dev, fill_parallelogram, trace_fill_parallelogram);
+    set_dev_proc(dev, fill_triangle, trace_fill_triangle);
+    set_dev_proc(dev, draw_thin_line, trace_draw_thin_line);
+    set_dev_proc(dev, strip_tile_rectangle, trace_strip_tile_rectangle);
+    set_dev_proc(dev, strip_copy_rop, trace_strip_copy_rop);
+    set_dev_proc(dev, begin_typed_image, trace_begin_typed_image);
+    set_dev_proc(dev, text_begin, trace_text_begin);
+    set_dev_proc(dev, strip_copy_rop2, trace_strip_copy_rop2);
+
+    return 0;
+}
+
+#define TRACE_DEVICE_BODY(dname, ncomp, depth, init)\
+    std_device_dci_body(gx_device, init, dname,\
                         DEFAULT_WIDTH_10THS * X_DPI / 10,\
                         DEFAULT_HEIGHT_10THS * Y_DPI / 10,\
                         X_DPI, Y_DPI, ncomp, depth,\
@@ -611,91 +643,41 @@ trace_text_begin(gx_device * dev, gs_gstate * pgs,
                         (ncomp > 1 ? (1 << (depth / ncomp)) - 1 : 0),\
                         1 << (depth / ncomp),\
                         (ncomp > 1 ? 1 << (depth / ncomp) : 1)),\
-{\
-     NULL,			/* open_device */\
-     NULL,			/* get_initial_matrix */\
-     NULL,			/* sync_output */\
-     NULL,			/* output_page */\
-     NULL,			/* close_device */\
-     map_rgb_color,		/* differs */\
-     map_color_rgb,		/* differs */\
-     trace_fill_rectangle,\
-     NULL,			/* tile_rectangle */\
-     trace_copy_mono,\
-     trace_copy_color,\
-     NULL,			/* draw_line */\
-     NULL,			/* get_bits */\
-     NULL,			/* get_params */\
-     NULL,			/* put_params */\
-     map_cmyk_color,		/* differs */\
-     NULL,			/* get_xfont_procs */\
-     NULL,			/* get_xfont_device */\
-     map_rgb_alpha_color,	/* differs */\
-     gx_page_device_get_page_device,\
-     NULL,			/* get_alpha_bits */\
-     trace_copy_alpha,\
-     NULL,			/* get_band */\
-     NULL,			/* copy_rop */\
-     trace_fill_path,\
-     trace_stroke_path,\
-     trace_fill_mask,\
-     trace_fill_trapezoid,\
-     trace_fill_parallelogram,\
-     trace_fill_triangle,\
-     trace_draw_thin_line,\
-     NULL,			/* begin_image */\
-     NULL,			/* image_data */\
-     NULL,			/* end_image */\
-     trace_strip_tile_rectangle,\
-     trace_strip_copy_rop,\
-     NULL,			/* get_clipping_box */\
-     trace_begin_typed_image,\
-     NULL,			/* get_bits_rectangle */\
-     NULL,			/* map_color_rgb_alpha */\
-     NULL,			/* create_compositor */\
-     NULL,			/* get_hardware_params */\
-     trace_text_begin,\
-     NULL,			/* initialize */\
-     NULL,			/* begin_transparency_group */\
-     NULL,			/* end_transparency_group */\
-     NULL,			/* begin_transparency_mask */\
-     NULL,			/* end_transparency_mask */\
-     NULL,			/* discard_transparency_layer */\
-     NULL,			/* get_color_mapping_procs */\
-     NULL,			/* get_color_comp_index */\
-     NULL,			/* encode_color */\
-     NULL,			/* decode_color */\
-     NULL,			/* pattern_manage */\
-     NULL,			/* fill_rectangle_hl_color */\
-     NULL,			/* include_color_space */\
-     NULL,			/* fill_linear_color_scanline */\
-     NULL,			/* fill_linear_color_trapezoid */\
-     NULL,			/* fill_linear_color_triangle */\
-     NULL,			/* update_spot_equivalent_colors */\
-     NULL,			/* ret_devn_params */\
-     NULL,			/* fillpage */\
-     NULL,			/* push_transparency_state */\
-     NULL,			/* pop_transparency_state */\
-     NULL,			/* put_image */\
-     NULL,			/* dev_spec_op */\
-     NULL,			/* copy_planes */\
-     NULL,			/* get_profile */\
-     NULL,			/* set_graphics_type_tag */\
-     trace_strip_copy_rop2\
+}
+
+static init
+tr_mono_initialize(gx_device *dev)
+{
+    return tr_base_initialize(dev,
+                              gx_default_b_w_map_rgb_color,
+                              gx_default_b_w_map_color_rgb, NULL, NULL);
+
 }
 
 const gx_device gs_tr_mono_device = {
-    TRACE_DEVICE_BODY("tr_mono", 1, 1,
-                      gx_default_b_w_map_rgb_color,
-                      gx_default_b_w_map_color_rgb, NULL, NULL)
+    TRACE_DEVICE_BODY("tr_mono", 1, 1, tr_mono_initialize)
 };
 
+static int
+tr_rgb_initialize(gx_device *dev)
+{
+    return tr_base_initialize(dev,
+                              gx_default_rgb_map_rgb_color,
+                              gx_default_rgb_map_color_rgb, NULL, NULL);
+}
+
 const gx_device gs_tr_rgb_device = {
-    TRACE_DEVICE_BODY("tr_rgb", 3, 24,
-                      gx_default_rgb_map_rgb_color,
-                      gx_default_rgb_map_color_rgb, NULL, NULL)
+    TRACE_DEVICE_BODY("tr_rgb", 3, 24, tr_rgb_initialize);
 };
 
+static int
+tr_cmyk_initialize(gx_device *dev)
+{
+    return tr_base_initialize(dev,
+                              NULL, cmyk_1bit_map_color_rgb,
+                              cmyk_1bit_map_cmyk_color, NULL);
+}
+
 const gx_device gs_tr_cmyk_device = {
     TRACE_DEVICE_BODY("tr_cmyk", 4, 4,
                       NULL, cmyk_1bit_map_color_rgb,
diff --git a/devices/gdevtsep.c b/devices/gdevtsep.c
index df1a31796..119b0d81c 100644
--- a/devices/gdevtsep.c
+++ b/devices/gdevtsep.c
@@ -72,11 +72,26 @@
 static dev_proc_print_page(tiffgray_print_page);
 
 /* FIXME: From initial analysis this is NOT safe for bg_printing, but might be fixable */
+static int
+tiffgray_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params);
+    set_dev_proc(dev, put_params, tiff_put_params);
+
+    return 0;
+}
+
 
 static const gx_device_procs tiffgray_procs =
-prn_color_params_procs(tiff_open, gdev_prn_output_page_seekable, tiff_close,
-                gx_default_gray_map_rgb_color, gx_default_gray_map_color_rgb,
-                tiff_get_params, tiff_put_params);
+    devprocs_initialize(tiffgray_initialize);
 
 const gx_device_tiff gs_tiffgray_device = {
     prn_device_body(gx_device_tiff, tiffgray_procs, "tiffgray",
@@ -109,14 +124,25 @@ dev_proc_open_device(tiff_open_s);
 static dev_proc_print_page(tiffscaled_print_page);
 static int tiff_set_icc_color_fields(gx_device_printer *pdev);
 
+static int
+tiffscaled_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params_downscale);
+    set_dev_proc(dev, put_params, tiff_put_params_downscale);
+
+    return 0;
+}
+
 static const gx_device_procs tiffscaled_procs =
-prn_color_params_procs(tiff_open,
-                       gdev_prn_output_page_seekable,
-                       tiff_close,
-                       gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb,
-                       tiff_get_params_downscale,
-                       tiff_put_params_downscale);
+    devprocs_initialize(tiffscaled_initialize);
 
 const gx_device_tiff gs_tiffscaled_device = {
     prn_device_body(gx_device_tiff,
@@ -143,16 +169,26 @@ const gx_device_tiff gs_tiffscaled_device = {
 
 static dev_proc_print_page(tiffscaled8_print_page);
 
-static const gx_device_procs tiffscaled8_procs = {
-    tiff_open_s, NULL, NULL, gdev_prn_output_page_seekable, tiff_close,
-    gx_default_gray_map_rgb_color, gx_default_gray_map_color_rgb, NULL, NULL,
-    NULL, NULL, NULL, NULL, tiff_get_params_downscale, tiff_put_params_downscale,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, tiffscaled_spec_op
-};
+static int
+tiffscaled8_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open_s);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params_downscale);
+    set_dev_proc(dev, put_params, tiff_put_params_downscale);
+    set_dev_proc(dev, dev_spec_op, tiffscaled_spec_op);
+
+    return 0;
+}
+
+static const gx_device_procs tiffscaled8_procs =
+    devprocs_initialize(tiffscaled8_initialize);
 
 const gx_device_tiff gs_tiffscaled8_device = {
     prn_device_body(gx_device_tiff,
@@ -179,16 +215,26 @@ const gx_device_tiff gs_tiffscaled8_device = {
 
 static dev_proc_print_page(tiffscaled24_print_page);
 
-static const gx_device_procs tiffscaled24_procs = {
-    tiff_open_s, NULL, NULL, gdev_prn_output_page_seekable, tiff_close,
-    gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb, NULL, NULL,
-    NULL, NULL, NULL, NULL, tiff_get_params_downscale, tiff_put_params_downscale,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, tiffscaled_spec_op
-};
+static int
+tiffscaled24_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_rgb(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open_s);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params_downscale);
+    set_dev_proc(dev, put_params, tiff_put_params_downscale);
+    set_dev_proc(dev, dev_spec_op, tiffscaled_spec_op);
+
+    return 0;
+}
+
+static const gx_device_procs tiffscaled24_procs =
+    devprocs_initialize(tiffscaled24_initialize);
 
 const gx_device_tiff gs_tiffscaled24_device = {
     prn_device_body(gx_device_tiff,
@@ -215,16 +261,26 @@ const gx_device_tiff gs_tiffscaled24_device = {
 
 static dev_proc_print_page(tiffscaled32_print_page);
 
-static const gx_device_procs tiffscaled32_procs = {
-    tiff_open_s, NULL, NULL, gdev_prn_output_page_seekable, tiff_close,
-    NULL, cmyk_8bit_map_color_cmyk, NULL, NULL, NULL, NULL, NULL, NULL,
-    tiff_get_params_downscale_cmyk, tiff_put_params_downscale_cmyk,
-    cmyk_8bit_map_cmyk_color, NULL, NULL, NULL, gx_page_device_get_page_device,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, tiffscaled_spec_op
-};
+static int
+tiffscaled32_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk8(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open_s);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params_downscale_cmyk);
+    set_dev_proc(dev, put_params, tiff_put_params_downscale_cmyk);
+    set_dev_proc(dev, dev_spec_op, tiffscaled_spec_op);
+
+    return 0;
+}
+
+static const gx_device_procs tiffscaled32_procs =
+    devprocs_initialize(tiffscaled32_initialize);
 
 const gx_device_tiff gs_tiffscaled32_device = {
     prn_device_body(gx_device_tiff,
@@ -251,12 +307,25 @@ const gx_device_tiff gs_tiffscaled32_device = {
 
 static dev_proc_print_page(tiffscaled4_print_page);
 
-static const gx_device_procs tiffscaled4_procs = {
-    tiff_open, NULL, NULL, gdev_prn_output_page_seekable, tiff_close,
-    NULL, cmyk_8bit_map_color_cmyk, NULL, NULL, NULL, NULL, NULL, NULL,
-    tiff_get_params_downscale_cmyk_ets, tiff_put_params_downscale_cmyk_ets,
-    cmyk_8bit_map_cmyk_color, NULL, NULL, NULL, gx_page_device_get_page_device
-};
+static int
+tiffscaled4_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk8(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params_downscale_cmyk_ets);
+    set_dev_proc(dev, put_params, tiff_put_params_downscale_cmyk_ets);
+
+    return 0;
+}
+
+static const gx_device_procs tiffscaled4_procs =
+    devprocs_initialize(tiffscaled4_initialize);
 
 const gx_device_tiff gs_tiffscaled4_device = {
     prn_device_body(gx_device_tiff,
@@ -519,17 +588,27 @@ tiffsep_spec_op(gx_device *dev_, int op, void *data, int datasize)
 
 static dev_proc_print_page(tiffcmyk_print_page);
 
-#define cmyk_procs(p_map_color_rgb, p_map_cmyk_color)\
-    tiff_open, NULL, NULL, gdev_prn_output_page_seekable, tiff_close,\
-    NULL, p_map_color_rgb, NULL, NULL, NULL, NULL, NULL, NULL,\
-    tiff_get_params, tiff_put_params,\
-    p_map_cmyk_color, NULL, NULL, NULL, gx_page_device_get_page_device
-
 /* 8-bit-per-plane separated CMYK color. */
 
-static const gx_device_procs tiffcmyk_procs = {
-    cmyk_procs(cmyk_8bit_map_color_cmyk, cmyk_8bit_map_cmyk_color)
-};
+static int
+tiffcmyk_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk8(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params);
+    set_dev_proc(dev, put_params, tiff_put_params);
+
+    return 0;
+}
+
+static const gx_device_procs tiffcmyk_procs =
+    devprocs_initialize(tiffcmyk_initialize);
 
 const gx_device_tiff gs_tiff32nc_device = {
     prn_device_body(gx_device_tiff, tiffcmyk_procs, "tiff32nc",
@@ -549,9 +628,25 @@ const gx_device_tiff gs_tiff32nc_device = {
 
 /* 16-bit-per-plane separated CMYK color. */
 
-static const gx_device_procs tiff64nc_procs = {
-    cmyk_procs(cmyk_16bit_map_color_cmyk, cmyk_16bit_map_cmyk_color)
-};
+static int
+tiff64_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk16(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiff_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page_seekable);
+    set_dev_proc(dev, close_device, tiff_close);
+    set_dev_proc(dev, get_params, tiff_get_params);
+    set_dev_proc(dev, put_params, tiff_put_params);
+
+    return 0;
+}
+
+static const gx_device_procs tiff64nc_procs =
+    devprocs_initialize(tiff64_initialize);
 
 const gx_device_tiff gs_tiff64nc_device = {
     prn_device_body(gx_device_tiff, tiff64nc_procs, "tiff64nc",
@@ -701,78 +796,45 @@ gs_private_st_composite_final(st_tiffsep_device, tiffsep_device,
     "tiffsep_device", tiffsep_device_enum_ptrs, tiffsep_device_reloc_ptrs,
     tiffsep_device_finalize);
 
-/*
- * Macro definition for tiffsep device procedures
- */
-#define sep_device_procs(open, close, encode_color, decode_color, update_spot_colors,put_params, fill_path) \
-{       open,\
-        gx_default_get_initial_matrix,\
-        NULL,                           /* sync_output */\
-        gdev_prn_output_page_seekable,  /* output_page */\
-        close,                          /* close */\
-        NULL,                           /* map_rgb_color - not used */\
-        tiffsep_decode_color,           /* map_color_rgb */\
-        NULL,                           /* fill_rectangle */\
-        NULL,                           /* tile_rectangle */\
-        NULL,                           /* copy_mono */\
-        NULL,                           /* copy_color */\
-        NULL,                           /* draw_line */\
-        NULL,                           /* get_bits */\
-        tiffsep_get_params,             /* get_params */\
-        put_params,                     /* put_params */\
-        NULL,                           /* map_cmyk_color - not used */\
-        NULL,                           /* get_xfont_procs */\
-        NULL,                           /* get_xfont_device */\
-        NULL,                           /* map_rgb_alpha_color */\
-        gx_page_device_get_page_device, /* get_page_device */\
-        NULL,                           /* get_alpha_bits */\
-        NULL,                           /* copy_alpha */\
-        NULL,                           /* get_band */\
-        NULL,                           /* copy_rop */\
-        fill_path,                      /* fill_path */\
-        NULL,                           /* stroke_path */\
-        NULL,                           /* fill_mask */\
-        NULL,                           /* fill_trapezoid */\
-        NULL,                           /* fill_parallelogram */\
-        NULL,                           /* fill_triangle */\
-        NULL,                           /* draw_thin_line */\
-        NULL,                           /* begin_image */\
-        NULL,                           /* image_data */\
-        NULL,                           /* end_image */\
-        NULL,                           /* strip_tile_rectangle */\
-        NULL,                           /* strip_copy_rop */\
-        NULL,                           /* get_clipping_box */\
-        NULL,                           /* begin_typed_image */\
-        NULL,                           /* get_bits_rectangle */\
-        NULL,                           /* map_color_rgb_alpha */\
-        NULL,                           /* create_compositor */\
-        NULL,                           /* get_hardware_params */\
-        NULL,                           /* text_begin */\
-        NULL,                           /* initialize */\
-        NULL,                           /* begin_transparency_group */\
-        NULL,                           /* end_transparency_group */\
-        NULL,                           /* begin_transparency_mask */\
-        NULL,                           /* end_transparency_mask */\
-        NULL,                           /* discard_transparency_layer */\
-        tiffsep_get_color_mapping_procs,/* get_color_mapping_procs */\
-        tiffsep_get_color_comp_index,   /* get_color_comp_index */\
-        encode_color,                   /* encode_color */\
-        decode_color,                   /* decode_color */\
-        NULL,                           /* pattern_manage */\
-        NULL,                           /* fill_rectangle_hl_color */\
-        NULL,                           /* include_color_space */\
-        NULL,                           /* fill_linear_color_scanline */\
-        NULL,                           /* fill_linear_color_trapezoid */\
-        NULL,                           /* fill_linear_color_triangle */\
-        update_spot_colors,             /* update_spot_equivalent_colors */\
-        tiffsep_ret_devn_params,         /* ret_devn_params */\
-        NULL,                           /* fillpage */\
-        NULL,                           /* push_transparency_state */\
-        NULL,                           /* pop_transparency_state */\
-        NULL,                           /* put_image */\
-        tiffsep_spec_op                 /* dev_spec_op */\
+static int
+tiffsep_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiffsep_prn_open);
+    set_dev_proc(dev, close_device, tiffsep_prn_close);
+    set_dev_proc(dev, map_color_rgb, tiffsep_decode_color);
+    set_dev_proc(dev, get_params, tiffsep_get_params);
+    set_dev_proc(dev, put_params, tiffsep_put_params);
+    set_dev_proc(dev, get_color_mapping_procs, tiffsep_get_color_mapping_procs);
+    set_dev_proc(dev, get_color_comp_index, tiffsep_get_color_comp_index);
+    set_dev_proc(dev, encode_color, tiffsep_encode_color);
+    set_dev_proc(dev, decode_color, tiffsep_decode_color);
+    set_dev_proc(dev, update_spot_equivalent_colors, tiffsep_update_spot_equivalent_colors);
+    set_dev_proc(dev, ret_devn_params, tiffsep_ret_devn_params);
+    set_dev_proc(dev, dev_spec_op, tiffsep_spec_op);
+
+    return 0;
 }
 
+static int
+tiffsep1_initialize(gx_device *dev)
+{
+    int code = tiffsep_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, tiffsep1_prn_open);
+    set_dev_proc(dev, close_device, tiffsep1_prn_close);
+    set_dev_proc(dev, put_params, tiffsep1_put_params);
+    set_dev_proc(dev, fill_path, sep1_fill_path);
+
+    return 0;
+}
 
 #define tiffsep_devices_body(dtype, procs, dname, ncomp, pol, depth, mg, mc, sl, cn, print_page, compr)\
     std_device_full_body_type_extended(dtype, &procs, dname,\
@@ -812,12 +874,10 @@ gs_private_st_composite_final(st_tiffsep_device, tiffsep_device,
  * TIFF devices with CMYK process color model and spot color support.
  */
 static const gx_device_procs spot_cmyk_procs =
-                sep_device_procs(tiffsep_prn_open, tiffsep_prn_close, tiffsep_encode_color, tiffsep_decode_color,
-                                tiffsep_update_spot_equivalent_colors, tiffsep_put_params, NULL);
+    devprocs_initialize(tiffsep_initialize);
 
 static const gx_device_procs spot1_cmyk_procs =
-                sep_device_procs(tiffsep1_prn_open, tiffsep1_prn_close, tiffsep_encode_color, tiffsep_decode_color,
-                                tiffsep_update_spot_equivalent_colors, tiffsep1_put_params, sep1_fill_path);
+    devprocs_initialize(tiffsep1_initialize);
 
 const tiffsep_device gs_tiffsep_device =
 {
@@ -2989,4 +3049,3 @@ tiff_open_s(gx_device *pdev)
     }
     return tiff_open(pdev);
 }
-
diff --git a/devices/gdevupd.c b/devices/gdevupd.c
index badc80417..58369c7dd 100644
--- a/devices/gdevupd.c
+++ b/devices/gdevupd.c
@@ -218,24 +218,23 @@ prn_std_procs instead of defining their own procedure-table.
 #define upd_set_dev_proc(dev, p, proc) \
    ((dev)->std_procs.p = (dev)->orig_procs.p = (proc))
 
-static gx_device_procs upd_procs = {  /** Table of procedures */
-   upd_open,                      /** open-function, upd-special */
-   gx_default_get_initial_matrix, /** retrieve matrix */
-   gx_default_sync_output,        /** sync display */
-   gdev_prn_output_page,          /** superclass-print (calls back) */
-   upd_close,                     /** close-function, upd-special */
-   gx_default_map_rgb_color,      /** RGB-mapping */
-   gx_default_map_color_rgb,      /** reverse mapping */
-   NULL,                          /** fill_rectangle */
-   NULL,                          /** tile_rectangle */
-   NULL,                          /** copy_mono */
-   NULL,                          /** copy_color */
-   NULL,                          /** draw_line */
-   gx_default_get_bits,           /** reads scanlines, e.g. for the driver */
-   upd_get_params,                /** Export parameters, upd-special */
-   upd_put_params,                /** Import parameters, upd-special */
-   gx_default_map_cmyk_color      /** KCMY-mapping */
-};                                     /** */
+static int
+upd_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, upd_open);
+    set_dev_proc(dev, output_page, gdev_prn_output_page);
+    set_dev_proc(dev, close_device, upd_close);
+    set_dev_proc(dev, map_rgb_color, gx_default_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gx_default_map_color_rgb);
+    set_dev_proc(dev, get_params, upd_get_params);
+    set_dev_proc(dev, get_params, upd_put_params);
+    set_dev_proc(dev, map_cmyk_color, gx_default_map_cmyk_color);
+
+    return 0;
+}
+
+static gx_device_procs upd_procs =
+    devprocs_initialize(upd_initialize);
 
 /**
 The prototype-instance of the device-structure _must_ have the name
diff --git a/devices/gdevwpr2.c b/devices/gdevwpr2.c
index c91e82a16..f2f14fef3 100644
--- a/devices/gdevwpr2.c
+++ b/devices/gdevwpr2.c
@@ -147,10 +147,26 @@ static dev_proc_put_params(win_pr2_put_params);
 
 static int win_pr2_set_bpp(gx_device * dev, int depth);
 
+static int
+win_pr2_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, win_pr2_open);
+    set_dev_proc(dev, close_device, win_pr2_close);
+    set_dev_proc(dev, map_rgb_color, win_pr2_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, win_pr2_map_color_rgb);
+    set_dev_proc(dev, get_params, win_pr2_get_params);
+    set_dev_proc(dev, put_params, win_pr2_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs win_pr2_procs =
-prn_color_params_procs(win_pr2_open, gdev_prn_output_page, win_pr2_close,
-                       win_pr2_map_rgb_color, win_pr2_map_color_rgb,
-                       win_pr2_get_params, win_pr2_put_params);
+    devprocs_initialize(win_pr2_initialize);
 
 #define PARENT_WINDOW  HWND_DESKTOP
 BOOL CALLBACK CancelDlgProc(HWND, UINT, WPARAM, LPARAM);
diff --git a/devices/gdevx.c b/devices/gdevx.c
index f15932e93..8daec3a19 100644
--- a/devices/gdevx.c
+++ b/devices/gdevx.c
@@ -52,106 +52,12 @@ static void update_do_flush(gx_device_X *);
 static void do_flush_text(gx_device_X *);
 
 /* Driver procedures */
-/* (External procedures are declared in gdevx.h.) */
-/*extern int gdev_x_open(gx_device_X *);*/
-static dev_proc_open_device(x_open);
-static dev_proc_get_initial_matrix(x_get_initial_matrix);
-static dev_proc_sync_output(x_sync);
-static dev_proc_output_page(x_output_page);
-/*extern int gdev_x_close(gx_device_X *);*/
-static dev_proc_close_device(x_close);
-/*extern dev_proc_map_rgb_color(gdev_x_map_rgb_color);*/
-/*extern dev_proc_map_color_rgb(gdev_x_map_color_rgb);*/
-static dev_proc_fill_rectangle(x_fill_rectangle);
-static dev_proc_copy_mono(x_copy_mono);
-static dev_proc_copy_color(x_copy_color);
-/*extern dev_proc_get_params(gdev_x_get_params);*/
-/*extern dev_proc_put_params(gdev_x_put_params);*/
-static dev_proc_get_page_device(x_get_page_device);
-static dev_proc_strip_tile_rectangle(x_strip_tile_rectangle);
-static dev_proc_get_bits_rectangle(x_get_bits_rectangle);
-/*extern dev_proc_get_xfont_procs(gdev_x_initialize);*/
-static dev_proc_fillpage(x_fillpage);
 
 /* The device descriptor */
 #define x_device(this_device, dev_body) \
 const gx_device_X this_device = { \
     dev_body, \
-    {				/* std_procs */ \
-        x_open, \
-        x_get_initial_matrix, \
-        x_sync, \
-        x_output_page, \
-        x_close, \
-        gdev_x_map_rgb_color, \
-        gdev_x_map_color_rgb, \
-        x_fill_rectangle, \
-        NULL,			/* tile_rectangle */ \
-        x_copy_mono, \
-        x_copy_color, \
-        NULL,			/* draw_line */ \
-        NULL,			/* get_bits */ \
-        gdev_x_get_params, \
-        gdev_x_put_params, \
-        NULL,			/* map_cmyk_color */ \
-        NULL, \
-        NULL,			/* get_xfont_device */ \
-        NULL,			/* map_rgb_alpha_color */ \
-        x_get_page_device, \
-        NULL,			/* get_alpha_bits */ \
-        NULL,			/* copy_alpha */ \
-        NULL,			/* get_band */ \
-        NULL,			/* copy_rop */ \
-        NULL,			/* fill_path */ \
-        NULL,			/* stroke_path */ \
-        NULL,			/* fill_mask */ \
-        NULL,			/* fill_trapezoid */ \
-        NULL,			/* fill_parallelogram */ \
-        NULL,			/* fill_triangle */ \
-        NULL,			/* draw_thin_line */ \
-        NULL,			/* begin_image */ \
-        NULL,			/* image_data */ \
-        NULL,			/* end_image */ \
-        x_strip_tile_rectangle, \
-        NULL,			/* strip_copy_rop */ \
-        NULL,			/* get_clipping_box */ \
-        NULL,                   /* begin_typed_image */ \
-        x_get_bits_rectangle, \
-        NULL,			/* map_color_rgb_alpha */ \
-        NULL,			/* create_compositor */ \
-        NULL,			/* get_hardware_params */ \
-        NULL,			/* text_begin */ \
-        gdev_x_initialize, \
-        NULL,			/* begin_transparency_group */ \
-        NULL,                   /* end_transparency_group */ \
-        NULL,                  /* begin_transparency_mask */ \
-        NULL,                    /* end_transparency_mask */ \
-        NULL,                       /* discard_transparency_layer */ \
-        NULL,                  /* get_color_mapping_procs */ \
-        NULL,                     /* get_color_comp_index */ \
-        NULL,                     /* encode_color */ \
-        NULL,                     /* decode_color */ \
-        NULL,                   /* pattern_manage */ \
-        NULL,                       /* fill_rectangle_hl_color */ \
-        NULL,                      /* include_color_space */ \
-        NULL,                    /* fill_linear_color_scanline */ \
-        NULL,                   /* fill_linear_color_trapezoid */ \
-        NULL,                    /* fill_linear_color_triangle */ \
-        NULL,                    /* update_spot_equivalent_colors */ \
-        NULL,                  /* ret_devn_params */ \
-        x_fillpage,              /* fillpage */ \
-        NULL,                      /* push_transparency_state */ \
-        NULL,                      /* pop_transparency_state */ \
-        NULL,                      /* put_image */ \
-        NULL,                      /* dev_spec_op */ \
-        NULL,                      /* copy_planes */ \
-        NULL,                      /* get_profile */ \
-        NULL,        /* set_graphics_type_tag */ \
-        NULL, \
-        NULL, \
-        NULL, \
-        NULL  \
-    }, \
+    devprocs_initialize(gdev_x_initialize), \
     gx_device_bbox_common_initial(0 /*false*/, 1 /*true*/, 1 /*true*/), \
     0 /*false*/,		/* is_buffered */ \
     1 /*true*/,			/* IsPageDevice */ \
@@ -284,7 +190,7 @@ GC gc, XImage * pi, int sx, int sy, int dx, int dy, unsigned w, unsigned h);
   END
 
 /* Open the device.  Most of the code is in gdevxini.c. */
-static int
+int
 x_open(gx_device * dev)
 {
     gx_device_X *xdev = (gx_device_X *) dev;
@@ -310,7 +216,7 @@ x_open(gx_device * dev)
 }
 
 /* Close the device. */
-static int
+int
 x_close(gx_device * dev)
 {
     gx_device_X *xdev = (gx_device_X *) dev;
@@ -321,7 +227,7 @@ x_close(gx_device * dev)
 /* Get initial matrix for X device. */
 /* This conflicts seriously with the code for page devices; */
 /* we only do it if Ghostview is active. */
-static void
+void
 x_get_initial_matrix(gx_device * dev, gs_matrix * pmat)
 {
     gx_device_X *xdev = (gx_device_X *) dev;
@@ -339,7 +245,7 @@ x_get_initial_matrix(gx_device * dev, gs_matrix * pmat)
 }
 
 /* Synchronize the display with the commands already given. */
-static int
+int
 x_sync(gx_device * dev)
 {
     gx_device_X *xdev = (gx_device_X *) dev;
@@ -366,7 +272,7 @@ gdev_x_send_event(gx_device_X *xdev, Atom msg)
 }
 
 /* Output "page" */
-static int
+int
 x_output_page(gx_device * dev, int num_copies, int flush)
 {
     gx_device_X *xdev = (gx_device_X *) dev;
@@ -389,7 +295,7 @@ x_output_page(gx_device * dev, int num_copies, int flush)
 }
 
 /* Fill a rectangle with a color. */
-static int
+int
 x_fill_rectangle(gx_device * dev,
                  int x, int y, int w, int h, gx_color_index gscolor)
 {
@@ -420,7 +326,7 @@ x_fill_rectangle(gx_device * dev,
 }
 
 /* Copy a monochrome bitmap. */
-static int
+int
 x_copy_mono(gx_device * dev,
             const byte * base, int sourcex, int raster, gx_bitmap_id id,
             int x, int y, int w, int h,
@@ -642,7 +548,8 @@ x_copy_image(gx_device_X * xdev, const byte * base, int sourcex, int raster,
     }
     return 0;
 }
-static int
+
+int
 x_copy_color(gx_device * dev,
              const byte * base, int sourcex, int raster, gx_bitmap_id id,
              int x, int y, int w, int h)
@@ -662,14 +569,14 @@ x_copy_color(gx_device * dev,
 
 /* Get the page device.  We reimplement this so that we can make this */
 /* device be a page device conditionally. */
-static gx_device *
+gx_device *
 x_get_page_device(gx_device * dev)
 {
     return (((gx_device_X *) dev)->IsPageDevice ? dev : (gx_device *) 0);
 }
 
 /* Tile a rectangle. */
-static int
+int
 x_strip_tile_rectangle(gx_device * dev, const gx_strip_bitmap * tiles,
                        int x, int y, int w, int h,
                        gx_color_index zero, gx_color_index one,
@@ -751,7 +658,7 @@ x_strip_tile_rectangle(gx_device * dev, const gx_strip_bitmap * tiles,
 }
 
 /* Read bits back from the screen. */
-static int
+int
 x_get_bits_rectangle(gx_device * dev, const gs_int_rect * prect,
                      gs_get_bits_params_t * params, gs_int_rect ** unread)
 {
@@ -947,7 +854,7 @@ x_get_bits_rectangle(gx_device * dev, const gs_int_rect * prect,
 /* Supplying a fillpage prevents the erasepage optimisation
    device being installed.
  */
-static int
+int
 x_fillpage(gx_device *dev, gs_gstate * pgs, gx_device_color *pdevc)
 {
     return gx_default_fillpage(dev, pgs, pdevc);
diff --git a/devices/gdevx.h b/devices/gdevx.h
index 05c6d2ab1..03defc609 100644
--- a/devices/gdevx.h
+++ b/devices/gdevx.h
@@ -228,5 +228,18 @@ dev_proc_map_color_rgb(gdev_x_map_color_rgb);  /* gdevxcmp.c */
 dev_proc_get_params(gdev_x_get_params);  /* gdevxini.c */
 dev_proc_put_params(gdev_x_put_params);  /* gdevxini.c */
 dev_proc_initialize(gdev_x_initialize);  /* gdevxini.c */
+dev_proc_open_device(x_open);
+dev_proc_get_initial_matrix(x_get_initial_matrix);
+dev_proc_sync_output(x_sync);
+dev_proc_output_page(x_output_page);
+dev_proc_close_device(x_close);
+dev_proc_fill_rectangle(x_fill_rectangle);
+dev_proc_copy_mono(x_copy_mono);
+dev_proc_copy_color(x_copy_color);
+dev_proc_get_page_device(x_get_page_device);
+dev_proc_strip_tile_rectangle(x_strip_tile_rectangle);
+dev_proc_get_bits_rectangle(x_get_bits_rectangle);
+dev_proc_fillpage(x_fillpage);
+
 
 #endif /* gdevx_INCLUDED */
diff --git a/devices/gdevxalt.c b/devices/gdevxalt.c
index 0290c8c60..92b71ce7a 100644
--- a/devices/gdevxalt.c
+++ b/devices/gdevxalt.c
@@ -546,32 +546,35 @@ static dev_proc_put_params(x_cmyk_put_params);
 static dev_proc_map_cmyk_color(x_cmyk_map_cmyk_color);
 /* Extended device procedures */
 static dev_proc_map_color_rgb(x_cmyk_alt_map_color);
+extern dev_proc_output_page(x_output_page);
+
+static int
+x_cmyk_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, x_cmyk_open);
+    set_dev_proc(dev, get_initial_matrix, gx_forward_get_initial_matrix);
+    set_dev_proc(dev, sync_output, x_forward_sync_output);
+    set_dev_proc(dev, output_page, x_output_page);
+    set_dev_proc(dev, close_device, x_wrap_close);
+    set_dev_proc(dev, map_color_rgb, x_wrap_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
+    set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
+    set_dev_proc(dev, copy_color, x_wrap_copy_color);
+    set_dev_proc(dev, get_bits, x_wrap_get_bits);
+    set_dev_proc(dev, get_params, x_wrap_get_params);
+    set_dev_proc(dev, put_params, x_cmyk_put_params);
+    set_dev_proc(dev, map_cmyk_color, x_cmyk_map_cmyk_color);
+    set_dev_proc(dev, get_xfont_procs, gx_forward_get_xfont_procs);
+    set_dev_proc(dev, get_xfont_device, gx_forward_get_xfont_device);
+    set_dev_proc(dev, get_page_device, gx_forward_get_page_device);
+    set_dev_proc(dev, get_alpha_bits, gx_forward_get_alpha_bits);
+
+    return 0;
+}
 
 /* The device descriptor */
-static const gx_device_procs x_cmyk_procs = {
-    x_cmyk_open,
-    gx_forward_get_initial_matrix,
-    x_forward_sync_output,
-    x_forward_output_page,
-    x_wrap_close,
-    NULL,			/* map_rgb_color */
-    x_wrap_map_color_rgb,
-    x_wrap_fill_rectangle,
-    gx_default_tile_rectangle,
-    x_wrap_copy_mono,
-    x_wrap_copy_color,
-    gx_default_draw_line,
-    x_wrap_get_bits,
-    x_wrap_get_params,
-    x_cmyk_put_params,
-    x_cmyk_map_cmyk_color,
-    gx_forward_get_xfont_procs,
-    gx_forward_get_xfont_device,
-    NULL,			/* map_rgb_alpha_color */
-    gx_forward_get_page_device,
-    gx_forward_get_alpha_bits,
-    NULL			/* copy_alpha */
-};
+static const gx_device_procs x_cmyk_procs =
+    devprocs_initialize(x_cmyk_initialize);
 
 /* The instances are public. */
 const gx_device_X_wrapper gs_x11cmyk_device = {
@@ -679,30 +682,31 @@ x_cmyk_map_cmyk_color(gx_device * dev, const gx_color_value cv[])
 static dev_proc_map_color_rgb(x_mono_alt_map_color);
 
 /* The device descriptor */
-static const gx_device_procs x_mono_procs = {
-    x_wrap_open,
-    gx_forward_get_initial_matrix,
-    x_forward_sync_output,
-    x_forward_output_page,
-    x_wrap_close,
-    gx_default_b_w_map_rgb_color,
-    x_wrap_map_color_rgb,
-    x_wrap_fill_rectangle,
-    gx_default_tile_rectangle,
-    x_wrap_copy_mono,
-    gx_default_copy_color,	/* this is fast for the 1-bit case */
-    gx_default_draw_line,
-    x_wrap_get_bits,
-    x_wrap_get_params,
-    x_wrap_put_params,
-    gx_default_map_cmyk_color,
-    gx_forward_get_xfont_procs,
-    gx_forward_get_xfont_device,
-    NULL,			/* map_rgb_alpha_color */
-    gx_forward_get_page_device,
-    gx_forward_get_alpha_bits,
-    NULL			/* copy_alpha */
-};
+static int
+x_mono_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, x_wrap_open);
+    set_dev_proc(dev, get_initial_matrix, gx_forward_get_initial_matrix);
+    set_dev_proc(dev, sync_output, x_forward_sync_output);
+    set_dev_proc(dev, output_page, x_forward_output_page);
+    set_dev_proc(dev, close_device, x_wrap_close);
+    set_dev_proc(dev, map_rgb_color, gx_default_b_w_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, x_wrap_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
+    set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
+    set_dev_proc(dev, get_bits, x_wrap_get_bits);
+    set_dev_proc(dev, get_params, x_wrap_get_params);
+    set_dev_proc(dev, put_params, x_wrap_put_params);
+    set_dev_proc(dev, get_xfont_procs, gx_forward_get_xfont_procs);
+    set_dev_proc(dev, get_xfont_device, gx_forward_get_xfont_device);
+    set_dev_proc(dev, get_page_device, gx_forward_get_page_device);
+    set_dev_proc(dev, get_alpha_bits, gx_forward_get_alpha_bits);
+
+    return 0;
+}
+
+static const gx_device_procs x_mono_procs =
+    devprocs_initialize(x_mono_initialize);
 
 /* The instance is public. */
 const gx_device_X_wrapper gs_x11mono_device = {
@@ -729,30 +733,32 @@ x_mono_alt_map_color(gx_device * dev, gx_color_index color,
 static dev_proc_map_color_rgb(x_gray_alt_map_color);
 
 /* The device descriptor */
-static const gx_device_procs x_gray_procs = {
-    x_wrap_open,
-    gx_forward_get_initial_matrix,
-    x_forward_sync_output,
-    x_forward_output_page,
-    x_wrap_close,
-    gx_default_gray_map_rgb_color,
-    x_wrap_map_color_rgb,
-    x_wrap_fill_rectangle,
-    gx_default_tile_rectangle,
-    x_wrap_copy_mono,
-    x_wrap_copy_color,
-    gx_default_draw_line,
-    x_wrap_get_bits,
-    x_wrap_get_params,
-    x_wrap_put_params,
-    gx_default_map_cmyk_color,
-    gx_forward_get_xfont_procs,
-    gx_forward_get_xfont_device,
-    NULL,			/* map_rgb_alpha_color */
-    gx_forward_get_page_device,
-    gx_forward_get_alpha_bits,
-    NULL			/* copy_alpha */
-};
+static int
+x_gray_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, x_wrap_open);
+    set_dev_proc(dev, get_initial_matrix, gx_forward_get_initial_matrix);
+    set_dev_proc(dev, sync_output, x_forward_sync_output);
+    set_dev_proc(dev, output_page, x_forward_output_page);
+    set_dev_proc(dev, close_device, x_wrap_close);
+    set_dev_proc(dev, map_rgb_color, gx_default_gray_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, x_wrap_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
+    set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
+    set_dev_proc(dev, copy_color, x_wrap_copy_color);
+    set_dev_proc(dev, get_bits, x_wrap_get_bits);
+    set_dev_proc(dev, get_params, x_wrap_get_params);
+    set_dev_proc(dev, put_params, x_wrap_put_params);
+    set_dev_proc(dev, get_xfont_procs, gx_forward_get_xfont_procs);
+    set_dev_proc(dev, get_xfont_device, gx_forward_get_xfont_device);
+    set_dev_proc(dev, get_page_device, gx_forward_get_page_device);
+    set_dev_proc(dev, get_alpha_bits, gx_forward_get_alpha_bits);
+
+    return 0;
+}
+
+static const gx_device_procs x_gray_procs =
+    devprocs_initialize(x_gray_initialize);
 
 /* The instances are public. */
 const gx_device_X_wrapper gs_x11gray2_device = {
@@ -810,33 +816,41 @@ static dev_proc_map_color_rgb(x_rg16x_alt_map_color);
 static dev_proc_map_color_rgb(x_rg32x_alt_map_color);
 
 /* The device descriptor */
-#define RGBX_PROCS(map_rgb_proc)\
-    x_wrap_open,\
-    gx_forward_get_initial_matrix,\
-    x_forward_sync_output,\
-    x_forward_output_page,\
-    x_wrap_close,\
-    map_rgb_proc,		/* differs */\
-    x_wrap_map_color_rgb,\
-    x_wrap_fill_rectangle,\
-    gx_default_tile_rectangle,\
-    x_wrap_copy_mono,\
-    x_forward_copy_color,\
-    gx_default_draw_line,\
-    x_forward_get_bits,\
-    x_wrap_get_params,\
-    x_wrap_put_params,\
-    gx_forward_map_cmyk_color,\
-    gx_forward_get_xfont_procs,\
-    gx_forward_get_xfont_device,\
-    x_alpha_map_rgb_alpha_color,\
-    gx_forward_get_page_device,\
-    gx_default_get_alpha_bits,\
-    gx_default_copy_alpha
-
-static const gx_device_procs x_rg16x_procs = {
-    RGBX_PROCS(x_rg16x_map_rgb_color)
-};
+static int
+rgbx_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, x_wrap_open);
+    set_dev_proc(dev, get_initial_matrix, gx_forward_get_initial_matrix);
+    set_dev_proc(dev, sync_output, x_forward_sync_output);
+    set_dev_proc(dev, output_page, x_forward_output_page);
+    set_dev_proc(dev, close_device, x_wrap_close);
+    set_dev_proc(dev, map_color_rgb, x_wrap_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, x_wrap_fill_rectangle);
+    set_dev_proc(dev, copy_mono, x_wrap_copy_mono);
+    set_dev_proc(dev, copy_color, x_forward_copy_color);
+    set_dev_proc(dev, get_bits, x_forward_get_bits);
+    set_dev_proc(dev, get_params, x_wrap_get_params);
+    set_dev_proc(dev, put_params, x_wrap_put_params);
+    set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
+    set_dev_proc(dev, get_xfont_procs, gx_forward_get_xfont_procs);
+    set_dev_proc(dev, get_xfont_device, gx_forward_get_xfont_device);
+    set_dev_proc(dev, map_rgb_alpha_color, x_alpha_map_rgb_alpha_color);
+    set_dev_proc(dev, get_page_device, gx_forward_get_page_device);
+
+    return 0;
+}
+
+static int
+x_rg16x_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, map_rgb_color, x_rg16x_map_rgb_color);
+
+    return rgbx_initialize(dev);
+}
+
+static const gx_device_procs x_rg16x_procs =
+    devprocs_initialize(x_rg16x_initialize);
+
 const gx_device_X_wrapper gs_x11rg16x_device = {
     std_device_dci_type_body(gx_device_X_wrapper, &x_rg16x_procs, "x11rg16x",
         &st_device_X_wrapper,
@@ -846,9 +860,17 @@ const gx_device_X_wrapper gs_x11rg16x_device = {
     X_WRAPPER_DATA(x_rg16x_alt_map_color)
 };
 
-static const gx_device_procs x_rg32x_procs = {
-    RGBX_PROCS(x_rg32x_map_rgb_color)
-};
+static int
+x_rg32x_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, map_rgb_color, x_rg32x_map_rgb_color);
+
+    return rgbx_initialize(dev);
+}
+
+static const gx_device_procs x_rg32x_procs =
+    devprocs_initialize(x_rg32x_initialize);
+
 const gx_device_X_wrapper gs_x11rg32x_device = {
     std_device_dci_type_body(gx_device_X_wrapper, &x_rg32x_procs, "x11rg32x",
         &st_device_X_wrapper,
diff --git a/devices/gdevxcf.c b/devices/gdevxcf.c
index 86b635e57..3ffae2b72 100644
--- a/devices/gdevxcf.c
+++ b/devices/gdevxcf.c
@@ -135,67 +135,36 @@ typedef struct xcf_device_s {
 /*
  * Macro definition for DeviceN procedures
  */
-#define device_procs(get_color_mapping_procs)\
-{	gdev_prn_open,\
-        gx_default_get_initial_matrix,\
-        NULL,				/* sync_output */\
-        /* Since the print_page doesn't alter the device, this device can print in the background */\
-        gdev_prn_bg_output_page,		/* output_page */\
-        xcf_prn_close,			/* close */\
-        NULL,				/* map_rgb_color - not used */\
-        xcf_map_color_rgb,		/* map_color_rgb */\
-        NULL,				/* fill_rectangle */\
-        NULL,				/* tile_rectangle */\
-        NULL,				/* copy_mono */\
-        NULL,				/* copy_color */\
-        NULL,				/* draw_line */\
-        NULL,				/* get_bits */\
-        xcf_get_params,		/* get_params */\
-        xcf_put_params,		/* put_params */\
-        NULL,				/* map_cmyk_color - not used */\
-        NULL,				/* get_xfont_procs */\
-        NULL,				/* get_xfont_device */\
-        NULL,				/* map_rgb_alpha_color */\
-        gx_page_device_get_page_device,	/* get_page_device */\
-        NULL,				/* get_alpha_bits */\
-        NULL,				/* copy_alpha */\
-        NULL,				/* get_band */\
-        NULL,				/* copy_rop */\
-        NULL,				/* fill_path */\
-        NULL,				/* stroke_path */\
-        NULL,				/* fill_mask */\
-        NULL,				/* fill_trapezoid */\
-        NULL,				/* fill_parallelogram */\
-        NULL,				/* fill_triangle */\
-        NULL,				/* draw_thin_line */\
-        NULL,				/* begin_image */\
-        NULL,				/* image_data */\
-        NULL,				/* end_image */\
-        NULL,				/* strip_tile_rectangle */\
-        NULL,				/* strip_copy_rop */\
-        NULL,				/* get_clipping_box */\
-        NULL,				/* begin_typed_image */\
-        NULL,				/* get_bits_rectangle */\
-        NULL,				/* map_color_rgb_alpha */\
-        NULL,				/* create_compositor */\
-        NULL,				/* get_hardware_params */\
-        NULL,				/* text_begin */\
-        NULL,				/* initialize */\
-        NULL,				/* begin_transparency_group */\
-        NULL,				/* end_transparency_group */\
-        NULL,				/* begin_transparency_mask */\
-        NULL,				/* end_transparency_mask */\
-        NULL,				/* discard_transparency_layer */\
-        get_color_mapping_procs,	/* get_color_mapping_procs */\
-        xcf_get_color_comp_index,	/* get_color_comp_index */\
-        xcf_encode_color,		/* encode_color */\
-        xcf_decode_color		/* decode_color */\
+static int
+xcf_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, gdev_prn_open);
+    set_dev_proc(dev, output_page, gdev_prn_bg_output_page);
+    set_dev_proc(dev, close_device, xcf_prn_close);
+    set_dev_proc(dev, map_color_rgb, xcf_map_color_rgb);
+    set_dev_proc(dev, get_params, xcf_get_params);
+    set_dev_proc(dev, put_params, xcf_put_params);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, get_color_comp_index, xcf_get_color_comp_index);
+    set_dev_proc(dev, encode_color, xcf_encode_color);
+    set_dev_proc(dev, decode_color, xcf_decode_color);
+
+    return 0;
+}
+
+static int
+spot_rgb_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, get_color_mapping_procs, get_spotrgb_color_mapping_procs);
+
+    return xcf_initialize(dev);
 }
 
 /*
  * Example device with RGB and spot color support
  */
-static const gx_device_procs spot_rgb_procs = device_procs(get_spotrgb_color_mapping_procs);
+static const gx_device_procs spot_rgb_procs =
+    devprocs_initialize(spot_rgb_initialize);
 
 const xcf_device gs_xcf_device =
 {
@@ -219,7 +188,16 @@ const xcf_device gs_xcf_device =
     {0}				/* SeparationOrder names */
 };
 
-static const gx_device_procs spot_cmyk_procs = device_procs(get_xcf_color_mapping_procs);
+static int
+spot_cmyk_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, get_color_mapping_procs, get_xcf_color_mapping_procs);
+
+    return xcf_initialize(dev);
+}
+
+static const gx_device_procs spot_cmyk_procs =
+    devprocs_initialize(spot_cmyk_initialize);
 
 const xcf_device gs_xcfcmyk_device =
 {
diff --git a/devices/gdevxini.c b/devices/gdevxini.c
index 4fd7992d0..039c09954 100644
--- a/devices/gdevxini.c
+++ b/devices/gdevxini.c
@@ -754,12 +754,29 @@ gdev_x_clear_window(gx_device_X * xdev)
 }
 
 
-/* Clean up the instance after making a copy. */
+/* (External procedures are declared in gdevx.h.) */
 int
 gdev_x_initialize(gx_device *dev)
 {
     gx_device_X *xdev = (gx_device_X *) dev;
 
+    set_dev_proc(dev, open_device, x_open);
+    set_dev_proc(dev, get_initial_matrix, x_get_initial_matrix);
+    set_dev_proc(dev, sync_output, x_sync);
+    set_dev_proc(dev, output_page, x_output_page);
+    set_dev_proc(dev, close_device, x_close);
+    set_dev_proc(dev, map_rgb_color, gdev_x_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_x_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, x_fill_rectangle);
+    set_dev_proc(dev, copy_mono, x_copy_mono);
+    set_dev_proc(dev, copy_color, x_copy_color);
+    set_dev_proc(dev, get_params, gdev_x_get_params);
+    set_dev_proc(dev, put_params, gdev_x_put_params);
+    set_dev_proc(dev, get_page_device, x_get_page_device);
+    set_dev_proc(dev, strip_tile_rectangle, x_strip_tile_rectangle);
+    set_dev_proc(dev, get_bits_rectangle, x_get_bits_rectangle);
+    set_dev_proc(dev, fillpage, x_fillpage);
+
     /* Mark the new instance as closed. */
     xdev->is_open = false;
 
diff --git a/devices/vector/gdevdocxw.c b/devices/vector/gdevdocxw.c
index cc0590602..ec6c34d99 100644
--- a/devices/vector/gdevdocxw.c
+++ b/devices/vector/gdevdocxw.c
@@ -144,6 +144,26 @@ typedef struct {
 
 private_st_textw_text_enum();
 
+static int
+docxwrite_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, docxwrite_open_device);
+    set_dev_proc(dev, output_page, docxwrite_output_page);
+    set_dev_proc(dev, close_device, docxwrite_close_device);
+    set_dev_proc(dev, fill_rectangle, docxwrite_fill_rectangle);
+    set_dev_proc(dev, get_params, docxwrite_get_params);
+    set_dev_proc(dev, put_params, docxwrite_put_params);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, fill_path, docxwrite_fill_path);
+    set_dev_proc(dev, stroke_path, docxwrite_stroke_path);
+    set_dev_proc(dev, strip_copy_rop, docxwrite_strip_copy_rop);
+    set_dev_proc(dev, create_compositor, gx_null_create_compositor);
+    set_dev_proc(dev, text_begin, docxwrite_text_begin);
+    set_dev_proc(dev, dev_spec_op, docxwrite_dev_spec_op);
+
+    return 0;
+}
+
 const gx_device_docxwrite_t gs_docxwrite_device =
 {
     /* Define the device as 8-bit gray scale to avoid computing halftones. */
@@ -152,78 +172,7 @@ const gx_device_docxwrite_t gs_docxwrite_device =
                         DEFAULT_HEIGHT_10THS * Y_DPI / 10,
                         X_DPI, Y_DPI,
                         1, 8, 255, 0, 256, 1),
-    {docxwrite_open_device,
-     NULL, /*gx_upright_get_initial_matrix,*/
-     NULL, /*gx_default_sync_output,*/
-     docxwrite_output_page,
-     docxwrite_close_device,
-     NULL, /*gx_default_gray_map_rgb_color,*/
-     NULL, /*gx_default_gray_map_color_rgb,*/
-     docxwrite_fill_rectangle,               /* Can't be NULL and there is no gx_default_fill_rectangle! */
-     NULL, /*gx_default_tile_rectangle,*/
-     NULL, /*gx_default_copy_mono,*/
-     NULL, /*gx_default_copy_color,*/
-     NULL, /*gx_default_draw_line,*/
-     NULL, /*gx_default_get_bits,*/
-     docxwrite_get_params,
-     docxwrite_put_params,
-     NULL, /*gx_default_map_cmyk_color,*/
-     NULL, /*gx_default_get_xfont_procs,*/
-     NULL, /*gx_default_get_xfont_device,*/
-     NULL, /*gx_default_map_rgb_alpha_color,*/
-     gx_page_device_get_page_device, /*gx_page_device_get_page_device,*/
-     NULL,			/* get_alpha_bits */
-     NULL, /*gx_default_copy_alpha,*/
-     NULL,			/* get_band */
-     NULL,			/* copy_rop */
-     docxwrite_fill_path,
-     docxwrite_stroke_path,
-     NULL, /*gx_default_fill_mask,*/
-     NULL, /*gx_default_fill_trapezoid,*/
-     NULL, /*gx_default_fill_parallelogram,*/
-     NULL, /*gx_default_fill_triangle,*/
-     NULL, /*gx_default_draw_thin_line,*/
-     NULL,                      /* begin image */
-     NULL,			/* image_data */
-     NULL,			/* end_image */
-     NULL, /*gx_default_strip_tile_rectangle,*/
-     docxwrite_strip_copy_rop,
-     NULL,			/* get_clipping_box */
-     NULL, /* docxwrite_begin_typed_image */
-     NULL,			/* get_bits_rectangle */
-     NULL, /*gx_default_map_color_rgb_alpha,*/
-     gx_null_create_compositor,
-     NULL,			/* get_hardware_params */
-     docxwrite_text_begin,
-     NULL,			/* initialize */
-     NULL,			/* begin_transparency_group */
-     NULL,			/* end_transparency_group */
-     NULL,			/* begin_transparency_mask */
-     NULL,			/* end_transparency_mask */
-     NULL,			/* discard_transparency_layer */
-     NULL,			/* get_color_mapping_procs */
-     NULL,			/* get_color_comp_index */
-     NULL,			/* encode_color */
-     NULL,			/* decode_color */
-     NULL,                      /* pattern manager */
-     NULL,                      /* fill_rectangle_hl_color */
-     NULL,                      /* include_color_space */
-     NULL,                      /* fill_linear_color_scanline */
-     NULL,                      /* fill_linear_color_trapezoid */
-     NULL,                      /* fill_linear_color_triangle */
-     NULL,                      /* update_spot_equivalent_colors */
-     NULL,                      /* ret_devn_params */
-     NULL,                      /* fillpage */
-     NULL,                      /* push_transparency_state */
-     NULL,                      /* pop_transparency_state */
-     NULL,                      /* put_image */
-     docxwrite_dev_spec_op,      /* dev_spec_op */
-     NULL,                      /* copy_planes */
-     NULL,                      /* get_profile */
-     NULL,                      /* set_graphics_type_tag */
-     NULL,                      /* strip_copy_rop2 */
-     NULL                       /* strip_tile_rect_devn */
-    },
+    devprocs_initialize(docxwrite_initialize),
     { 0 },			/* Page Data */
     0,				/* Output FILE * */
     0,				/* TextFormat */
diff --git a/devices/vector/gdevpdf.c b/devices/vector/gdevpdf.c
index 116a9ed82..736162504 100644
--- a/devices/vector/gdevpdf.c
+++ b/devices/vector/gdevpdf.c
@@ -220,6 +220,43 @@ static dev_proc_close_device(pdf_close);
 
 /* ---------------- Device prototype ---------------- */
 
+static int
+pdfwrite_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, pdf_open);
+    set_dev_proc(dev, get_initial_matrix, gx_upright_get_initial_matrix);
+    set_dev_proc(dev, output_page, pdf_output_page);
+    set_dev_proc(dev, close_device, pdf_close);
+    set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gx_default_rgb_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, gdev_pdf_fill_rectangle);
+    set_dev_proc(dev, copy_mono, gdev_pdf_copy_mono);
+    set_dev_proc(dev, copy_color, gdev_pdf_copy_color);
+    set_dev_proc(dev, get_bits, psdf_get_bits);
+    set_dev_proc(dev, get_params, gdev_pdf_get_params);
+    set_dev_proc(dev, put_params, gdev_pdf_put_params);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, fill_path, gdev_pdf_fill_path);
+    set_dev_proc(dev, stroke_path, gdev_pdf_stroke_path);
+    set_dev_proc(dev, fill_mask, gdev_pdf_fill_mask);
+    set_dev_proc(dev, strip_tile_rectangle, gdev_pdf_strip_tile_rectangle);
+    set_dev_proc(dev, begin_typed_image, gdev_pdf_begin_typed_image);
+    set_dev_proc(dev, get_bits_rectangle, psdf_get_bits_rectangle);
+    set_dev_proc(dev, create_compositor, gdev_pdf_create_compositor);
+    set_dev_proc(dev, text_begin, gdev_pdf_text_begin);
+    set_dev_proc(dev, begin_transparency_group, gdev_pdf_begin_transparency_group);
+    set_dev_proc(dev, end_transparency_group, gdev_pdf_end_transparency_group);
+    set_dev_proc(dev, begin_transparency_mask ,gdev_pdf_begin_transparency_mask);
+    set_dev_proc(dev, end_transparency_mask, gdev_pdf_end_transparency_mask);
+    set_dev_proc(dev, fill_rectangle_hl_color, gdev_pdf_fill_rectangle_hl_color);
+    set_dev_proc(dev, include_color_space, gdev_pdf_include_color_space);
+    set_dev_proc(dev, fillpage, gdev_pdf_fillpage);
+    set_dev_proc(dev, dev_spec_op, gdev_pdf_dev_spec_op);
+    set_dev_proc(dev, fill_stroke_path, gdev_pdf_fill_stroke_path);
+
+    return 0;
+}
+
 #define PDF_DEVICE_NAME "pdfwrite"
 #define PDF_DEVICE_IDENT gs_pdfwrite_device
 #define PDF_DEVICE_MaxInlineImageSize 4000
diff --git a/devices/vector/gdevpdfb.h b/devices/vector/gdevpdfb.h
index d218e104b..b3039a7e8 100644
--- a/devices/vector/gdevpdfb.h
+++ b/devices/vector/gdevpdfb.h
@@ -33,82 +33,7 @@ const gx_device_pdf PDF_DEVICE_IDENT =
                           DEFAULT_HEIGHT_10THS * Y_DPI / 10,
                           X_DPI, Y_DPI,
                           3, 24, 255, 255, 256, 256),
- {pdf_open,
-  gx_upright_get_initial_matrix,
-  NULL,				/* sync_output */
-  pdf_output_page,
-  pdf_close,
-  gx_default_rgb_map_rgb_color,
-  gx_default_rgb_map_color_rgb,
-  gdev_pdf_fill_rectangle,
-  NULL,				/* tile_rectangle */
-  gdev_pdf_copy_mono,
-  gdev_pdf_copy_color,
-  NULL,				/* draw_line */
-  psdf_get_bits,		/* get_bits */
-  gdev_pdf_get_params,
-  gdev_pdf_put_params,
-  NULL,				/* map_cmyk_color */
-  NULL,				/* get_xfont_procs */
-  NULL,				/* get_xfont_device */
-  NULL,				/* map_rgb_alpha_color */
-  gx_page_device_get_page_device,
-  NULL,				/* get_alpha_bits */
-  NULL,				/* copy_alpha */
-  NULL,				/* get_band */
-  NULL,				/* copy_rop */
-  gdev_pdf_fill_path,
-  gdev_pdf_stroke_path,
-  gdev_pdf_fill_mask,
-  NULL,				/* fill_trapezoid */
-  NULL,				/* fill_parallelogram */
-  NULL,				/* fill_triangle */
-  NULL,				/* draw_thin_line */
-  NULL,				/* begin_image */
-  NULL,				/* image_data */
-  NULL,				/* end_image */
-  gdev_pdf_strip_tile_rectangle,
-  NULL,				/* strip_copy_rop */
-  NULL,				/* get_clipping_box */
-  gdev_pdf_begin_typed_image,
-  psdf_get_bits_rectangle,	/* get_bits_rectangle */
-  NULL,				/* map_color_rgb_alpha */
-  gdev_pdf_create_compositor,	/* create_compositor */
-  NULL,				/* get_hardware_params */
-  gdev_pdf_text_begin,
-  NULL,				/* initialize */
-  gdev_pdf_begin_transparency_group,	/* begin_transparency_group */
-  gdev_pdf_end_transparency_group,	/* end_transparency_group */
-  gdev_pdf_begin_transparency_mask,	/* begin_transparency_mask */
-  gdev_pdf_end_transparency_mask,	/* end_transparency_mask */
-  NULL,	            /* discard_transparency_layer */
-  NULL,				/* get_color_mapping_procs */
-  NULL,				/* get_color_comp_index */
-  NULL,				/* encode_color */
-  NULL,				/* decode_color */
-  NULL, 			/* pattern_manage */
-  gdev_pdf_fill_rectangle_hl_color, 	/* fill_rectangle_hl_color */
-  gdev_pdf_include_color_space, 	/* include_color_space */
-  NULL,				/* fill_linear_color_scanline */
-  NULL,				/* fill_linear_color_trapezoid */
-  NULL,				/* fill_linear_color_triangle */
-  NULL,				/* update_spot_equivalent_colors */
-  NULL,				/* ret_devn_params */
-  gdev_pdf_fillpage,		/* fillpage */
-  NULL,				/* push_transparency_state */
-  NULL,				/* pop_transparency_state */
-  NULL,				/* put_image */
-  gdev_pdf_dev_spec_op,		/* dev_spec_op */
-  NULL,             /* copy_planes */
-  NULL,             /* get_profile */
-  NULL,             /* set_graphics_type_tag */
-  NULL,             /* strip_copy_rop2 */
-  NULL,             /* strip_tile_rect_devn */
-  NULL,             /* copy_alpha_hl_color */
-  NULL,             /* process_page */
-  NULL,             /* transform_pixel_region */
-  gdev_pdf_fill_stroke_path /* fill_stroke_path */
- },
+ devprocs_initialize(pdfwrite_initialize),
  psdf_initial_values(PSDF_VERSION_INITIAL, 0 /*false */ ),  /* (!ASCII85EncodePages) */
  0,                     /* pdf_font_dir */
  PDF_FOR_OPDFREAD,		/* is_ps2write */
diff --git a/devices/vector/gdevpx.c b/devices/vector/gdevpx.c
index 2002219d0..1b34c42fb 100644
--- a/devices/vector/gdevpx.c
+++ b/devices/vector/gdevpx.c
@@ -146,56 +146,58 @@ static dev_proc_put_params(pclxl_put_params);
 static dev_proc_begin_image(pclxl_begin_image);
 static dev_proc_strip_copy_rop(pclxl_strip_copy_rop);
 
-#define pclxl_device_procs(map_rgb_color, map_color_rgb)\
-{\
-        pclxl_open_device,\
-        NULL,			/* get_initial_matrix */\
-        NULL,			/* sync_output */\
-        pclxl_output_page,\
-        pclxl_close_device,\
-        map_rgb_color,		/* differs */\
-        map_color_rgb,		/* differs */\
-        gdev_vector_fill_rectangle,\
-        NULL,			/* tile_rectangle */\
-        pclxl_copy_mono,\
-        pclxl_copy_color,\
-        NULL,			/* draw_line */\
-        NULL,			/* get_bits */\
-        pclxl_get_params,\
-        pclxl_put_params,\
-        NULL,			/* map_cmyk_color */\
-        NULL,			/* get_xfont_procs */\
-        NULL,			/* get_xfont_device */\
-        NULL,			/* map_rgb_alpha_color */\
-        gx_page_device_get_page_device,\
-        NULL,			/* get_alpha_bits */\
-        NULL,			/* copy_alpha */\
-        NULL,			/* get_band */\
-        NULL,			/* copy_rop */\
-        gdev_vector_fill_path,\
-        gdev_vector_stroke_path,\
-        pclxl_fill_mask,\
-        gdev_vector_fill_trapezoid,\
-        gdev_vector_fill_parallelogram,\
-        gdev_vector_fill_triangle,\
-        NULL /****** WRONG ******/,	/* draw_thin_line */\
-        pclxl_begin_image,\
-        NULL,			/* image_data */\
-        NULL,			/* end_image */\
-        NULL,			/* strip_tile_rectangle */\
-        pclxl_strip_copy_rop\
+static int
+pclxl_initialize(gx_device *dev,
+                 dev_proc_map_rgb_color(map_rgb_color),
+                 dev_proc_map_color_rgb(map_color_rgb))
+{
+    set_dev_proc(dev, open_device, pclxl_open_device);
+    set_dev_proc(dev, output_page, pclxl_output_page);
+    set_dev_proc(dev, close_device, pclxl_close_device);
+    set_dev_proc(dev, map_rgb_color, map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, gdev_vector_fill_rectangle);
+    set_dev_proc(dev, copy_mono, pclxl_copy_mono);
+    set_dev_proc(dev, copy_color, pclxl_copy_color);
+    set_dev_proc(dev, get_params, pclxl_get_params);
+    set_dev_proc(dev, put_params, pclxl_put_params);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, fill_path, gdev_vector_fill_path);
+    set_dev_proc(dev, stroke_path, gdev_vector_stroke_path);
+    set_dev_proc(dev, fill_mask, pclxl_fill_mask);
+    set_dev_proc(dev, fill_trapezoid, gdev_vector_fill_trapezoid);
+    set_dev_proc(dev, fill_parallelogram, gdev_vector_fill_parallelogram);
+    set_dev_proc(dev, fill_triangle, gdev_vector_fill_triangle);
+    set_dev_proc(dev, begin_image, pclxl_begin_image);
+    set_dev_proc(dev, strip_copy_rop, pclxl_strip_copy_rop);
+
+    return 0;
+}
+
+static int
+pxlmono_initialize(gx_device *dev)
+{
+    return pclxl_initialize(dev,
+                            gx_default_gray_map_rgb_color,
+                            gx_default_gray_map_color_rgb);
+}
+
+static int
+pxlcolor_initialize(gx_device *dev)
+{
+    return pclxl_initialize(dev,
+                            gx_default_rgb_map_rgb_color,
+                            gx_default_rgb_map_color_rgb);
 }
 
 const gx_device_pclxl gs_pxlmono_device = {
     pclxl_device_body("pxlmono", 8),
-    pclxl_device_procs(gx_default_gray_map_rgb_color,
-                       gx_default_gray_map_color_rgb)
+    devprocs_initialize(pxlmono_initialize)
 };
 
 const gx_device_pclxl gs_pxlcolor_device = {
     pclxl_device_body("pxlcolor", 24),
-    pclxl_device_procs(gx_default_rgb_map_rgb_color,
-                       gx_default_rgb_map_color_rgb)
+    devprocs_initialize(pxlcolor_initialize)
 };
 
 /* ---------------- Other utilities ---------------- */
diff --git a/devices/vector/gdevtxtw.c b/devices/vector/gdevtxtw.c
index fe8468334..8a0ec55c3 100644
--- a/devices/vector/gdevtxtw.c
+++ b/devices/vector/gdevtxtw.c
@@ -145,6 +145,26 @@ typedef struct textw_text_enum_s {
 
 private_st_textw_text_enum();
 
+static int
+txtwrite_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, txtwrite_open_device);
+    set_dev_proc(dev, output_page, txtwrite_output_page);
+    set_dev_proc(dev, close_device, txtwrite_close_device);
+    set_dev_proc(dev, fill_rectangle, txtwrite_fill_rectangle);
+    set_dev_proc(dev, get_params, txtwrite_get_params);
+    set_dev_proc(dev, put_params, txtwrite_put_params);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, fill_path, txtwrite_fill_path);
+    set_dev_proc(dev, stroke_path, txtwrite_stroke_path);
+    set_dev_proc(dev, strip_copy_rop, txtwrite_strip_copy_rop);
+    set_dev_proc(dev, create_compositor, gx_null_create_compositor);
+    set_dev_proc(dev, text_begin, txtwrite_text_begin);
+    set_dev_proc(dev, dev_spec_op, txtwrite_dev_spec_op);
+
+    return 0;
+}
+
 const gx_device_txtwrite_t gs_txtwrite_device =
 {
     /* Define the device as 8-bit gray scale to avoid computing halftones. */
@@ -153,78 +173,7 @@ const gx_device_txtwrite_t gs_txtwrite_device =
                         DEFAULT_HEIGHT_10THS * Y_DPI / 10,
                         X_DPI, Y_DPI,
                         1, 8, 255, 0, 256, 1),
-    {txtwrite_open_device,
-     NULL, /*gx_upright_get_initial_matrix,*/
-     NULL, /*gx_default_sync_output,*/
-     txtwrite_output_page,
-     txtwrite_close_device,
-     NULL, /*gx_default_gray_map_rgb_color,*/
-     NULL, /*gx_default_gray_map_color_rgb,*/
-     txtwrite_fill_rectangle,               /* Can't be NULL and there is no gx_default_fill_rectangle! */
-     NULL, /*gx_default_tile_rectangle,*/
-     NULL, /*gx_default_copy_mono,*/
-     NULL, /*gx_default_copy_color,*/
-     NULL, /*gx_default_draw_line,*/
-     NULL, /*gx_default_get_bits,*/
-     txtwrite_get_params,
-     txtwrite_put_params,
-     NULL, /*gx_default_map_cmyk_color,*/
-     NULL, /*gx_default_get_xfont_procs,*/
-     NULL, /*gx_default_get_xfont_device,*/
-     NULL, /*gx_default_map_rgb_alpha_color,*/
-     gx_page_device_get_page_device, /*gx_page_device_get_page_device,*/
-     NULL,			/* get_alpha_bits */
-     NULL, /*gx_default_copy_alpha,*/
-     NULL,			/* get_band */
-     NULL,			/* copy_rop */
-     txtwrite_fill_path,
-     txtwrite_stroke_path,
-     NULL, /*gx_default_fill_mask,*/
-     NULL, /*gx_default_fill_trapezoid,*/
-     NULL, /*gx_default_fill_parallelogram,*/
-     NULL, /*gx_default_fill_triangle,*/
-     NULL, /*gx_default_draw_thin_line,*/
-     NULL,                      /* begin image */
-     NULL,			/* image_data */
-     NULL,			/* end_image */
-     NULL, /*gx_default_strip_tile_rectangle,*/
-     txtwrite_strip_copy_rop,
-     NULL,			/* get_clipping_box */
-     NULL, /* txtwrite_begin_typed_image */
-     NULL,			/* get_bits_rectangle */
-     NULL, /*gx_default_map_color_rgb_alpha,*/
-     gx_null_create_compositor,
-     NULL,			/* get_hardware_params */
-     txtwrite_text_begin,
-     NULL,			/* initialize */
-     NULL,			/* begin_transparency_group */
-     NULL,			/* end_transparency_group */
-     NULL,			/* begin_transparency_mask */
-     NULL,			/* end_transparency_mask */
-     NULL,			/* discard_transparency_layer */
-     NULL,			/* get_color_mapping_procs */
-     NULL,			/* get_color_comp_index */
-     NULL,			/* encode_color */
-     NULL,			/* decode_color */
-     NULL,                      /* pattern manager */
-     NULL,                      /* fill_rectangle_hl_color */
-     NULL,                      /* include_color_space */
-     NULL,                      /* fill_linear_color_scanline */
-     NULL,                      /* fill_linear_color_trapezoid */
-     NULL,                      /* fill_linear_color_triangle */
-     NULL,                      /* update_spot_equivalent_colors */
-     NULL,                      /* ret_devn_params */
-     NULL,                      /* fillpage */
-     NULL,                      /* push_transparency_state */
-     NULL,                      /* pop_transparency_state */
-     NULL,                      /* put_image */
-     txtwrite_dev_spec_op,      /* dev_spec_op */
-     NULL,                      /* copy_planes */
-     NULL,                      /* get_profile */
-     NULL,                      /* set_graphics_type_tag */
-     NULL,                      /* strip_copy_rop2 */
-     NULL                       /* strip_tile_rect_devn */
-    },
+    devprocs_initialize(txtwrite_initialize),
     { 0 },			/* Page Data */
     { 0 },			/* Output Filename */
     0,				/* Output FILE * */
diff --git a/devices/vector/gdevxps.c b/devices/vector/gdevxps.c
index e8afd0d3a..d4564ac3c 100644
--- a/devices/vector/gdevxps.c
+++ b/devices/vector/gdevxps.c
@@ -217,60 +217,34 @@ static dev_proc_stroke_path(gdev_xps_stroke_path);
 static dev_proc_initialize(xps_initialize);
 static dev_proc_begin_image(xps_begin_image);
 
-#define xps_device_procs \
-{ \
-        xps_open_device, \
-        NULL,                   /* get_initial_matrix */\
-        NULL,                   /* sync_output */\
-        xps_output_page,\
-        xps_close_device,\
-        gx_default_rgb_map_rgb_color,\
-        gx_default_rgb_map_color_rgb,\
-        gdev_vector_fill_rectangle,\
-        NULL,                   /* tile_rectangle */\
-        NULL,                   /* copy_mono */\
-        NULL,                   /* copy_color */\
-        NULL,                   /* draw_line */\
-        NULL,                   /* get_bits */\
-        xps_get_params,\
-        xps_put_params,\
-        NULL,                   /* map_cmyk_color */\
-        NULL,                   /* get_xfont_procs */\
-        NULL,                   /* get_xfont_device */\
-        NULL,                   /* map_rgb_alpha_color */\
-        gx_page_device_get_page_device,\
-        NULL,                   /* get_alpha_bits */\
-        NULL,                   /* copy_alpha */\
-        NULL,                   /* get_band */\
-        NULL,                   /* copy_rop */\
-        gdev_xps_fill_path,\
-        gdev_xps_stroke_path,\
-        NULL,                   /* fill_mask */\
-        NULL,                   /* gdev_vector_fill_trapezoid, */     \
-        NULL,                   /* gdev_vector_fill_parallelogram */        \
-        NULL,                   /* gdev_vector_fill_triangle */           \
-        NULL,                   /* draw_thin_line */\
-        xps_begin_image,        /* begin_image */   \
-        NULL,                   /* image_data */\
-        NULL,                   /* end_image */\
-        NULL,                   /* strip_tile_rectangle */\
-        NULL,                    /* strip_copy_rop */\
-        NULL,                   /* get_clipping_box */\
-        NULL,                   /* begin_typed_image */\
-        NULL,                   /* get_bits_rectangle */\
-        NULL,                   /* map_color_rgb_alpha */\
-        NULL,                   /* create_compositor */\
-        NULL,                   /* get_hardware_params */\
-        NULL,                   /* text_begin */\
-        xps_initialize,\
-        NULL,\
-}
-
 const gx_device_xps gs_xpswrite_device = {
     xps_device_body("xpswrite", 24),
-    xps_device_procs
+    devprocs_initialize(xps_initialize)
 };
 
+static int
+xps_initialize(gx_device *dev)
+{
+    gx_device_xps *xps = (gx_device_xps*)dev;
+
+    set_dev_proc(dev, open_device, xps_open_device);
+    set_dev_proc(dev, output_page, xps_output_page);
+    set_dev_proc(dev, close_device, xps_close_device);
+    set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gx_default_rgb_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, gdev_vector_fill_rectangle);
+    set_dev_proc(dev, get_params, xps_get_params);
+    set_dev_proc(dev, put_params, xps_put_params);
+    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);
+    set_dev_proc(dev, fill_path, gdev_xps_fill_path);
+    set_dev_proc(dev, stroke_path, gdev_xps_stroke_path);
+    set_dev_proc(dev, begin_image, xps_begin_image);
+
+    memset(xps->PrinterName, 0x00, MAXPRINTERNAME);
+
+    return 0;
+}
+
 /* Vector device procedures */
 static int
 xps_beginpage(gx_device_vector *vdev);
@@ -1321,14 +1295,6 @@ xps_put_params(gx_device *dev, gs_param_list *plist)
     return code;
 }
 
-static int xps_initialize(gx_device *dev)
-{
-    gx_device_xps *xps = (gx_device_xps*)dev;
-
-    memset(xps->PrinterName, 0x00, MAXPRINTERNAME);
-    return 0;
-}
-
 static int
 set_state_color(gx_device_vector *vdev, const gx_drawing_color *pdc, gx_color_index *color)
 {