Move devices away from static init of procs.

26 files changed, 725 insertions, 468 deletions

diff --git a/contrib/eplaser/gdevescv.c b/contrib/eplaser/gdevescv.c
index 70f76f244..3043130e8 100644
--- a/contrib/eplaser/gdevescv.c
+++ b/contrib/eplaser/gdevescv.c
@@ -118,60 +118,47 @@ gs_public_st_suffix_add0_final(st_device_escv, gx_device_escv,
                                 ESCPAGE_RIGHT_MARGIN_DEFAULT,\
                                 ESCPAGE_TOP_MARGIN_DEFAULT)
 
-#define escv_procs_part1 \
-        escv_open,				/* open_device */\
-        gx_default_get_initial_matrix,		/* get_initial_matrix */\
-        NULL,					/* sync_output */\
-        escv_output_page,			/* output_page */\
-        escv_close				/* close_device */
-
-#define escv_procs_part2 \
-        gdev_vector_fill_rectangle,		/* fill_rectangle */\
-        NULL,					/* tile_rectangle */\
-        escv_copy_mono,				/* dev_t_proc_copy_mono */\
-        escv_copy_color,			/* dev_t_proc_copy_color */\
-        NULL,					/* draw_line */\
-        NULL,					/* get_bits */\
-        escv_get_params,			/* dev_t_proc_get_params */\
-        escv_put_params,			/* dev_t_proc_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,		/* dev_t_proc_get_page_device */\
-        NULL,					/* get_alpha_bits */\
-        NULL,					/* copy_alpha */\
-        NULL,					/* get_band */\
-        NULL,					/* copy_rop */\
-        gdev_vector_fill_path,			/* fill_path */\
-        gdev_vector_stroke_path,		/* stroke_path */\
-        escv_fill_mask,				/* fill_mask */\
-        gdev_vector_fill_trapezoid,		/* fill_trapezoid */\
-        gdev_vector_fill_parallelogram,		/* fill_parallelogram */\
-        gdev_vector_fill_triangle,		/* fill_triangle */\
-        NULL,	/****** WRONG ******/		/* draw_thin_line */\
-        escv_begin_image,			/* begin_image */\
-        NULL,					/* image_data */\
-        NULL,					/* end_image */\
-        NULL,					/* strip_tile_rectangle */\
-        NULL					/******strip_copy_rop******/
+static int
+esc_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, escv_open);
+    set_dev_proc(dev, output_page, escv_output_page);
+    set_dev_proc(dev, close_device, escv_close);
+    set_dev_proc(dev, fill_rectangle, gdev_vector_fill_rectangle);
+    set_dev_proc(dev, copy_mono, escv_copy_mono);
+    set_dev_proc(dev, copy_color, escv_copy_color);
+    set_dev_proc(dev, get_params, escv_get_params);
+    set_dev_proc(dev, put_params, escv_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, escv_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, escv_begin_image);
+
+    return 0;
+}
 
 /* for ESC/Page-Color */
-#define escv_procs	\
-{\
-        escv_procs_part1,\
-        gx_default_rgb_map_rgb_color, /* map_rgb_color */\
-        gx_default_rgb_map_color_rgb, /* map_color_rgb */\
-        escv_procs_part2\
+static int
+escv_initialize(gx_device *dev)
+{
+    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);
+
+    return esc_initialize(dev);
 }
 
 /* for ESC/Page (Monochrome) */
-#define esmv_procs	\
-{\
-        escv_procs_part1,\
-        gx_default_gray_map_rgb_color, /* map_rgb_color */\
-        gx_default_gray_map_color_rgb, /* map_color_rgb */\
-        escv_procs_part2\
+static int
+esmv_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, map_rgb_color, gx_default_gray_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gx_default_gray_map_color_rgb);
+
+    return esc_initialize(dev);
 }
 
 #define	escv_init_code_common \
@@ -245,60 +232,60 @@ gs_public_st_suffix_add0_final(st_device_escv, gx_device_escv,
         escv_init_code_common
 
 /* for ESC/Page (Monochrome) */
-gx_device_escv far_data gs_epl2050_device ={esmv_device_body("epl2050"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl2050p_device={esmv_device_body("epl2050p"),esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl2120_device ={esmv_device_body("epl2120"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl2500_device ={esmv_device_body("epl2500"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl2750_device ={esmv_device_body("epl2750"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl5800_device ={esmv_device_body("epl5800"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl5900_device ={esmv_device_body("epl5900"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl6100_device ={esmv_device_body("epl6100"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_epl6200_device ={esmv_device_body("epl6200"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp1800_device  ={esmv_device_body("lp1800"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp1900_device  ={esmv_device_body("lp1900"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp2200_device  ={esmv_device_body("lp2200"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp2400_device  ={esmv_device_body("lp2400"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp2500_device  ={esmv_device_body("lp2500"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp7500_device  ={esmv_device_body("lp7500"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp7700_device  ={esmv_device_body("lp7700"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp7900_device  ={esmv_device_body("lp7900"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp8100_device  ={esmv_device_body("lp8100"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp8300f_device ={esmv_device_body("lp8300f"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp8400f_device ={esmv_device_body("lp8400f"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp8600_device  ={esmv_device_body("lp8600"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp8600f_device ={esmv_device_body("lp8600f"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp8700_device  ={esmv_device_body("lp8700"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp8900_device  ={esmv_device_body("lp8900"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp9000b_device ={esmv_device_body("lp9000b"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp9100_device  ={esmv_device_body("lp9100"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp9200b_device ={esmv_device_body("lp9200b"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp9300_device  ={esmv_device_body("lp9300"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp9400_device  ={esmv_device_body("lp9400"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp9600_device  ={esmv_device_body("lp9600"),  esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lp9600s_device ={esmv_device_body("lp9600s"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_lps4500_device ={esmv_device_body("lps4500"), esmv_procs, esmv_init_code};
-gx_device_escv far_data gs_eplmono_device ={esmv_device_body(ESCPAGE_DEVICENAME_MONO), esmv_procs, esmv_init_code};
+gx_device_escv far_data gs_epl2050_device ={esmv_device_body("epl2050"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl2050p_device={esmv_device_body("epl2050p"),devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl2120_device ={esmv_device_body("epl2120"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl2500_device ={esmv_device_body("epl2500"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl2750_device ={esmv_device_body("epl2750"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl5800_device ={esmv_device_body("epl5800"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl5900_device ={esmv_device_body("epl5900"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl6100_device ={esmv_device_body("epl6100"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_epl6200_device ={esmv_device_body("epl6200"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp1800_device  ={esmv_device_body("lp1800"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp1900_device  ={esmv_device_body("lp1900"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp2200_device  ={esmv_device_body("lp2200"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp2400_device  ={esmv_device_body("lp2400"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp2500_device  ={esmv_device_body("lp2500"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp7500_device  ={esmv_device_body("lp7500"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp7700_device  ={esmv_device_body("lp7700"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp7900_device  ={esmv_device_body("lp7900"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp8100_device  ={esmv_device_body("lp8100"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp8300f_device ={esmv_device_body("lp8300f"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp8400f_device ={esmv_device_body("lp8400f"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp8600_device  ={esmv_device_body("lp8600"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp8600f_device ={esmv_device_body("lp8600f"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp8700_device  ={esmv_device_body("lp8700"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp8900_device  ={esmv_device_body("lp8900"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp9000b_device ={esmv_device_body("lp9000b"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp9100_device  ={esmv_device_body("lp9100"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp9200b_device ={esmv_device_body("lp9200b"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp9300_device  ={esmv_device_body("lp9300"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp9400_device  ={esmv_device_body("lp9400"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp9600_device  ={esmv_device_body("lp9600"),  devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lp9600s_device ={esmv_device_body("lp9600s"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_lps4500_device ={esmv_device_body("lps4500"), devprocs_initialize(esmv_initialize), esmv_init_code};
+gx_device_escv far_data gs_eplmono_device ={esmv_device_body(ESCPAGE_DEVICENAME_MONO), devprocs_initialize(esmv_initialize), esmv_init_code};
 
 /* for ESC/Page-Color */
-gx_device_escv far_data gs_alc1900_device ={escv_device_body("alc1900"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_alc2000_device ={escv_device_body("alc2000"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_alc4000_device ={escv_device_body("alc4000"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_alc4100_device ={escv_device_body("alc4100"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_alc8500_device ={escv_device_body("alc8500"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_alc8600_device ={escv_device_body("alc8600"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_alc9100_device ={escv_device_body("alc9100"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp3000c_device ={escv_device_body("lp3000c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp8000c_device ={escv_device_body("lp8000c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp8200c_device ={escv_device_body("lp8200c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp8300c_device ={escv_device_body("lp8300c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp8500c_device ={escv_device_body("lp8500c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp8800c_device ={escv_device_body("lp8800c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp9000c_device ={escv_device_body("lp9000c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp9200c_device ={escv_device_body("lp9200c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp9500c_device ={escv_device_body("lp9500c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lp9800c_device ={escv_device_body("lp9800c"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_lps6500_device ={escv_device_body("lps6500"), escv_procs, escv_init_code};
-gx_device_escv far_data gs_eplcolor_device ={escv_device_body(ESCPAGE_DEVICENAME_COLOR), escv_procs, escv_init_code};
+gx_device_escv far_data gs_alc1900_device ={escv_device_body("alc1900"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_alc2000_device ={escv_device_body("alc2000"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_alc4000_device ={escv_device_body("alc4000"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_alc4100_device ={escv_device_body("alc4100"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_alc8500_device ={escv_device_body("alc8500"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_alc8600_device ={escv_device_body("alc8600"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_alc9100_device ={escv_device_body("alc9100"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp3000c_device ={escv_device_body("lp3000c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp8000c_device ={escv_device_body("lp8000c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp8200c_device ={escv_device_body("lp8200c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp8300c_device ={escv_device_body("lp8300c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp8500c_device ={escv_device_body("lp8500c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp8800c_device ={escv_device_body("lp8800c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp9000c_device ={escv_device_body("lp9000c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp9200c_device ={escv_device_body("lp9200c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp9500c_device ={escv_device_body("lp9500c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lp9800c_device ={escv_device_body("lp9800c"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_lps6500_device ={escv_device_body("lps6500"), devprocs_initialize(escv_initialize), escv_init_code};
+gx_device_escv far_data gs_eplcolor_device ={escv_device_body(ESCPAGE_DEVICENAME_COLOR), devprocs_initialize(escv_initialize), escv_init_code};
 
 /* Vector device implementation */
 /* Page management */
diff --git a/contrib/gdevbjc_.c b/contrib/gdevbjc_.c
index a661ba0d1..e0ab67ce0 100644
--- a/contrib/gdevbjc_.c
+++ b/contrib/gdevbjc_.c
@@ -211,10 +211,23 @@ static media_t media_codes[] = {
 /* ------------------------- 1 bit Monochrome ---------------------------- */
 /***************************************************************************/
 
+static int
+bjcmono_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, gdev_bjc_get_params);
+    set_dev_proc(dev, put_params, gdev_bjc_put_params);
+
+    return 0;
+}
+
+
 static const gx_device_procs bjcmono_procs =
-prn_color_params_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
-                 NULL, NULL,
-                 gdev_bjc_get_params, gdev_bjc_put_params);
+devprocs_initialize(bjcmono_initialize);
 
 const gx_device_bjc_printer gs_bjcmono_device =
 bjc_device(bjcmono_procs, "bjcmono",
@@ -234,10 +247,22 @@ bjc_device(bjcmono_procs, "bjcmono",
 /* -------------------------- 8 bit Grayscale ---------------------------- */
 /***************************************************************************/
 
+static int
+bjcgray_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_gray(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, gdev_bjc_get_params);
+    set_dev_proc(dev, put_params, gdev_bjc_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs bjcgray_procs =
-prn_color_params_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
-                 gx_default_gray_map_rgb_color, gx_default_gray_map_color_rgb,
-                 gdev_bjc_get_params, gdev_bjc_put_params);
+devprocs_initialize(bjcgray_initialize);
 
 const gx_device_bjc_printer gs_bjcgray_device =
 bjc_device(bjcgray_procs, "bjcgray",
@@ -257,10 +282,22 @@ bjc_device(bjcgray_procs, "bjcgray",
 /* --------------------------- 3 bit CMYK Color -------------------------- */
 /***************************************************************************/
 
+static int
+bjccmyk_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk1(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, gdev_bjc_get_params);
+    set_dev_proc(dev, put_params, gdev_bjc_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs bjc_cmykcolor_procs =
-bjc_cmyk_param_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
-                     cmyk_1bit_map_color_rgb, cmyk_1bit_map_cmyk_color,
-                     gdev_bjc_get_params, gdev_bjc_put_params);
+devprocs_initialize(bjccmyk_initialize);
 
 const gx_device_bjc_printer gs_bjccmyk_device =
 bjc_device(bjc_cmykcolor_procs, "bjccmyk",
@@ -280,10 +317,22 @@ bjc_device(bjc_cmykcolor_procs, "bjccmyk",
 /* --------------------------- 24 bit TrueColor -------------------------- */
 /***************************************************************************/
 
+static int
+bjc_truecolor_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_cmyk8(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_params, gdev_bjc_get_params);
+    set_dev_proc(dev, put_params, gdev_bjc_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs bjc_truecolor_procs =
-bjc_cmyk_param_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
-                     cmyk_8bit_map_color_rgb, cmyk_8bit_map_cmyk_color,
-                     gdev_bjc_get_params, gdev_bjc_put_params);
+devprocs_initialize(bjc_truecolor_initialize);
 
 const gx_device_bjc_printer gs_bjccolor_device =
 bjc_device(bjc_truecolor_procs, "bjccolor",
diff --git a/contrib/gdevcd8.c b/contrib/gdevcd8.c
index 23532c0f2..f09123027 100644
--- a/contrib/gdevcd8.c
+++ b/contrib/gdevcd8.c
@@ -701,26 +701,6 @@ typedef struct {
     terminate_page\
 }
 
-#define cmyk_colour_procs(proc_colour_open, proc_get_params, proc_put_params, \
-                          map_rgb_color, map_color_rgb, map_cmyk_color)\
-{	proc_colour_open,\
-        gx_default_get_initial_matrix,\
-        gx_default_sync_output,\
-        gdev_prn_output_page,\
-        gdev_prn_close,\
-        map_rgb_color,\
-        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,\
-        map_cmyk_color\
-}
-
 /*  Printer-specific functions.  Most printers are handled by the cdj850_xx()
  *  functions.
  */
@@ -788,30 +768,78 @@ static void
 static void
      cdnj500_terminate_page(gx_device_printer * pdev, gp_file * prn_stream);
 
+static int
+cdj670_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hp_colour_open);
+    set_dev_proc(dev, map_rgb_color, NULL);
+    set_dev_proc(dev, map_color_rgb, gdev_cmyk_map_color_rgb);
+    set_dev_proc(dev, get_params, cdj850_get_params);
+    set_dev_proc(dev, put_params, cdj850_put_params);
+    set_dev_proc(dev, map_cmyk_color, gdev_cmyk_map_cmyk_color);
+
+    return 0;
+}
+
+static int
+cdj1600_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hp_colour_open);
+    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, cdj850_get_params);
+    set_dev_proc(dev, put_params, cdj850_put_params);
+    set_dev_proc(dev, map_cmyk_color, NULL);
+
+    return 0;
+}
+
+static int
+chp2200_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hp_colour_open);
+    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, cdj850_get_params);
+    set_dev_proc(dev, put_params, cdj850_put_params);
+    set_dev_proc(dev, map_cmyk_color, NULL);
+
+    return 0;
+}
+
 static const gx_device_procs cdj670_procs =
-cmyk_colour_procs(hp_colour_open, cdj850_get_params, cdj850_put_params,
-                  NULL, gdev_cmyk_map_color_rgb, gdev_cmyk_map_cmyk_color);
+    devprocs_initialize(cdj670_initialize);
 
 static const gx_device_procs cdj850_procs =
-cmyk_colour_procs(hp_colour_open, cdj850_get_params, cdj850_put_params,
-                  NULL, gdev_cmyk_map_color_rgb, gdev_cmyk_map_cmyk_color);
+    devprocs_initialize(cdj670_initialize);
 
 static const gx_device_procs cdj880_procs =
-cmyk_colour_procs(hp_colour_open, cdj850_get_params, cdj850_put_params,
-                  NULL, gdev_cmyk_map_color_rgb, gdev_cmyk_map_cmyk_color);
+    devprocs_initialize(cdj670_initialize);
 
 static const gx_device_procs cdj890_procs =
-cmyk_colour_procs(hp_colour_open, cdj850_get_params, cdj850_put_params,
-                  NULL, gdev_cmyk_map_color_rgb, gdev_cmyk_map_cmyk_color);
+    devprocs_initialize(cdj670_initialize);
 
 static const gx_device_procs cdj1600_procs =
-cmyk_colour_procs(hp_colour_open, cdj850_get_params, cdj850_put_params,
-                  gdev_pcl_map_rgb_color, gdev_pcl_map_color_rgb, NULL);
+    devprocs_initialize(cdj1600_initialize);
 
 /* HP2200 and DNJ500 is a RGB printer */
 static const gx_device_procs chp2200_procs =
-cmyk_colour_procs(hp_colour_open, cdj850_get_params, cdj850_put_params,
-                  gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb, NULL);
+    devprocs_initialize(chp2200_initialize);
 
 const gx_device_cdj850 gs_cdj670_device =
 cdj_850_device(cdj670_procs, "cdj670", 600, 600, 32, cdj850_print_page, 0,
diff --git a/contrib/gdevdj9.c b/contrib/gdevdj9.c
index efbeaef58..6e18924f0 100644
--- a/contrib/gdevdj9.c
+++ b/contrib/gdevdj9.c
@@ -510,24 +510,23 @@ typedef struct
     terminate_page\
 }
 
-#define cmyk_colour_procs(proc_colour_open, proc_get_params, proc_put_params, \
-                          proc_colour_close, map_rgb_color, map_color_rgb, map_cmyk_color) {\
-        proc_colour_open,\
-        gx_default_get_initial_matrix,\
-        gx_default_sync_output,\
-        gdev_prn_output_page,\
-        proc_colour_close,\
-        map_rgb_color,\
-        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,\
-        map_cmyk_color\
+static int
+cdj970_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hp_colour_open);
+    set_dev_proc(dev, close_device, cdj970_close);
+    set_dev_proc(dev, map_rgb_color, NULL);
+    set_dev_proc(dev, map_color_rgb, gdev_cmyk_map_color_rgb);
+    set_dev_proc(dev, get_params, cdj970_get_params);
+    set_dev_proc(dev, put_params, cdj970_put_params);
+    set_dev_proc(dev, map_cmyk_color, gdev_cmyk_map_cmyk_color);
+
+    return 0;
 }
 
 static void
@@ -544,9 +543,7 @@ static void
 cdj970_terminate_page(gx_device_printer * pdev, gp_file * prn_stream);
 
 static const gx_device_procs cdj970_procs =
-cmyk_colour_procs(hp_colour_open, cdj970_get_params, cdj970_put_params,
-                  cdj970_close, NULL, gdev_cmyk_map_color_rgb,
-                  gdev_cmyk_map_cmyk_color);
+    devprocs_initialize(cdj970_initialize);
 
 const gx_device_cdj970 gs_cdj970_device =
 cdj_970_device(cdj970_procs, "cdj970", 600, 600, 32, cdj970_print_page, 0,
diff --git a/contrib/gdevgdi.c b/contrib/gdevgdi.c
index cdd148baf..7028bec78 100644
--- a/contrib/gdevgdi.c
+++ b/contrib/gdevgdi.c
@@ -94,9 +94,22 @@ static dev_proc_open_device(gdi_open);
 static dev_proc_close_device(gdi_close);
 static dev_proc_print_page(gdi_print_page);
 
+static int
+gdi_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, gdi_open);
+    set_dev_proc(dev, close_device, gdi_close);
+
+    return 0;
+}
+
 static gx_device_procs prn_gdi_procs =
-    prn_params_procs(gdi_open, gdev_prn_output_page, gdi_close,
-                   gdev_prn_get_params, gdev_prn_put_params);
+    devprocs_initialize(gdi_initialize);
 
 gx_device_printer far_data gs_gdi_device =
   prn_device(prn_gdi_procs, "gdi",
diff --git a/contrib/gdevhl12.c b/contrib/gdevhl12.c
index 9f4d617cb..46b4aae0d 100644
--- a/contrib/gdevhl12.c
+++ b/contrib/gdevhl12.c
@@ -159,9 +159,24 @@ static dev_proc_print_page_copies(hl1250_print_page_copies);
 static dev_proc_get_params(hl1250_get_params);
 static dev_proc_put_params(hl1250_put_params);
 
+static int
+hl1250_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, hl1250_open);
+    set_dev_proc(dev, close_device, hl1250_close);
+    set_dev_proc(dev, get_params, hl1250_get_params);
+    set_dev_proc(dev, put_params, hl1250_put_params);
+
+    return 0;
+}
+
 static const gx_device_procs prn_hl1250_procs =
-prn_params_procs(hl1250_open, gdev_prn_output_page, hl1250_close,
-                 hl1250_get_params, hl1250_put_params);
+    devprocs_initialize(hl1250_initialize);
 
 #define hl1250_device_copies(dname, xdpi, ydpi)\
 {   prn_device_std_body_copies(gx_device_hl1250, prn_hl1250_procs,\
diff --git a/contrib/gdevln03.c b/contrib/gdevln03.c
index 88cf8a1f9..29580b112 100644
--- a/contrib/gdevln03.c
+++ b/contrib/gdevln03.c
@@ -48,10 +48,24 @@ static int sixel_print_page(gx_device_printer *pdev, gp_file *prn_stream,
 /* The device descriptor */
 static dev_proc_output_page(sixel_output_page);
 static dev_proc_print_page(ln03_print_page);
+
 /* We have to supply our own procs, since we have to intercept */
 /* output_page so we can open the printer in text mode. */
+static int
+sixel_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, output_page, sixel_output_page);
+
+    return 0;
+}
+
 static gx_device_procs sixel_procs =
-  prn_procs(gdev_prn_open, sixel_output_page, gdev_prn_close);
+  devprocs_initialize(sixel_initialize);
 
 #ifdef A4
 #  define BOTTOM_MARGIN 0.5
diff --git a/contrib/gdevlx32.c b/contrib/gdevlx32.c
index 7cbd2b972..fe2076cb8 100644
--- a/contrib/gdevlx32.c
+++ b/contrib/gdevlx32.c
@@ -257,10 +257,25 @@ static int print_photo_page(pagedata *gendata);
  */
 
 /* Device procedures */
+static int
+lxm3200_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, lxm3200_open);
+    set_dev_proc(dev, map_rgb_color, lxm3200_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, lxm3200_map_color_rgb);
+    set_dev_proc(dev, get_params, lxm3200_get_params);
+    set_dev_proc(dev, put_params, lxm3200_put_params);
+
+    return 0;
+}
+
 static gx_device_procs lxm3200_procs =
-  prn_color_params_procs(lxm3200_open, gdev_prn_output_page, gdev_prn_close,
-          lxm3200_map_rgb_color, lxm3200_map_color_rgb, lxm3200_get_params,
-    lxm3200_put_params);
+  devprocs_initialize(lxm3200_initialize);
 
 /* Define an extension (subclass) of gx_device_printer. */
 struct lxm_device_s
diff --git a/contrib/gdevlx7.c b/contrib/gdevlx7.c
index 37f9697fb..56b232577 100644
--- a/contrib/gdevlx7.c
+++ b/contrib/gdevlx7.c
@@ -107,9 +107,22 @@ static dev_proc_get_params(lxm_get_params);
 static dev_proc_put_params(lxm_put_params);
 
 /* set up dispatch table.  I follow gdevdjet in using gdev_prn_output_page */
+static int
+lxm7000m_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(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 lxm7000m_procs =
-    prn_params_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
-                     lxm_get_params, lxm_put_params);
+    devprocs_initialize(lxm7000m_initialize);
 
 /* The device descriptors */
 
diff --git a/contrib/gdevmd2k.c b/contrib/gdevmd2k.c
index 86202774f..5b8d9fe24 100644
--- a/contrib/gdevmd2k.c
+++ b/contrib/gdevmd2k.c
@@ -64,28 +64,25 @@ typedef struct gx_device_alps_s gx_device_alps;
 
 #define dev_alps ((gx_device_alps *) pdev)
 
-static gx_device_procs alps_procs = {
-    alps_open,
-    gx_default_get_initial_matrix,
-    NULL,			/* sync_output */
-    gdev_prn_output_page,
-    gdev_prn_close,
-    NULL,			/* map_rgb_color,*/
-    alps_map_color_rgb,
-    NULL,			/* fill_rectangle */
-    NULL,			/* tile_rectangle */
-    NULL,			/* copy_mono */
-    NULL,			/* copy_color */
-    NULL,			/* draw_line */
-    NULL,			/* get_bits */
-    alps_get_params,
-    alps_put_params,
-    alps_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 int
+alps_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, alps_open);
+    set_dev_proc(dev, map_color_rgb, alps_map_color_rgb);
+    set_dev_proc(dev, get_params, alps_get_params);
+    set_dev_proc(dev, put_params, alps_put_params);
+    set_dev_proc(dev, map_cmyk_color, alps_map_cmyk_color);
+
+    return 0;
+}
+
+static gx_device_procs alps_procs =
+    devprocs_initialize(alps_initialize);
 
 #define alps_device(dname, print_page) \
 {\
diff --git a/contrib/gdevop4w.c b/contrib/gdevop4w.c
index a92f6e63b..6d34df6ab 100644
--- a/contrib/gdevop4w.c
+++ b/contrib/gdevop4w.c
@@ -94,9 +94,22 @@ static dev_proc_open_device(oki4w_open);
 static dev_proc_close_device(oki4w_close);
 static dev_proc_print_page(oki4w_print_page);
 
+static int
+oki4w_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, oki4w_open);
+    set_dev_proc(dev, close_device, oki4w_close);
+
+    return 0;
+}
+
 static gx_device_procs prn_hp_procs =
-  prn_params_procs(oki4w_open, gdev_prn_output_page, oki4w_close,
-                   gdev_prn_get_params, gdev_prn_put_params);
+    devprocs_initialize(oki4w_initialize);
 
 gx_device_printer far_data gs_oki4w_device =
   prn_device(prn_hp_procs, "oki4w",
diff --git a/contrib/gdevxes.c b/contrib/gdevxes.c
index a10b89c8a..025f927d7 100644
--- a/contrib/gdevxes.c
+++ b/contrib/gdevxes.c
@@ -48,8 +48,23 @@ static int sixel_print_page(gx_device_printer *pdev,
 /* The device descriptor */
 static dev_proc_output_page(sixel_output_page);
 static dev_proc_print_page(xes_print_page);
+
+static int
+sixel_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, output_page, sixel_output_page);
+
+    return 0;
+}
+
+
 static gx_device_procs xes_procs =
-  prn_procs(gdev_prn_open, sixel_output_page, gdev_prn_close);
+  devprocs_initialize(sixel_initialize);
 
 #ifdef A4
 #  define BOTTOM_MARGIN 0.5
diff --git a/contrib/japanese/gdev10v.c b/contrib/japanese/gdev10v.c
index f4c349d18..d429c005e 100644
--- a/contrib/japanese/gdev10v.c
+++ b/contrib/japanese/gdev10v.c
@@ -86,8 +86,21 @@ gx_device_procs prn_bj10v_procs =
   prn_matrix_procs(gdev_prn_open, bj10v_get_initial_matrix,
     gdev_prn_output_page, gdev_prn_close);
 #endif
+static int
+bj10v_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, bj10v_open);
+
+    return 0;
+}
+
 gx_device_procs prn_bj10v_procs =
-  prn_procs(bj10v_open, gdev_prn_output_page, gdev_prn_close);
+  devprocs_initialize(bj10v_initialize);
 
 gx_device_printer gs_bj10v_device =
   prn_device(prn_bj10v_procs, "bj10v",
diff --git a/contrib/japanese/gdevalps.c b/contrib/japanese/gdevalps.c
index 9d3122acd..badad8106 100644
--- a/contrib/japanese/gdevalps.c
+++ b/contrib/japanese/gdevalps.c
@@ -57,8 +57,21 @@ static dev_proc_print_page(md50m_print_page);
 static dev_proc_print_page(md50e_print_page);
 static dev_proc_print_page(md1xm_print_page);
 
+static int
+md_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, md_open);
+
+    return 0;
+}
+
 static gx_device_procs prn_md_procs =
-  prn_procs(md_open, gdev_prn_output_page, gdev_prn_close);
+  devprocs_initialize(md_initialize);
 
 gx_device_printer far_data gs_md50Mono_device =
   prn_device(prn_md_procs, "md50Mono",
diff --git a/contrib/japanese/gdevespg.c b/contrib/japanese/gdevespg.c
index 2f1821346..cc677a9a2 100644
--- a/contrib/japanese/gdevespg.c
+++ b/contrib/japanese/gdevespg.c
@@ -42,11 +42,42 @@ static dev_proc_image_out(escpage_image_out);
 static void escpage_printer_initialize(gx_device_printer * pdev, gp_file * fp, int);
 static void escpage_paper_set(gx_device_printer * pdev, gp_file * fp);
 
+static int
+lp2000_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, lp2000_open);
+    set_dev_proc(dev, get_params, lprn_get_params);
+    set_dev_proc(dev, put_params, lprn_put_params);
+
+    return code;
+}
+
 static gx_device_procs lp2000_prn_procs =
-lprn_procs(lp2000_open, gdev_prn_output_page, gdev_prn_close);
+    devprocs_initialize(lp2000_initialize);
+
+static int
+escpage_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, escpage_open);
+    set_dev_proc(dev, close_device, escpage_close);
+    set_dev_proc(dev, get_params, lprn_get_params);
+    set_dev_proc(dev, put_params, lprn_put_params);
+
+    return code;
+}
 
 static gx_device_procs escpage_prn_procs =
-lprn_procs(escpage_open, gdev_prn_output_page, escpage_close);
+    devprocs_initialize(escpage_initialize);
 
 gx_device_lprn far_data gs_lp2000_device =
 lprn_device(gx_device_lprn, lp2000_prn_procs, "lp2000",
diff --git a/contrib/japanese/gdevfmlbp.c b/contrib/japanese/gdevfmlbp.c
index 0e0ab4254..21d3b60bc 100644
--- a/contrib/japanese/gdevfmlbp.c
+++ b/contrib/japanese/gdevfmlbp.c
@@ -41,15 +41,24 @@ copies.  */
 /* The device descriptors */
 static dev_proc_print_page(fmlbp_print_page);
 
-#ifdef	FMLBP_NOADJUST_MARGIN
-#define	PRNFMLBP	prn_std_procs
+#ifdef FMLBP_NOADJUST_MARGIN
+#define PRNFML_INIT gdev_prn_initialize
 #else
 /* Adjust margin for ghostscript 2.6.1 */
-#define	PRNFMLBP	prn_fmlbp_procs
+#define PRNFML_INIT fmlbp_initialize
 static dev_proc_get_initial_matrix(fmlbp_get_initial_matrix);
-gx_device_procs prn_fmlbp_procs =
-  prn_matrix_procs(gdev_prn_open, fmlbp_get_initial_matrix,
-    gdev_prn_output_page, gdev_prn_close);
+
+static int fmlbp_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, get_initial_matrix, fmlbp_get_initial_matrix);
+
+    return 0;
+}
 
 /* Shift the origin from the top left corner of the pysical page to the
    first printable pixel, as defined by the top and left margins. */
@@ -63,7 +72,7 @@ fmlbp_get_initial_matrix(gx_device *dev, gs_matrix *pmat)
 #endif/*FMLBP_NOADJUST_MARGIN*/
 
 gx_device_printer gs_fmlbp_device =
-  prn_device(PRNFMLBP, "fmlbp",
+  prn_device(PRNFML_INIT, "fmlbp",
         DEFAULT_WIDTH_10THS_A4,		/* width_10ths, 8.3" */
         DEFAULT_HEIGHT_10THS_A4,	/* height_10ths, 11.7" */
         X_DPI, Y_DPI,
diff --git a/contrib/japanese/gdevmjc.c b/contrib/japanese/gdevmjc.c
index 80d489c57..5cb33cd04 100644
--- a/contrib/japanese/gdevmjc.c
+++ b/contrib/japanese/gdevmjc.c
@@ -208,73 +208,90 @@ typedef struct gx_device_mj_s gx_device_mj;
          (bpp == 32 ? 3 : 1), dns, r, g, b, k, drct, mcrwv, dtsz \
 }
 
-#define mj_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_output_page,\
-        gdev_prn_close,\
-        gdev_mjc_map_rgb_color,\
-        gdev_mjc_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,\
-        NULL,	/* 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_mjc_encode_color,\
-        gdev_mjc_decode_color\
+static int
+mj_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, map_rgb_color, gdev_mjc_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gdev_mjc_map_color_rgb);
+    set_dev_proc(dev, get_params, mj_get_params);
+    set_dev_proc(dev, encode_color, gdev_mjc_encode_color);
+    set_dev_proc(dev, decode_color, gdev_mjc_decode_color);
+
+    return 0;
+}
+
+static int
+mj700v2c_initialize(gx_device *dev)
+{
+    int code = mj_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, mj700v2c_open);
+    set_dev_proc(dev, put_params, mj700v2c_put_params);
+
+    return 0;
 }
 
 static gx_device_procs mj700v2c_procs =
-mj_colour_procs(mj700v2c_open, mj_get_params, mj700v2c_put_params);
+    devprocs_initialize(mj700v2c_initialize);
+
+static int
+mj500c_initialize(gx_device *dev)
+{
+    int code = mj_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, mj500c_open);
+    set_dev_proc(dev, put_params, mj500c_put_params);
+
+    return 0;
+}
 
 static gx_device_procs mj500c_procs =
-mj_colour_procs(mj500c_open, mj_get_params, mj500c_put_params);
+    devprocs_initialize(mj500c_initialize);
+
+static int
+mj6000c_initialize(gx_device *dev)
+{
+    int code = mj_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, mj6000c_open);
+    set_dev_proc(dev, put_params, mj700v2c_put_params);
+
+    return 0;
+}
 
 static gx_device_procs mj6000c_procs =
-mj_colour_procs(mj6000c_open, mj_get_params, mj700v2c_put_params);
+    devprocs_initialize(mj6000c_initialize);
+
+static int
+mj8000c_initialize(gx_device *dev)
+{
+    int code = mj_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, mj8000c_open);
+    set_dev_proc(dev, put_params, mj700v2c_put_params);
+
+    return 0;
+}
 
 static gx_device_procs mj8000c_procs =
-mj_colour_procs(mj8000c_open, mj_get_params, mj700v2c_put_params);
+    devprocs_initialize(mj8000c_initialize);
 
 gx_device_mj far_data gs_mj700v2c_device =
 mjcmyk_device(mj700v2c_procs, "mj700v2c", 360, 360, BITSPERPIXEL,
diff --git a/contrib/japanese/gdevml6.c b/contrib/japanese/gdevml6.c
index d8eaa1c30..60ab151fd 100644
--- a/contrib/japanese/gdevml6.c
+++ b/contrib/japanese/gdevml6.c
@@ -32,8 +32,22 @@ static dev_proc_open_device(ml600_open);
 static dev_proc_close_device(ml600_close);
 static dev_proc_print_page(ml600_print_page);
 
+static int
+ml600_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, ml600_open);
+    set_dev_proc(dev, close_device, ml600_close);
+
+    return code;
+}
+
 static gx_device_procs ml600_procs =
-        prn_procs(ml600_open, gdev_prn_output_page, ml600_close);
+    devprocs_initialize(ml600_initialize);
 
 gx_device_printer gs_ml600_device =
   prn_device(ml600_procs, "ml600",
diff --git a/contrib/japanese/gdevnpdl.c b/contrib/japanese/gdevnpdl.c
index 9deadaeef..98432b4fb 100644
--- a/contrib/japanese/gdevnpdl.c
+++ b/contrib/japanese/gdevnpdl.c
@@ -118,9 +118,24 @@ static dev_proc_print_page_copies(npdl_print_page_copies);
 static dev_proc_put_params(npdl_put_params);
 static dev_proc_image_out(npdl_image_out);
 
+static int
+npdl_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, npdl_open);
+    set_dev_proc(dev, close_device, npdl_close);
+    set_dev_proc(dev, get_params, lprn_get_params);
+    set_dev_proc(dev, put_params, npdl_put_params);
+
+    return code;
+}
+
 static gx_device_procs npdl_prn_procs =
-prn_params_procs(npdl_open, gdev_prn_output_page, npdl_close,
-                 lprn_get_params, npdl_put_params);
+    devprocs_initialize(npdl_initialize);
 
 gx_device_lprn far_data gs_npdl_device =
 lprn_duplex_device(gx_device_lprn, npdl_prn_procs, "npdl",
diff --git a/contrib/japanese/gdevrpdl.c b/contrib/japanese/gdevrpdl.c
index d7e561f53..69c2b644c 100644
--- a/contrib/japanese/gdevrpdl.c
+++ b/contrib/japanese/gdevrpdl.c
@@ -34,8 +34,24 @@ static dev_proc_image_out(rpdl_image_out);
 static void rpdl_printer_initialize(gx_device_printer * pdev, gp_file * prn_stream, int num_copies);
 static void rpdl_paper_set(gx_device_printer * pdev, gp_file * prn_stream);
 
+static int
+rpdl_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, rpdl_open);
+    set_dev_proc(dev, close_device, rpdl_close);
+    set_dev_proc(dev, get_params, lprn_get_params);
+    set_dev_proc(dev, put_params, lprn_put_params);
+
+    return code;
+}
+
 static gx_device_procs rpdl_prn_procs =
-lprn_procs(rpdl_open, gdev_prn_output_page, rpdl_close);
+    devprocs_initialize(rpdl_initialize);
 
 gx_device_lprn far_data gs_rpdl_device =
 lprn_device(gx_device_lprn, rpdl_prn_procs, "rpdl",
diff --git a/contrib/lips4/gdevl4r.c b/contrib/lips4/gdevl4r.c
index 0e03270aa..3f077f486 100644
--- a/contrib/lips4/gdevl4r.c
+++ b/contrib/lips4/gdevl4r.c
@@ -99,21 +99,81 @@ struct gx_device_lips4_s {
     lips4_params_common;
 };
 
+static int
+lips2p_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, lips2p_open);
+    set_dev_proc(dev, close_device, lips_close);
+    set_dev_proc(dev, get_params, lips_get_params);
+    set_dev_proc(dev, put_params, lips_put_params);
+
+    return 0;
+};
+
+static int
+lips3_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, lips3_open);
+    set_dev_proc(dev, close_device, lips_close);
+    set_dev_proc(dev, get_params, lips_get_params);
+    set_dev_proc(dev, put_params, lips_put_params);
+
+    return 0;
+};
+
+static int
+bjc880j_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, bjc880j_open);
+    set_dev_proc(dev, close_device, lips_close);
+    set_dev_proc(dev, get_params, lips4_get_params);
+    set_dev_proc(dev, put_params, lips4_put_params);
+
+    return 0;
+};
+
+static int
+lips4_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize_mono(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, lips4_open);
+    set_dev_proc(dev, close_device, lips_close);
+    set_dev_proc(dev, get_params, lips4_get_params);
+    set_dev_proc(dev, put_params, lips4_put_params);
+
+    return 0;
+};
+
 static gx_device_procs lips2p_prn_procs =
-prn_params_procs(lips2p_open, gdev_prn_output_page, lips_close,
-                 lips_get_params, lips_put_params);
+    devprocs_initialize(lips2p_initialize);
 
 static gx_device_procs lips3_prn_procs =
-prn_params_procs(lips3_open, gdev_prn_output_page, lips_close,
-                 lips_get_params, lips_put_params);
+    devprocs_initialize(lips3_initialize);
 
 static gx_device_procs bjc880j_prn_color_procs =
-prn_params_procs(bjc880j_open, gdev_prn_output_page, lips_close,
-                       lips4_get_params, lips4_put_params);
+    devprocs_initialize(bjc880j_initialize);
 
 static gx_device_procs lips4_prn_procs =
-prn_params_procs(lips4_open, gdev_prn_output_page, lips_close,
-                       lips4_get_params, lips4_put_params);
+    devprocs_initialize(lips4_initialize);
 
 gx_device_lips far_data gs_lips2p_device =
 lips_device(gx_device_lips, lips2p_prn_procs, "lips2p",
diff --git a/contrib/lips4/gdevl4v.c b/contrib/lips4/gdevl4v.c
index acf5a1eed..cc7f5ae3a 100644
--- a/contrib/lips4/gdevl4v.c
+++ b/contrib/lips4/gdevl4v.c
@@ -156,48 +156,35 @@ gs_public_st_suffix_add0_final(st_device_lips4v, gx_device_lips4v,
                         LIPS4_RIGHT_MARGIN_DEFAULT,\
                         LIPS4_TOP_MARGIN_DEFAULT)
 
-#define lips4v_procs\
-        {	lips4v_open,\
-                gx_upright_get_initial_matrix,\
-                NULL,			/* sync_output */\
-                lips4v_output_page,\
-                lips4v_close,\
-                gx_default_gray_map_rgb_color,\
-                gx_default_gray_map_color_rgb,\
-                gdev_vector_fill_rectangle,\
-                NULL,			/* tile_rectangle */\
-                lips4v_copy_mono,\
-                lips4v_copy_color,\
-                NULL,			/* draw_line */\
-                NULL,			/* get_bits */\
-                lips4v_get_params,\
-                lips4v_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,\
-                lips4v_fill_mask,\
-                gdev_vector_fill_trapezoid,\
-                gdev_vector_fill_parallelogram,\
-                gdev_vector_fill_triangle,\
-                NULL /****** WRONG ******/,	/* draw_thin_line */\
-                lips4v_begin_image,\
-                NULL,\
-                NULL,\
-                NULL,			/* strip_tile_rectangle */\
-                NULL/******strip_copy_rop******/\
-        }
+static int
+lips4v_initialize(gx_device *dev)
+{
+    set_dev_proc(dev, open_device, lips4v_open);
+    set_dev_proc(dev, get_initial_matrix, gx_upright_get_initial_matrix);
+    set_dev_proc(dev, output_page, lips4v_output_page);
+    set_dev_proc(dev, close_device, lips4v_close);
+    set_dev_proc(dev, map_rgb_color, gx_default_gray_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, gx_default_gray_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, gdev_vector_fill_rectangle);
+    set_dev_proc(dev, copy_mono, lips4v_copy_mono);
+    set_dev_proc(dev, copy_color, lips4v_copy_color);
+    set_dev_proc(dev, get_params, lips4v_get_params);
+    set_dev_proc(dev, put_params, lips4v_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, lips4v_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, lips4v_begin_image);
+
+    return 0;
+}
 
 gx_device_lips4v far_data gs_lips4v_device = {
     lips4v_device_body,
-    lips4v_procs,
+    devprocs_initialize(lips4v_initialize),
     vector_initial_values,
     LIPS_CASSETFEED_DEFAULT,
     LIPS_USERNAME_DEFAULT,
diff --git a/contrib/lips4/gdevlprn.h b/contrib/lips4/gdevlprn.h
index de04ed3ac..4c066c5fa 100644
--- a/contrib/lips4/gdevlprn.h
+++ b/contrib/lips4/gdevlprn.h
@@ -114,9 +114,6 @@
        lp_duplex_device_body_rest_(print_page_copies, image_out)\
 }
 
-#define lprn_procs(p_open, p_output_page, p_close)\
-  prn_params_procs(p_open, p_output_page, p_close, lprn_get_params, lprn_put_params)
-
 typedef struct _Bubble
 {
     struct _Bubble *next;
diff --git a/contrib/opvp/gdevopvp.c b/contrib/opvp/gdevopvp.c
index 7c80dc32e..caade19fd 100644
--- a/contrib/opvp/gdevopvp.c
+++ b/contrib/opvp/gdevopvp.c
@@ -296,57 +296,34 @@ gs_public_st_suffix_add0_final(
     NULL /* *docInfo */
 
 /* device procs */
-#define opvp_procs \
-{\
-    opvp_open,\
-    opvp_get_initial_matrix,\
-    NULL, /* sync_output */\
-    opvp_output_page,\
-    opvp_close,\
-    opvp_map_rgb_color,\
-    opvp_map_color_rgb,\
-    opvp_fill_rectangle, /*gdev_vector_fill_rectangle,*/\
-    NULL, /* tile_rectangle OBSOLETE */\
-    opvp_copy_mono,\
-    opvp_copy_color,\
-    NULL, /* draw_line OBSOLETE */\
-    NULL, /* get_bits */\
-    opvp_get_params,\
-    opvp_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 OBSOLETE */\
-    NULL, /* copy_alpha */\
-    NULL, /* get_band */\
-    NULL, /* copy_rop */\
-    opvp_fill_path,\
-    opvp_stroke_path,\
-    opvp_fill_mask,\
-    gdev_vector_fill_trapezoid,\
-    gdev_vector_fill_parallelogram,\
-    gdev_vector_fill_triangle,\
-    NULL, /* draw_thin_line */\
-    opvp_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 */\
+static int
+opvp_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, opvp_open);
+    set_dev_proc(dev, get_initial_matrix, opvp_get_initial_matrix);
+    set_dev_proc(dev, output_page, opvp_output_page);
+    set_dev_proc(dev, close_device, opvp_close);
+    set_dev_proc(dev, map_rgb_color, opvp_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, opvp_map_color_rgb);
+    set_dev_proc(dev, fill_rectangle, opvp_fill_rectangle);
+    set_dev_proc(dev, copy_mono, opvp_copy_mono);
+    set_dev_proc(dev, copy_color, opvp_copy_color);
+    set_dev_proc(dev, get_params, opvp_get_params);
+    set_dev_proc(dev, put_params, opvp_put_params);
+    set_dev_proc(dev, fill_path, opvp_fill_path);
+    set_dev_proc(dev, stroke_path, opvp_stroke_path);
+    set_dev_proc(dev, fill_mask, opvp_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, opvp_begin_image);
+
+    return 0;
 }
 
 /* vector procs */
@@ -395,20 +372,31 @@ const   gx_device_opvp          gs_opvp_device =
         256,
         256
     ),
-    opvp_procs
+    devprocs_initialize(opvp_initialize)
 };
 
 /* for inkjet */
+static int
+oprp_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, oprp_open);
+    set_dev_proc(dev, output_page, opvp_output_page);
+    set_dev_proc(dev, close_device, opvp_close);
+    set_dev_proc(dev, map_rgb_color, opvp_map_rgb_color);
+    set_dev_proc(dev, map_color_rgb, opvp_map_color_rgb);
+    set_dev_proc(dev, get_params, oprp_get_params);
+    set_dev_proc(dev, put_params, oprp_put_params);
+
+    return 0;
+}
+
 static  gx_device_procs prn_oprp_procs =
-    prn_color_params_procs(
-        oprp_open,
-        opvp_output_page,
-        opvp_close,
-        opvp_map_rgb_color,
-        opvp_map_color_rgb,
-        oprp_get_params,
-        oprp_put_params
-    );
+    devprocs_initialize(oprp_initialize);
 
 const gx_device_oprp gs_oprp_device =
 {
diff --git a/contrib/pcl3/eprn/gdeveprn.h b/contrib/pcl3/eprn/gdeveprn.h
index e81afeae6..b079d002d 100644
--- a/contrib/pcl3/eprn/gdeveprn.h
+++ b/contrib/pcl3/eprn/gdeveprn.h
@@ -646,7 +646,6 @@ extern void eprn_set_media_flags(eprn_Device *dev, ms_MediaCode desired,
 
 /*****************************************************************************/
 
-/* Device procedures */
 extern dev_proc_open_device(eprn_open_device);
 extern dev_proc_get_initial_matrix(eprn_get_initial_matrix);
 extern dev_proc_output_page(eprn_output_page);
@@ -666,84 +665,6 @@ extern dev_proc_map_cmyk_color(eprn_map_cmyk_color_max);
 extern dev_proc_map_cmyk_color(eprn_map_cmyk_color_glob);
 extern dev_proc_fillpage(eprn_fillpage);
 
-/*  Macro for initializing device procedure tables
-
-    This macro corresponds to the macro prn_params_procs() which is used when
-    basing a device directly on the prn device.
-
-    If your device does not need all of the procedures in the argument list,
-    use the following defaults:
-      p_open:		eprn_open_device
-      p_close:		eprn_close_device
-      p_get_params:	eprn_get_params
-      p_put_params:	eprn_put_params
-    On the other hand, if your driver needs its own procedure in any of these
-    cases its code must also call the appropriate default routine.
-*/
-#define eprn_procs_initdata(p_open, p_close, p_get_params, p_put_params) \
-  p_open,			/* open_device */		\
-  eprn_get_initial_matrix,	/* get_initial_matrix */	\
-  NULL,				/* sync_output */		\
-  eprn_output_page,		/* output_page */		\
-  p_close,			/* close_device */		\
-  eprn_map_rgb_color_for_CMY_or_K,  /* map_rgb_color */		\
-  eprn_map_color_rgb,		/* map_color_rgb */		\
-  NULL,				/* fill_rectangle */		\
-  NULL,				/* tile_rectangle */		\
-  NULL,				/* copy_mono */			\
-  NULL,				/* copy_color */		\
-  NULL,				/* draw_line */			\
-  NULL,				/* get_bits */			\
-  p_get_params,			/* get_params */		\
-  p_put_params,			/* put_params */		\
-  eprn_map_cmyk_color_glob,	/* 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 */      \
-  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 */              \
-  eprn_fillpage                 /* fillpage */
-  /* The remaining fields should be NULL. */
 
 /*****************************************************************************/
 
diff --git a/contrib/pcl3/src/gdevpcl3.c b/contrib/pcl3/src/gdevpcl3.c
index 6b6468e02..c679fa038 100644
--- a/contrib/pcl3/src/gdevpcl3.c
+++ b/contrib/pcl3/src/gdevpcl3.c
@@ -92,12 +92,32 @@ static dev_proc_close_device(pcl3_close_device);
 static dev_proc_get_params(pcl3_get_params);
 static dev_proc_put_params(pcl3_put_params);
 
-/* Device procedure table */
-static gx_device_procs pcl3_procs = {
-  eprn_procs_initdata(pcl3_open_device, pcl3_close_device, pcl3_get_params,
-    pcl3_put_params)
+/* Device procedures */
+static int
+eprn_initialize(gx_device *dev)
+{
+    int code = gdev_prn_initialize(dev);
+
+    if (code < 0)
+        return code;
+
+    set_dev_proc(dev, open_device, pcl3_open_device);
+    set_dev_proc(dev, get_initial_matrix, eprn_get_initial_matrix);
+    set_dev_proc(dev, close_device, pcl3_close_device);
+    set_dev_proc(dev, map_rgb_color, eprn_map_rgb_color_for_CMY_or_K);
+    set_dev_proc(dev, map_color_rgb, eprn_map_color_rgb);
+    set_dev_proc(dev, map_cmyk_color, eprn_map_cmyk_color_glob);
+    set_dev_proc(dev, get_params, pcl3_get_params);
+    set_dev_proc(dev, put_params, pcl3_put_params);
+    set_dev_proc(dev, fillpage, eprn_fillpage);
+
+    return 0;
 };
 
+/* Device procedure table */
+static gx_device_procs pcl3_procs =
+    devprocs_initialize(eprn_initialize);
+
 /* prn procedure implementations */
 #if !defined(GS_REVISION) || GS_REVISION >= 550
 static prn_dev_proc_print_page(pcl3_print_page);