Removes all uses of the now-deprecated Pn macros from PostScript operator

files (src/z*.c).

git-svn-id: http://svn.ghostscript.com/ghostscript/trunk@2737 a1074d23-0009-0410-80fe-cf8c14f379e6

52 files changed, 304 insertions, 306 deletions

diff --git a/gs/src/zbfont.c b/gs/src/zbfont.c
index 3779e50e3..74b1ee874 100644
--- a/gs/src/zbfont.c
+++ b/gs/src/zbfont.c
@@ -402,8 +402,8 @@ lookup_gs_simple_font_encoding(gs_font_base * pfont)
 }
 
 /* Get FontMatrix and FontName parameters. */
-private void get_font_name(P2(ref *, const ref *));
-private void copy_font_name(P2(gs_font_name *, const ref *));
+private void get_font_name(ref *, const ref *);
+private void copy_font_name(gs_font_name *, const ref *);
 private int
 sub_font_params(const ref *op, gs_matrix *pmat, ref *pfname)
 {
diff --git a/gs/src/zcfont.c b/gs/src/zcfont.c
index 49eea0fc9..2ee507baf 100644
--- a/gs/src/zcfont.c
+++ b/gs/src/zcfont.c
@@ -29,8 +29,8 @@
 #include "store.h"
 
 /* Forward references */
-private int cshow_continue(P1(i_ctx_t *));
-private int cshow_restore_font(P1(i_ctx_t *));
+private int cshow_continue(i_ctx_t *);
+private int cshow_restore_font(i_ctx_t *);
 
 /* <proc> <string> cshow - */
 private int
diff --git a/gs/src/zchar.c b/gs/src/zchar.c
index 8d85da41b..09a86c339 100644
--- a/gs/src/zchar.c
+++ b/gs/src/zchar.c
@@ -39,10 +39,10 @@
 #include "store.h"
 
 /* Forward references */
-private bool map_glyph_to_char(P3(const ref *, const ref *, ref *));
-private int finish_show(P1(i_ctx_t *));
-private int op_show_cleanup(P1(i_ctx_t *));
-private int op_show_return_width(P3(i_ctx_t *, uint, double *));
+private bool map_glyph_to_char(const ref *, const ref *, ref *);
+private int finish_show(i_ctx_t *);
+private int op_show_cleanup(i_ctx_t *);
+private int op_show_return_width(i_ctx_t *, uint, double *);
 
 /* <string> show - */
 private int
@@ -202,8 +202,8 @@ finish_stringwidth(i_ctx_t *i_ctx_p)
 /* Common code for charpath and .charboxpath. */
 private int
 zchar_path(i_ctx_t *i_ctx_p,
-	   int (*begin)(P6(gs_state *, const byte *, uint,
-			   bool, gs_memory_t *, gs_text_enum_t **)))
+	   int (*begin)(gs_state *, const byte *, uint,
+			bool, gs_memory_t *, gs_text_enum_t **))
 {
     os_ptr op = osp;
     gs_text_enum_t *penum;
diff --git a/gs/src/zchar1.c b/gs/src/zchar1.c
index 0fb9f486d..802d67963 100644
--- a/gs/src/zchar1.c
+++ b/gs/src/zchar1.c
@@ -130,30 +130,29 @@ gs_private_st_suffix_add1(st_gs_type1exec_state, gs_type1exec_state,
 			  i_ctx_p);
 
 /* Forward references */
-private int bbox_continue(P1(i_ctx_t *));
-private int nobbox_continue(P1(i_ctx_t *));
-private int type1_push_OtherSubr(P4(i_ctx_t *, const gs_type1exec_state *,
-				    int (*)(P1(i_ctx_t *)), const ref *));
-private int type1_call_OtherSubr(P4(i_ctx_t *, const gs_type1exec_state *,
-				    int (*)(P1(i_ctx_t *)), const ref *));
-private int type1_callout_dispatch(P3(i_ctx_t *, int (*)(P1(i_ctx_t *)),
-				      int));
-private int type1_continue_dispatch(P5(i_ctx_t *, gs_type1exec_state *,
-				       const ref *, ref *, int));
-private int op_type1_cleanup(P1(i_ctx_t *));
-private void op_type1_free(P1(i_ctx_t *));
+private int bbox_continue(i_ctx_t *);
+private int nobbox_continue(i_ctx_t *);
+private int type1_push_OtherSubr(i_ctx_t *, const gs_type1exec_state *,
+				 int (*)(i_ctx_t *), const ref *);
+private int type1_call_OtherSubr(i_ctx_t *, const gs_type1exec_state *,
+				 int (*)(i_ctx_t *), const ref *);
+private int type1_callout_dispatch(i_ctx_t *, int (*)(i_ctx_t *), int);
+private int type1_continue_dispatch(i_ctx_t *, gs_type1exec_state *,
+				    const ref *, ref *, int);
+private int op_type1_cleanup(i_ctx_t *);
+private void op_type1_free(i_ctx_t *);
 private void
-     type1_cis_get_metrics(P2(const gs_type1_state * pcis, double psbw[4]));
-private int bbox_getsbw_continue(P1(i_ctx_t *));
-private int type1exec_bbox(P3(i_ctx_t *, gs_type1exec_state *, gs_font *));
-private int bbox_finish_fill(P1(i_ctx_t *));
-private int bbox_finish_stroke(P1(i_ctx_t *));
-private int bbox_fill(P1(i_ctx_t *));
-private int bbox_stroke(P1(i_ctx_t *));
-private int nobbox_finish(P2(i_ctx_t *, gs_type1exec_state *));
-private int nobbox_draw(P2(i_ctx_t *, int (*)(P1(gs_state *))));
-private int nobbox_fill(P1(i_ctx_t *));
-private int nobbox_stroke(P1(i_ctx_t *));
+     type1_cis_get_metrics(const gs_type1_state * pcis, double psbw[4]);
+private int bbox_getsbw_continue(i_ctx_t *);
+private int type1exec_bbox(i_ctx_t *, gs_type1exec_state *, gs_font *);
+private int bbox_finish_fill(i_ctx_t *);
+private int bbox_finish_stroke(i_ctx_t *);
+private int bbox_fill(i_ctx_t *);
+private int bbox_stroke(i_ctx_t *);
+private int nobbox_finish(i_ctx_t *, gs_type1exec_state *);
+private int nobbox_draw(i_ctx_t *, int (*)(gs_state *));
+private int nobbox_fill(i_ctx_t *);
+private int nobbox_stroke(i_ctx_t *);
 
 /* <font> <code|name> <name> <charstring> .type1execchar - */
 private int
@@ -379,7 +378,7 @@ bbox_getsbw_continue(i_ctx_t *i_ctx_p)
 
 /* <font> <code|name> <name> <charstring> <sbx> <sby> %bbox_{fill|stroke} - */
 /* <font> <code|name> <name> <charstring> %bbox_{fill|stroke} - */
-private int bbox_finish(P2(i_ctx_t *, int (*)(P1(i_ctx_t *))));
+private int bbox_finish(i_ctx_t *, int (*)(i_ctx_t *));
 private int
 bbox_finish_fill(i_ctx_t *i_ctx_p)
 {
@@ -391,7 +390,7 @@ bbox_finish_stroke(i_ctx_t *i_ctx_p)
     return bbox_finish(i_ctx_p, bbox_stroke);
 }
 private int
-bbox_finish(i_ctx_t *i_ctx_p, int (*cont) (P1(i_ctx_t *)))
+bbox_finish(i_ctx_t *i_ctx_p, int (*cont) (i_ctx_t *))
 {
     os_ptr op = osp;
     gs_font *pfont;
@@ -480,7 +479,7 @@ bbox_continue(i_ctx_t *i_ctx_p)
  * of type1execchar are still on the o-stack.
  */
 private int
-bbox_draw(i_ctx_t *i_ctx_p, int (*draw)(P1(gs_state *)))
+bbox_draw(i_ctx_t *i_ctx_p, int (*draw)(gs_state *))
 {
     os_ptr op = osp;
     gs_rect bbox;
@@ -626,7 +625,7 @@ type1_continue_dispatch(i_ctx_t *i_ctx_p, gs_type1exec_state *pcxs,
  */
 private int
 type1_push_OtherSubr(i_ctx_t *i_ctx_p, const gs_type1exec_state *pcxs,
-		     int (*cont)(P1(i_ctx_t *)), const ref *pos)
+		     int (*cont)(i_ctx_t *), const ref *pos)
 {
     int i, n = pcxs->num_args;
 
@@ -650,7 +649,7 @@ type1_push_OtherSubr(i_ctx_t *i_ctx_p, const gs_type1exec_state *pcxs,
  */
 private int
 type1_call_OtherSubr(i_ctx_t *i_ctx_p, const gs_type1exec_state * pcxs,
-		     int (*cont) (P1(i_ctx_t *)),
+		     int (*cont) (i_ctx_t *),
 		     const ref * pos)
 {
     /* Move the Type 1 interpreter state to the heap. */
@@ -670,7 +669,7 @@ type1_call_OtherSubr(i_ctx_t *i_ctx_p, const gs_type1exec_state * pcxs,
 
 /* Continue from an OtherSubr callout while building the path. */
 private int
-type1_callout_dispatch(i_ctx_t *i_ctx_p, int (*cont)(P1(i_ctx_t *)),
+type1_callout_dispatch(i_ctx_t *i_ctx_p, int (*cont)(i_ctx_t *),
 		       int num_args)
 {
     ref other_subr;
@@ -785,7 +784,7 @@ nobbox_finish(i_ctx_t *i_ctx_p, gs_type1exec_state * pcxs)
 }
 /* Finish by popping the operands and filling or stroking. */
 private int
-nobbox_draw(i_ctx_t *i_ctx_p, int (*draw)(P1(gs_state *)))
+nobbox_draw(i_ctx_t *i_ctx_p, int (*draw)(gs_state *))
 {
     int code = draw(igs);
 
diff --git a/gs/src/zchar42.c b/gs/src/zchar42.c
index 1270a3574..91e7cf7a7 100644
--- a/gs/src/zchar42.c
+++ b/gs/src/zchar42.c
@@ -37,8 +37,8 @@
 #include "store.h"
 
 /* <font> <code|name> <name> <glyph_index> .type42execchar - */
-private int type42_fill(P1(i_ctx_t *));
-private int type42_stroke(P1(i_ctx_t *));
+private int type42_fill(i_ctx_t *);
+private int type42_stroke(i_ctx_t *);
 private int
 ztype42execchar(i_ctx_t *i_ctx_p)
 {
@@ -131,8 +131,8 @@ ztype42execchar(i_ctx_t *i_ctx_p)
 }
 
 /* Continue after a CDevProc callout. */
-private int type42_finish(P2(i_ctx_t *i_ctx_p,
-			     int (*cont)(P1(gs_state *))));
+private int type42_finish(i_ctx_t *i_ctx_p,
+			  int (*cont)(gs_state *));
 private int
 type42_fill(i_ctx_t *i_ctx_p)
 {
@@ -146,7 +146,7 @@ type42_stroke(i_ctx_t *i_ctx_p)
 /* <font> <code|name> <name> <glyph_index> <sbx> <sby> %type42_{fill|stroke} - */
 /* <font> <code|name> <name> <glyph_index> %type42_{fill|stroke} - */
 private int
-type42_finish(i_ctx_t *i_ctx_p, int (*cont) (P1(gs_state *)))
+type42_finish(i_ctx_t *i_ctx_p, int (*cont) (gs_state *))
 {
     os_ptr op = osp;
     gs_font *pfont;
diff --git a/gs/src/zcharout.c b/gs/src/zcharout.c
index 906868959..c12b5519f 100644
--- a/gs/src/zcharout.c
+++ b/gs/src/zcharout.c
@@ -276,8 +276,8 @@ zchar_set_cache(i_ctx_t *i_ctx_p, const gs_font_base * pbfont,
  * Get the CharString data corresponding to a glyph.  Return typecheck
  * if it isn't a string.
  */
-private bool charstring_is_notdef_proc(P1(const ref *));
-private int charstring_make_notdef(P2(gs_glyph_data_t *, gs_font *));
+private bool charstring_is_notdef_proc(const ref *);
+private int charstring_make_notdef(gs_glyph_data_t *, gs_font *);
 int
 zchar_charstring_data(gs_font *font, const ref *pgref, gs_glyph_data_t *pgd)
 {
diff --git a/gs/src/zcie.c b/gs/src/zcie.c
index 867dfcf52..9b2d66a40 100644
--- a/gs/src/zcie.c
+++ b/gs/src/zcie.c
@@ -151,8 +151,8 @@ cie_points_param(const ref * pdref, gs_cie_wb * pwb)
 /* Process a 3- or 4-dimensional lookup table from a dictionary. */
 /* The caller has set pclt->n and pclt->m. */
 /* ptref is known to be a readable array of size at least n+1. */
-private int cie_3d_table_param(P4(const ref * ptable, uint count, uint nbytes,
-				  gs_const_string * strings));
+private int cie_3d_table_param(const ref * ptable, uint count, uint nbytes,
+			       gs_const_string * strings);
 int
 cie_table_param(const ref * ptref, gx_color_lookup_table * pclt,
 		gs_memory_t * mem)
@@ -287,13 +287,13 @@ cie_set_finish(i_ctx_t *i_ctx_p, gs_color_space * pcs,
 }
 
 /* Forward references */
-private int cache_common(P5(i_ctx_t *, gs_cie_common *, const ref_cie_procs *,
-			    void *, gs_ref_memory_t *));
-private int cache_abc_common(P5(i_ctx_t *, gs_cie_abc *, const ref_cie_procs *,
-				void *, gs_ref_memory_t *));
+private int cache_common(i_ctx_t *, gs_cie_common *, const ref_cie_procs *,
+			 void *, gs_ref_memory_t *);
+private int cache_abc_common(i_ctx_t *, gs_cie_abc *, const ref_cie_procs *,
+			     void *, gs_ref_memory_t *);
 
 /* <dict> .setciedefgspace - */
-private int cie_defg_finish(P1(i_ctx_t *));
+private int cie_defg_finish(i_ctx_t *);
 private int
 zsetciedefgspace(i_ctx_t *i_ctx_p)
 {
@@ -352,7 +352,7 @@ cie_defg_finish(i_ctx_t *i_ctx_p)
 }
 
 /* <dict> .setciedefspace - */
-private int cie_def_finish(P1(i_ctx_t *));
+private int cie_def_finish(i_ctx_t *);
 private int
 zsetciedefspace(i_ctx_t *i_ctx_p)
 {
@@ -411,7 +411,7 @@ cie_def_finish(i_ctx_t *i_ctx_p)
 }
 
 /* <dict> .setcieabcspace - */
-private int cie_abc_finish(P1(i_ctx_t *));
+private int cie_abc_finish(i_ctx_t *);
 private int
 zsetcieabcspace(i_ctx_t *i_ctx_p)
 {
@@ -454,7 +454,7 @@ cie_abc_finish(i_ctx_t *i_ctx_p)
 }
 
 /* <dict> .setcieaspace - */
-private int cie_a_finish(P1(i_ctx_t *));
+private int cie_a_finish(i_ctx_t *);
 private int
 zsetcieaspace(i_ctx_t *i_ctx_p)
 {
@@ -532,8 +532,8 @@ cache_common(i_ctx_t *i_ctx_p, gs_cie_common * pcie,
 /* ------ Internal routines ------ */
 
 /* Prepare to cache the values for one or more procedures. */
-private int cie_cache_finish1(P1(i_ctx_t *));
-private int cie_cache_finish(P1(i_ctx_t *));
+private int cie_cache_finish1(i_ctx_t *);
+private int cie_cache_finish(i_ctx_t *);
 int
 cie_prepare_cache(i_ctx_t *i_ctx_p, const gs_range * domain, const ref * proc,
 		  cie_cache_floats * pcache, void *container,
diff --git a/gs/src/zcolor.c b/gs/src/zcolor.c
index 5f7ca7f32..717145513 100644
--- a/gs/src/zcolor.c
+++ b/gs/src/zcolor.c
@@ -31,7 +31,7 @@
 #include "icolor.h"
 
 /* Imported from gsht.c */
-void gx_set_effective_transfer(P1(gs_state *));
+void gx_set_effective_transfer(gs_state *);
 
 /* Define the number of stack slots needed for zcolor_remap_one. */
 const int zcolor_remap_one_ostack = 4;
diff --git a/gs/src/zcolor2.c b/gs/src/zcolor2.c
index 054441ea0..1cb93c63a 100644
--- a/gs/src/zcolor2.c
+++ b/gs/src/zcolor2.c
@@ -40,10 +40,10 @@
 #include "store.h"
 
 /* Forward references */
-private int store_color_params(P3(os_ptr, const gs_paint_color *,
-				  const gs_color_space *));
-private int load_color_params(P3(os_ptr, gs_paint_color *,
-				 const gs_color_space *));
+private int store_color_params(os_ptr, const gs_paint_color *,
+			       const gs_color_space *);
+private int load_color_params(os_ptr, gs_paint_color *,
+			      const gs_color_space *);
 
 /* Test whether a Pattern instance uses a base space. */
 inline private bool
diff --git a/gs/src/zcontext.c b/gs/src/zcontext.c
index 236a75f24..df7c1409f 100644
--- a/gs/src/zcontext.c
+++ b/gs/src/zcontext.c
@@ -47,8 +47,8 @@
 private int reschedule_interval = 100;
 
 /* Scheduling hooks in interp.c */
-extern int (*gs_interp_reschedule_proc)(P1(i_ctx_t **));
-extern int (*gs_interp_time_slice_proc)(P1(i_ctx_t **));
+extern int (*gs_interp_reschedule_proc)(i_ctx_t **);
+extern int (*gs_interp_time_slice_proc)(i_ctx_t **);
 extern int gs_interp_time_slice_ticks;
 
 /* Context structure */
@@ -293,15 +293,15 @@ context_reclaim(vm_spaces * pspaces, bool global)
 
 
 /* Forward references */
-private int context_create(P5(gs_scheduler_t *, gs_context_t **,
-			      const gs_dual_memory_t *,
-			      const gs_context_state_t *, bool));
-private long context_usertime(P0());
-private int context_param(P3(const gs_scheduler_t *, os_ptr, gs_context_t **));
-private void context_destroy(P1(gs_context_t *));
-private void stack_copy(P4(ref_stack_t *, const ref_stack_t *, uint, uint));
-private int lock_acquire(P2(os_ptr, gs_context_t *));
-private int lock_release(P1(ref *));
+private int context_create(gs_scheduler_t *, gs_context_t **,
+			   const gs_dual_memory_t *,
+			   const gs_context_state_t *, bool);
+private long context_usertime(void);
+private int context_param(const gs_scheduler_t *, os_ptr, gs_context_t **);
+private void context_destroy(gs_context_t *);
+private void stack_copy(ref_stack_t *, const ref_stack_t *, uint, uint);
+private int lock_acquire(os_ptr, gs_context_t *);
+private int lock_release(ref *);
 
 /* Internal procedures */
 private void
@@ -336,9 +336,9 @@ add_last(const gs_scheduler_t *psched, ctx_list_t *pl, gs_context_t *pc)
 
 /* ------ Initialization ------ */
 
-private int ctx_initialize(P1(i_ctx_t **));
-private int ctx_reschedule(P1(i_ctx_t **));
-private int ctx_time_slice(P1(i_ctx_t **));
+private int ctx_initialize(i_ctx_t **);
+private int ctx_reschedule(i_ctx_t **);
+private int ctx_time_slice(i_ctx_t **);
 private int
 zcontext_init(i_ctx_t *i_ctx_p)
 {
@@ -520,15 +520,15 @@ zdetach(i_ctx_t *i_ctx_p)
 }
 
 private int
-    do_fork(P6(i_ctx_t *i_ctx_p, os_ptr op, const ref * pstdin,
-	       const ref * pstdout, uint mcount, bool local)),
-    values_older_than(P4(const ref_stack_t * pstack, uint first, uint last,
-			 int max_space));
+    do_fork(i_ctx_t *i_ctx_p, os_ptr op, const ref * pstdin,
+	    const ref * pstdout, uint mcount, bool local),
+    values_older_than(const ref_stack_t * pstack, uint first, uint last,
+		      int max_space);
 private int
-    fork_done(P1(i_ctx_t *)),
-    fork_done_with_error(P1(i_ctx_t *)),
-    finish_join(P1(i_ctx_t *)),
-    reschedule_now(P1(i_ctx_t *));
+    fork_done(i_ctx_t *),
+    fork_done_with_error(i_ctx_t *),
+    finish_join(i_ctx_t *),
+    reschedule_now(i_ctx_t *);
 
 /* <mark> <obj1> ... <objN> <proc> .fork <context> */
 /* <mark> <obj1> ... <objN> <proc> <stdin|null> <stdout|null> */
@@ -920,11 +920,11 @@ zyield(i_ctx_t *i_ctx_p)
 /* ------ Condition and lock operators ------ */
 
 private int
-    monitor_cleanup(P1(i_ctx_t *)),
-    monitor_release(P1(i_ctx_t *)),
-    await_lock(P1(i_ctx_t *));
+    monitor_cleanup(i_ctx_t *),
+    monitor_release(i_ctx_t *),
+    await_lock(i_ctx_t *);
 private void
-     activate_waiting(P2(gs_scheduler_t *, ctx_list_t * pcl));
+     activate_waiting(gs_scheduler_t *, ctx_list_t * pcl);
 
 /* - condition <condition> */
 private int
diff --git a/gs/src/zcontrol.c b/gs/src/zcontrol.c
index e7f0b2e2d..be6056b6f 100644
--- a/gs/src/zcontrol.c
+++ b/gs/src/zcontrol.c
@@ -27,16 +27,16 @@
 #include "store.h"
 
 /* Forward references */
-private int no_cleanup(P1(i_ctx_t *));
-private uint count_exec_stack(P2(i_ctx_t *, bool));
-private uint count_to_stopped(P2(i_ctx_t *, long));
-private int unmatched_exit(P2(os_ptr, op_proc_t));
+private int no_cleanup(i_ctx_t *);
+private uint count_exec_stack(i_ctx_t *, bool);
+private uint count_to_stopped(i_ctx_t *, long);
+private int unmatched_exit(os_ptr, op_proc_t);
 
 /* See the comment in opdef.h for an invariant which allows */
 /* more efficient implementation of for, loop, and repeat. */
 
 /* <[test0 body0 ...]> .cond - */
-private int cond_continue(P1(i_ctx_t *));
+private int cond_continue(i_ctx_t *);
 private int
 zcond(i_ctx_t *i_ctx_p)
 {
@@ -152,7 +152,7 @@ zexecn(i_ctx_t *i_ctx_p)
 }
 
 /* <obj> superexec - */
-private int end_superexec(P1(i_ctx_t *));
+private int end_superexec(i_ctx_t *);
 private int
 zsuperexec(i_ctx_t *i_ctx_p)
 {
@@ -186,8 +186,8 @@ end_superexec(i_ctx_t *i_ctx_p)
 /* 	After execution, the array will be placed on  the top of the	*/
 /*	operand stack (on top of any elemetns pushed by <executable>	*/
 /*	for both the normal case and for the error case.		*/
-private int end_runandhide(P1(i_ctx_t *));
-private int err_end_runandhide(P1(i_ctx_t *));
+private int end_runandhide(i_ctx_t *);
+private int err_end_runandhide(i_ctx_t *);
 private int
 zrunandhide(i_ctx_t *i_ctx_p)
 {
@@ -293,9 +293,9 @@ zifelse(i_ctx_t *i_ctx_p)
 
 /* <init> <step> <limit> <proc> for - */
 private int
-    for_pos_int_continue(P1(i_ctx_t *)),
-    for_neg_int_continue(P1(i_ctx_t *)),
-    for_real_continue(P1(i_ctx_t *));
+    for_pos_int_continue(i_ctx_t *),
+    for_neg_int_continue(i_ctx_t *),
+    for_real_continue(i_ctx_t *);
 int
 zfor(i_ctx_t *i_ctx_p)
 {
@@ -417,7 +417,7 @@ for_real_continue(i_ctx_t *i_ctx_p)
  *
  * NOTE: This computation must match the SAMPLE_LOOP_VALUE macro in gscie.h.
  */
-private int for_samples_continue(P1(i_ctx_t *));
+private int for_samples_continue(i_ctx_t *);
 /* <first> <count> <last> <proc> %for_samples - */
 int
 zfor_samples(i_ctx_t *i_ctx_p)
@@ -464,7 +464,7 @@ for_samples_continue(i_ctx_t *i_ctx_p)
 }
 
 /* <int> <proc> repeat - */
-private int repeat_continue(P1(i_ctx_t *));
+private int repeat_continue(i_ctx_t *);
 private int
 zrepeat(i_ctx_t *i_ctx_p)
 {
@@ -500,7 +500,7 @@ repeat_continue(i_ctx_t *i_ctx_p)
 }
 
 /* <proc> loop */
-private int loop_continue(P1(i_ctx_t *));
+private int loop_continue(i_ctx_t *);
 private int
 zloop(i_ctx_t *i_ctx_p)
 {
@@ -724,8 +724,8 @@ zcountexecstack1(i_ctx_t *i_ctx_p)
 /* <array> <include_marks> .execstack <subarray> */
 /* <array> execstack <subarray> */
 /* execstack is an operator solely for the sake of the Genoa tests. */
-private int execstack_continue(P1(i_ctx_t *));
-private int execstack2_continue(P1(i_ctx_t *));
+private int execstack_continue(i_ctx_t *);
+private int execstack2_continue(i_ctx_t *);
 private int
 push_execstack(i_ctx_t *i_ctx_p, os_ptr op1, bool include_marks,
 	       op_proc_t cont)
@@ -856,7 +856,7 @@ zquit(i_ctx_t *i_ctx_p)
 }
 
 /* - currentfile <file> */
-private ref *zget_current_file(P1(i_ctx_t *));
+private ref *zget_current_file(i_ctx_t *);
 private int
 zcurrentfile(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zcrd.c b/gs/src/zcrd.c
index 47feb4e2f..771fa8f7e 100644
--- a/gs/src/zcrd.c
+++ b/gs/src/zcrd.c
@@ -35,12 +35,12 @@
 #include "store.h"		/* for make_null */
 
 /* Forward references */
-private int zcrd1_proc_params(P2(os_ptr op, ref_cie_render_procs * pcprocs));
-private int zcrd1_params(P4(os_ptr op, gs_cie_render * pcrd,
-			ref_cie_render_procs * pcprocs, gs_memory_t * mem));
-private int cache_colorrendering1(P4(i_ctx_t *i_ctx_p, gs_cie_render * pcrd,
-				     const ref_cie_render_procs * pcprocs,
-				     gs_ref_memory_t * imem));
+private int zcrd1_proc_params(os_ptr op, ref_cie_render_procs * pcprocs);
+private int zcrd1_params(os_ptr op, gs_cie_render * pcrd,
+			 ref_cie_render_procs * pcprocs, gs_memory_t * mem);
+private int cache_colorrendering1(i_ctx_t *i_ctx_p, gs_cie_render * pcrd,
+				  const ref_cie_render_procs * pcprocs,
+				  gs_ref_memory_t * imem);
 
 /* - currentcolorrendering <dict> */
 private int
@@ -247,7 +247,7 @@ zcrd1_params(os_ptr op, gs_cie_render * pcrd,
 }
 
 /* Cache the results of the color rendering procedures. */
-private int cie_cache_render_finish(P1(i_ctx_t *));
+private int cie_cache_render_finish(i_ctx_t *);
 private int
 cache_colorrendering1(i_ctx_t *i_ctx_p, gs_cie_render * pcrd,
 		      const ref_cie_render_procs * pcrprocs,
@@ -322,9 +322,9 @@ cie_cache_render_finish(i_ctx_t *i_ctx_p)
 
 /* Load the joint caches. */
 private int
-    cie_exec_tpqr(P1(i_ctx_t *)),
-    cie_post_exec_tpqr(P1(i_ctx_t *)),
-    cie_tpqr_finish(P1(i_ctx_t *));
+    cie_exec_tpqr(i_ctx_t *),
+    cie_post_exec_tpqr(i_ctx_t *),
+    cie_tpqr_finish(i_ctx_t *);
 int
 cie_cache_joint(i_ctx_t *i_ctx_p, const ref_cie_render_procs * pcrprocs,
 		const gs_cie_common *pcie, gs_state * pgs)
diff --git a/gs/src/zcsindex.c b/gs/src/zcsindex.c
index 07660ce81..1bada4591 100644
--- a/gs/src/zcsindex.c
+++ b/gs/src/zcsindex.c
@@ -36,7 +36,7 @@
 extern const gs_color_space_type gs_color_space_type_Indexed;
 
 /* Forward references. */
-private int indexed_map1(P1(i_ctx_t *));
+private int indexed_map1(i_ctx_t *);
 
 /* <array> .setindexedspace - */
 /* The current color space is the base space for the indexed space. */
diff --git a/gs/src/zcssepr.c b/gs/src/zcssepr.c
index 023274ef2..bd406e9cf 100644
--- a/gs/src/zcssepr.c
+++ b/gs/src/zcssepr.c
@@ -39,7 +39,7 @@
 extern const gs_color_space_type gs_color_space_type_Separation;
 
 /* Forward references */
-private int separation_map1(P1(i_ctx_t *));
+private int separation_map1(i_ctx_t *);
 
 /* Define the separation cache size.  This makes many useful tint values */
 /* map to integer cache indices. */
diff --git a/gs/src/zdevice2.c b/gs/src/zdevice2.c
index 2b0826fb4..d5539a63f 100644
--- a/gs/src/zdevice2.c
+++ b/gs/src/zdevice2.c
@@ -32,8 +32,8 @@
 #include "gsstate.h"
 
 /* Forward references */
-private int z2copy_gstate(P1(i_ctx_t *));
-private int push_callout(P2(i_ctx_t *, const char *));
+private int z2copy_gstate(i_ctx_t *);
+private int push_callout(i_ctx_t *, const char *);
 
 /* Extend the `copy' operator to deal with gstates. */
 /* This is done with a hack -- we know that gstates are the only */
diff --git a/gs/src/zdouble.c b/gs/src/zdouble.c
index 406d0d4a7..ea391b95e 100644
--- a/gs/src/zdouble.c
+++ b/gs/src/zdouble.c
@@ -36,10 +36,10 @@
  */
 
 /* Forward references */
-private int double_params_result(P3(os_ptr, int, double *));
-private int double_params(P3(os_ptr, int, double *));
-private int double_result(P3(i_ctx_t *, int, double));
-private int double_unary(P2(i_ctx_t *, double (*)(P1(double))));
+private int double_params_result(os_ptr, int, double *);
+private int double_params(os_ptr, int, double *);
+private int double_result(i_ctx_t *, int, double);
+private int double_unary(i_ctx_t *, double (*)(double));
 
 #define dbegin_unary()\
 	os_ptr op = osp;\
@@ -153,7 +153,7 @@ zdtruncate(i_ctx_t *i_ctx_p)
 /* ------ Transcendental functions ------ */
 
 private int
-darc(i_ctx_t *i_ctx_p, double (*afunc)(P1(double)))
+darc(i_ctx_t *i_ctx_p, double (*afunc)(double))
 {
     dbegin_unary();
     return double_result(i_ctx_p, 1, (*afunc)(num) * radians_to_degrees);
@@ -212,7 +212,7 @@ zdexp(i_ctx_t *i_ctx_p)
 }
 
 private int
-dlog(i_ctx_t *i_ctx_p, double (*lfunc)(P1(double)))
+dlog(i_ctx_t *i_ctx_p, double (*lfunc)(double))
 {
     dbegin_unary();
     if (num <= 0.0)
@@ -530,7 +530,7 @@ double_result(i_ctx_t *i_ctx_p, int count, double result)
 
 /* Apply a unary function to a double operand. */
 private int
-double_unary(i_ctx_t *i_ctx_p, double (*func)(P1(double)))
+double_unary(i_ctx_t *i_ctx_p, double (*func)(double))
 {
     dbegin_unary();
     return double_result(i_ctx_p, 1, (*func)(num));
diff --git a/gs/src/zdpnext.c b/gs/src/zdpnext.c
index 19c08dad6..517214b73 100644
--- a/gs/src/zdpnext.c
+++ b/gs/src/zdpnext.c
@@ -77,7 +77,7 @@ zsetalpha(i_ctx_t *i_ctx_p)
  */
 
 /* Imported procedures */
-int zimage_multiple(P2(i_ctx_t *i_ctx_p, bool has_alpha));  /* in zcolor1.c */
+int zimage_multiple(i_ctx_t *i_ctx_p, bool has_alpha);  /* in zcolor1.c */
 
 /*
  * Define the operand and bookeeping structure for a compositing operation.
@@ -92,9 +92,9 @@ typedef struct alpha_composite_state_s {
 } alpha_composite_state_t;
 
 /* Forward references */
-private int begin_composite(P2(i_ctx_t *, alpha_composite_state_t *));
-private void end_composite(P2(i_ctx_t *, alpha_composite_state_t *));
-private int xywh_param(P2(os_ptr, double[4]));
+private int begin_composite(i_ctx_t *, alpha_composite_state_t *);
+private void end_composite(i_ctx_t *, alpha_composite_state_t *);
+private int xywh_param(os_ptr, double[4]);
 
 /* <width> <height> <bits/comp> <matrix> */
 /*      <datasrc_0> ... <datasrc_ncomp-1> true <ncomp> alphaimage - */
@@ -220,11 +220,11 @@ zdissolve(i_ctx_t *i_ctx_p)
 
 /* ------ Image reading ------ */
 
-private int device_is_true_color(P1(gx_device * dev));
+private int device_is_true_color(gx_device * dev);
 
 /* <x> <y> <width> <height> <matrix> .sizeimagebox */
 /*   <dev_x> <dev_y> <dev_width> <dev_height> <matrix> */
-private void box_confine(P3(int *pp, int *pq, int wh));
+private void box_confine(int *pp, int *pq, int wh);
 private int
 zsizeimagebox(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zdps.c b/gs/src/zdps.c
index e121e9563..a25b2e800 100644
--- a/gs/src/zdps.c
+++ b/gs/src/zdps.c
@@ -34,7 +34,7 @@
 #include "store.h"
 
 /* Import the procedure for constructing user paths. */
-extern int make_upath(P5(i_ctx_t *, ref *, const gs_state *, gx_path *, bool));
+extern int make_upath(i_ctx_t *, ref *, const gs_state *, gx_path *, bool);
 
 /* ------ Graphics state ------ */
 
diff --git a/gs/src/zdps1.c b/gs/src/zdps1.c
index 91192f716..ecf980404 100644
--- a/gs/src/zdps1.c
+++ b/gs/src/zdps1.c
@@ -30,7 +30,7 @@
 #include "ibnum.h"
 
 /* Forward references */
-private int gstate_unshare(P1(i_ctx_t *));
+private int gstate_unshare(i_ctx_t *);
 
 /* Structure descriptors */
 public_st_igstate_obj();
@@ -241,8 +241,8 @@ typedef struct local_rects_s {
 } local_rects_t;
 
 /* Forward references */
-private int rect_get(P3(local_rects_t *, os_ptr, gs_memory_t *));
-private void rect_release(P2(local_rects_t *, gs_memory_t *));
+private int rect_get(local_rects_t *, os_ptr, gs_memory_t *);
+private void rect_release(local_rects_t *, gs_memory_t *);
 
 /* <x> <y> <width> <height> .rectappend - */
 /* <numarray|numstring> .rectappend - */
diff --git a/gs/src/zdscpars.c b/gs/src/zdscpars.c
index 342023e1b..c615eb1af 100644
--- a/gs/src/zdscpars.c
+++ b/gs/src/zdscpars.c
@@ -103,7 +103,7 @@ typedef struct dsc_data_s {
 } dsc_data_t;
 
 /* Structure descriptors */
-private void dsc_finalize(P1(void *vptr));
+private void dsc_finalize(void *vptr);
 gs_private_st_simple_final(st_dsc_data_t, dsc_data_t, "dsc_data_struct", dsc_finalize);
 
 /* Define the key name for storing the instance pointer in a dictionary. */
@@ -349,7 +349,7 @@ dsc_viewing_orientation(gs_param_list *plist, const CDSC *pData)
 typedef struct cmd_list_s {
     int code;			/* Russell's DSC parser code (see dsc.h) */
     const char *comment_name;	/* A name to be returned to postscript caller */
-    int (*dsc_proc) (P2(gs_param_list *, const CDSC *));
+    int (*dsc_proc) (gs_param_list *, const CDSC *);
 				/* A routine for transferring parameter values
 				   from C data structure to postscript dictionary
 				   key/value pairs. */
diff --git a/gs/src/zfile.c b/gs/src/zfile.c
index f78da773b..7fff6d0df 100644
--- a/gs/src/zfile.c
+++ b/gs/src/zfile.c
@@ -51,21 +51,21 @@ extern_gx_io_device_table();
 extern const char iodev_dtype_stdio[];
 
 /* Forward references: file name parsing. */
-private int parse_file_name(P2(const ref * op, gs_parsed_file_name_t * pfn));
-private int parse_real_file_name(P4(const ref * op,
-				    gs_parsed_file_name_t * pfn,
-				    gs_memory_t *mem, client_name_t cname));
-private int parse_file_access_string(P2(const ref *op, char file_access[4]));
+private int parse_file_name(const ref * op, gs_parsed_file_name_t * pfn);
+private int parse_real_file_name(const ref * op,
+				 gs_parsed_file_name_t * pfn,
+				 gs_memory_t *mem, client_name_t cname);
+private int parse_file_access_string(const ref *op, char file_access[4]);
 
 /* Forward references: other. */
-private int execfile_finish(P1(i_ctx_t *));
-private int execfile_cleanup(P1(i_ctx_t *));
-private int zopen_file(P5(i_ctx_t *, const gs_parsed_file_name_t *pfn,
-			  const char *file_access, stream **ps,
-			  gs_memory_t *mem));
+private int execfile_finish(i_ctx_t *);
+private int execfile_cleanup(i_ctx_t *);
+private int zopen_file(i_ctx_t *, const gs_parsed_file_name_t *pfn,
+		       const char *file_access, stream **ps,
+		       gs_memory_t *mem);
 private iodev_proc_open_file(iodev_os_open_file);
-private void file_init_stream(P5(stream *s, FILE *file, const char *fmode,
-				 byte *buffer, uint buffer_size));
+private void file_init_stream(stream *s, FILE *file, const char *fmode,
+			      byte *buffer, uint buffer_size);
 stream_proc_report_error(filter_report_error);
 
 /*
@@ -311,8 +311,8 @@ zdeletefile(i_ctx_t *i_ctx_p)
 }
 
 /* <template> <proc> <scratch> filenameforall - */
-private int file_continue(P1(i_ctx_t *));
-private int file_cleanup(P1(i_ctx_t *));
+private int file_continue(i_ctx_t *);
+private int file_cleanup(i_ctx_t *);
 private int
 zfilenameforall(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zfileio.c b/gs/src/zfileio.c
index 661d725ba..16f50e63b 100644
--- a/gs/src/zfileio.c
+++ b/gs/src/zfileio.c
@@ -32,11 +32,11 @@
 #include "estack.h"
 
 /* Forward references */
-private int write_string(P2(ref *, stream *));
-private int handle_read_status(P5(i_ctx_t *, int, const ref *, const uint *,
-				  op_proc_t));
-private int handle_write_status(P5(i_ctx_t *, int, const ref *, const uint *,
-				   op_proc_t));
+private int write_string(ref *, stream *);
+private int handle_read_status(i_ctx_t *, int, const ref *, const uint *,
+			       op_proc_t);
+private int handle_write_status(i_ctx_t *, int, const ref *, const uint *,
+				op_proc_t);
 
 /* ------ Operators ------ */
 
@@ -107,7 +107,7 @@ zwrite(i_ctx_t *i_ctx_p)
 }
 
 /* <file> <string> readhexstring <substring> <filled_bool> */
-private int zreadhexstring_continue(P1(i_ctx_t *));
+private int zreadhexstring_continue(i_ctx_t *);
 
 /* We keep track of the odd digit in the next byte of the string */
 /* beyond the bytes already used.  (This is just for convenience; */
@@ -193,7 +193,7 @@ zreadhexstring_continue(i_ctx_t *i_ctx_p)
 }
 
 /* <file> <string> writehexstring - */
-private int zwritehexstring_continue(P1(i_ctx_t *));
+private int zwritehexstring_continue(i_ctx_t *);
 private int
 zwritehexstring_at(i_ctx_t *i_ctx_p, os_ptr op, uint odd)
 {
@@ -272,7 +272,7 @@ zwritehexstring_continue(i_ctx_t *i_ctx_p)
 }
 
 /* <file> <string> readstring <substring> <filled_bool> */
-private int zreadstring_continue(P1(i_ctx_t *));
+private int zreadstring_continue(i_ctx_t *);
 private int
 zreadstring_at(i_ctx_t *i_ctx_p, os_ptr op, uint start)
 {
@@ -350,8 +350,8 @@ zwritestring(i_ctx_t *i_ctx_p)
 }
 
 /* <file> <string> readline <substring> <bool> */
-private int zreadline(P1(i_ctx_t *));
-private int zreadline_continue(P1(i_ctx_t *));
+private int zreadline(i_ctx_t *);
+private int zreadline_continue(i_ctx_t *);
 
 /*
  * We could handle readline the same way as readstring,
@@ -734,7 +734,7 @@ zunread(i_ctx_t *i_ctx_p)
 }
 
 /* <file> <obj> <==flag> .writecvp - */
-private int zwritecvp_continue(P1(i_ctx_t *));
+private int zwritecvp_continue(i_ctx_t *);
 private int
 zwritecvp_at(i_ctx_t *i_ctx_p, os_ptr op, uint start, bool first)
 {
diff --git a/gs/src/zfilter.c b/gs/src/zfilter.c
index 91cfd22f3..641da2214 100644
--- a/gs/src/zfilter.c
+++ b/gs/src/zfilter.c
@@ -169,7 +169,7 @@ zSFD(i_ctx_t *i_ctx_p)
 /* ------ Utilities ------ */
 
 /* Forward references */
-private int filter_ensure_buf(P4(stream **, uint, gs_ref_memory_t *, bool));
+private int filter_ensure_buf(stream **, uint, gs_ref_memory_t *, bool);
 
 /* Set up an input filter. */
 int
diff --git a/gs/src/zfont.c b/gs/src/zfont.c
index 9af19171d..3da681a05 100644
--- a/gs/src/zfont.c
+++ b/gs/src/zfont.c
@@ -33,8 +33,8 @@
 #include "ivmspace.h"
 
 /* Forward references */
-private int make_font(P2(i_ctx_t *, const gs_matrix *));
-private void make_uint_array(P3(os_ptr, const uint *, int));
+private int make_font(i_ctx_t *, const gs_matrix *);
+private void make_uint_array(os_ptr, const uint *, int);
 
 /* The (global) font directory */
 gs_font_dir *ifont_dir = 0;	/* needed for buildfont */
diff --git a/gs/src/zfont0.c b/gs/src/zfont0.c
index 8029427b1..bd64b33fc 100644
--- a/gs/src/zfont0.c
+++ b/gs/src/zfont0.c
@@ -42,13 +42,13 @@
 #include "store.h"
 
 /* Imported from zfcmap.c */
-int ztype0_get_cmap(P4(const gs_cmap_t ** ppcmap, const ref * pfdepvector,
-		       const ref * op, gs_memory_t *imem));
+int ztype0_get_cmap(const gs_cmap_t ** ppcmap, const ref * pfdepvector,
+		    const ref * op, gs_memory_t *imem);
 
 /* Forward references */
 private font_proc_define_font(ztype0_define_font);
 private font_proc_make_font(ztype0_make_font);
-private int ensure_char_entry(P5(i_ctx_t *, os_ptr, const char *, byte *, int));
+private int ensure_char_entry(i_ctx_t *, os_ptr, const char *, byte *, int);
 
 /* <string|name> <font_dict> .buildfont0 <string|name> <font> */
 /* Build a type 0 (composite) font. */
diff --git a/gs/src/zfont42.c b/gs/src/zfont42.c
index da40b131b..f7e623d2a 100644
--- a/gs/src/zfont42.c
+++ b/gs/src/zfont42.c
@@ -32,9 +32,9 @@
 #include "store.h"
 
 /* Forward references */
-private int z42_string_proc(P4(gs_font_type42 *, ulong, uint, const byte **));
-private uint z42_get_glyph_index(P2(gs_font_type42 *, gs_glyph));
-private int z42_gdir_get_outline(P3(gs_font_type42 *, uint, gs_glyph_data_t *));
+private int z42_string_proc(gs_font_type42 *, ulong, uint, const byte **);
+private uint z42_get_glyph_index(gs_font_type42 *, gs_glyph);
+private int z42_gdir_get_outline(gs_font_type42 *, uint, gs_glyph_data_t *);
 private font_proc_enumerate_glyph(z42_enumerate_glyph);
 private font_proc_enumerate_glyph(z42_gdir_enumerate_glyph);
 private font_proc_encode_char(z42_encode_char);
diff --git a/gs/src/zfproc.c b/gs/src/zfproc.c
index db6e23dcf..c6318d88a 100644
--- a/gs/src/zfproc.c
+++ b/gs/src/zfproc.c
@@ -128,7 +128,7 @@ s_proc_set_defaults(stream_state * st)
 
 /* Forward references */
 private stream_proc_process(s_proc_read_process);
-private int s_proc_read_continue(P1(i_ctx_t *));
+private int s_proc_read_continue(i_ctx_t *);
 
 /* Stream templates */
 private const stream_template s_proc_read_template = {
@@ -248,7 +248,7 @@ s_proc_read_continue(i_ctx_t *i_ctx_p)
 /* Forward references */
 private stream_proc_flush(s_proc_write_flush);
 private stream_proc_process(s_proc_write_process);
-private int s_proc_write_continue(P1(i_ctx_t *));
+private int s_proc_write_continue(i_ctx_t *);
 
 /* Stream templates */
 private const stream_template s_proc_write_template = {
diff --git a/gs/src/zfrsd.c b/gs/src/zfrsd.c
index 6987919ce..5f2f4c800 100644
--- a/gs/src/zfrsd.c
+++ b/gs/src/zfrsd.c
@@ -116,11 +116,11 @@ zrsdparams(i_ctx_t *i_ctx_p)
  * Reusable streams are also reusable sources, but they look just like
  * ordinary file or string streams.
  */
-private int make_rss(P8(i_ctx_t *i_ctx_p, os_ptr op, const byte * data,
-			uint size, int space, long offset, long length,
-			bool is_bytestring));
-private int make_rfs(P5(i_ctx_t *i_ctx_p, os_ptr op, stream *fs,
-			long offset, long length));
+private int make_rss(i_ctx_t *i_ctx_p, os_ptr op, const byte * data,
+		     uint size, int space, long offset, long length,
+		     bool is_bytestring);
+private int make_rfs(i_ctx_t *i_ctx_p, os_ptr op, stream *fs,
+		     long offset, long length);
 private int
 zreusablestream(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zfsample.c b/gs/src/zfsample.c
index a1569ff29..10392627c 100644
--- a/gs/src/zfsample.c
+++ b/gs/src/zfsample.c
@@ -68,7 +68,7 @@ gs_private_st_ptrs1(st_gs_sampled_data_enum, gs_sampled_data_enum,
 private int cube_build_func0(const ref * pdict,
 	gs_function_Sd_params_t * params, gs_memory_t *mem);
 private int sampled_data_setup(i_ctx_t *i_ctx_p, gs_function_t *pfn,
-	const ref * pproc, int (*finish_proc)(P1(i_ctx_t *)),
+	const ref * pproc, int (*finish_proc)(i_ctx_t *),
 	gs_memory_t * mem);
 private int sampled_data_sample(i_ctx_t *i_ctx_p);
 private int sampled_data_continue(i_ctx_t *i_ctx_p);
@@ -379,7 +379,7 @@ fail:
  */
 private int
 sampled_data_setup(i_ctx_t *i_ctx_p, gs_function_t *pfn,
-	const ref * pproc, int (*finish_proc)(P1(i_ctx_t *)), gs_memory_t * mem)
+	const ref * pproc, int (*finish_proc)(i_ctx_t *), gs_memory_t * mem)
 {
     gs_sampled_data_enum *penum;
     int i;
diff --git a/gs/src/zfunc4.c b/gs/src/zfunc4.c
index 74f1c5663..f1d4c8776 100644
--- a/gs/src/zfunc4.c
+++ b/gs/src/zfunc4.c
@@ -41,7 +41,7 @@
  *
  * The following list is taken directly from the PDF 1.3 documentation.
  */
-#define XOP(zfn) int zfn(P1(i_ctx_t *))
+#define XOP(zfn) int zfn(i_ctx_t *)
 XOP(zabs); XOP(zand); XOP(zatan); XOP(zbitshift);
 XOP(zceiling); XOP(zcos); XOP(zcvi); XOP(zcvr);
 XOP(zdiv); XOP(zexp); XOP(zfloor); XOP(zidiv);
diff --git a/gs/src/zgeneric.c b/gs/src/zgeneric.c
index a2e3d24a5..185671fb9 100644
--- a/gs/src/zgeneric.c
+++ b/gs/src/zgeneric.c
@@ -37,9 +37,9 @@
 /* more efficient implementation of forall. */
 
 /* Forward references */
-private int zcopy_integer(P1(i_ctx_t *));
-private int zcopy_interval(P1(i_ctx_t *));
-private int copy_interval(P5(i_ctx_t *, os_ptr, uint, os_ptr, client_name_t));
+private int zcopy_integer(i_ctx_t *);
+private int zcopy_interval(i_ctx_t *);
+private int copy_interval(i_ctx_t *, os_ptr, uint, os_ptr, client_name_t);
 
 /* <various1> <various2> copy <various> */
 /* <obj1> ... <objn> <int> copy <obj1> ... <objn> <obj1> ... <objn> */
@@ -390,11 +390,11 @@ zputinterval(i_ctx_t *i_ctx_p)
 /* <array|packedarray|string> <<element> proc> forall - */
 /* <dict> <<key> <value> proc> forall - */
 private int
-    array_continue(P1(i_ctx_t *)),
-    dict_continue(P1(i_ctx_t *)),
-    string_continue(P1(i_ctx_t *)),
-    packedarray_continue(P1(i_ctx_t *));
-private int forall_cleanup(P1(i_ctx_t *));
+    array_continue(i_ctx_t *),
+    dict_continue(i_ctx_t *),
+    string_continue(i_ctx_t *),
+    packedarray_continue(i_ctx_t *);
+private int forall_cleanup(i_ctx_t *);
 private int
 zforall(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zgstate.c b/gs/src/zgstate.c
index 7960bc268..74c7f1040 100644
--- a/gs/src/zgstate.c
+++ b/gs/src/zgstate.c
@@ -34,7 +34,7 @@ private_st_int_remap_color_info();
 /* ------ Utilities ------ */
 
 private int
-zset_real(i_ctx_t *i_ctx_p, int (*set_proc)(P2(gs_state *, floatp)))
+zset_real(i_ctx_t *i_ctx_p, int (*set_proc)(gs_state *, floatp))
 {
     os_ptr op = osp;
     double param;
@@ -49,7 +49,7 @@ zset_real(i_ctx_t *i_ctx_p, int (*set_proc)(P2(gs_state *, floatp)))
 }
 
 private int
-zset_bool(i_ctx_t *i_ctx_p, void (*set_proc)(P2(gs_state *, bool)))
+zset_bool(i_ctx_t *i_ctx_p, void (*set_proc)(gs_state *, bool))
 {
     os_ptr op = osp;
 
@@ -60,7 +60,7 @@ zset_bool(i_ctx_t *i_ctx_p, void (*set_proc)(P2(gs_state *, bool)))
 }
 
 private int
-zcurrent_bool(i_ctx_t *i_ctx_p, bool (*current_proc)(P1(const gs_state *)))
+zcurrent_bool(i_ctx_t *i_ctx_p, bool (*current_proc)(const gs_state *))
 {
     os_ptr op = osp;
 
@@ -72,9 +72,9 @@ zcurrent_bool(i_ctx_t *i_ctx_p, bool (*current_proc)(P1(const gs_state *)))
 /* ------ Operations on the entire graphics state ------ */
 
 /* "Client" procedures */
-private void *gs_istate_alloc(P1(gs_memory_t * mem));
-private int gs_istate_copy(P2(void *to, const void *from));
-private void gs_istate_free(P2(void *old, gs_memory_t * mem));
+private void *gs_istate_alloc(gs_memory_t * mem);
+private int gs_istate_copy(void *to, const void *from);
+private void gs_istate_free(void *old, gs_memory_t * mem);
 private const gs_state_client_procs istate_procs = {
     gs_istate_alloc,
     gs_istate_copy,
diff --git a/gs/src/zht.c b/gs/src/zht.c
index 27ccb5475..09f21de63 100644
--- a/gs/src/zht.c
+++ b/gs/src/zht.c
@@ -32,9 +32,9 @@
 #include "store.h"
 
 /* Forward references */
-private int screen_sample(P1(i_ctx_t *));
-private int set_screen_continue(P1(i_ctx_t *));
-private int screen_cleanup(P1(i_ctx_t *));
+private int screen_sample(i_ctx_t *);
+private int set_screen_continue(i_ctx_t *);
+private int screen_cleanup(i_ctx_t *);
 
 /* - .currenthalftone <dict> 0 */
 /* - .currenthalftone <frequency> <angle> <proc> 1 */
@@ -106,7 +106,7 @@ zcurrentscreenlevels(i_ctx_t *i_ctx_p)
 #define senum r_ptr(esp, gs_screen_enum)
 
 /* Forward references */
-private int setscreen_finish(P1(i_ctx_t *));
+private int setscreen_finish(i_ctx_t *);
 
 /* <frequency> <angle> <proc> setscreen - */
 private int
@@ -137,7 +137,7 @@ zsetscreen(i_ctx_t *i_ctx_p)
 int
 zscreen_enum_init(i_ctx_t *i_ctx_p, const gx_ht_order * porder,
 		  gs_screen_halftone * psp, ref * pproc, int npop,
-		  int (*finish_proc)(P1(i_ctx_t *)), gs_memory_t * mem)
+		  int (*finish_proc)(i_ctx_t *), gs_memory_t * mem)
 {
     gs_screen_enum *penum;
     int code;
diff --git a/gs/src/zht1.c b/gs/src/zht1.c
index cf267abed..c4be1aeec 100644
--- a/gs/src/zht1.c
+++ b/gs/src/zht1.c
@@ -39,8 +39,8 @@ spot_dummy(floatp x, floatp y)
 }
 
 /* <red_freq> ... <gray_proc> setcolorscreen - */
-private int setcolorscreen_finish(P1(i_ctx_t *));
-private int setcolorscreen_cleanup(P1(i_ctx_t *));
+private int setcolorscreen_finish(i_ctx_t *);
+private int setcolorscreen_cleanup(i_ctx_t *);
 private int
 zsetcolorscreen(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zht2.c b/gs/src/zht2.c
index 75be917b1..1d33f5820 100644
--- a/gs/src/zht2.c
+++ b/gs/src/zht2.c
@@ -31,13 +31,12 @@
 #include "store.h"
 
 /* Forward references */
-private int dict_spot_params(P4(const ref *, gs_spot_halftone *,
-				ref *, ref *));
-private int dict_spot_results(P3(i_ctx_t *, ref *, const gs_spot_halftone *));
-private int dict_threshold_params(P3(const ref *, gs_threshold_halftone *,
-				     ref *));
-private int dict_threshold2_params(P4(const ref *, gs_threshold2_halftone *,
-				      ref *, gs_memory_t *));
+private int dict_spot_params(const ref *, gs_spot_halftone *, ref *, ref *);
+private int dict_spot_results(i_ctx_t *, ref *, const gs_spot_halftone *);
+private int dict_threshold_params(const ref *, gs_threshold_halftone *,
+				  ref *);
+private int dict_threshold2_params(const ref *, gs_threshold2_halftone *,
+				   ref *, gs_memory_t *);
 
 /* Dummy spot function */
 private float
@@ -47,8 +46,8 @@ spot1_dummy(floatp x, floatp y)
 }
 
 /* <dict> <dict5> .sethalftone5 - */
-private int sethalftone_finish(P1(i_ctx_t *));
-private int sethalftone_cleanup(P1(i_ctx_t *));
+private int sethalftone_finish(i_ctx_t *);
+private int sethalftone_cleanup(i_ctx_t *);
 private int
 zsethalftone5(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zimage.c b/gs/src/zimage.c
index 3ec8fc5d8..c11ceb050 100644
--- a/gs/src/zimage.c
+++ b/gs/src/zimage.c
@@ -35,12 +35,12 @@
 #include "iimage.h"
 
 /* Forward references */
-private int image_setup(P5(i_ctx_t *i_ctx_p, os_ptr op, gs_image_t * pim,
-			   const gs_color_space * pcs, int npop));
-private int image_proc_process(P1(i_ctx_t *));
-private int image_file_continue(P1(i_ctx_t *));
-private int image_string_continue(P1(i_ctx_t *));
-private int image_cleanup(P1(i_ctx_t *));
+private int image_setup(i_ctx_t *i_ctx_p, os_ptr op, gs_image_t * pim,
+			const gs_color_space * pcs, int npop);
+private int image_proc_process(i_ctx_t *);
+private int image_file_continue(i_ctx_t *);
+private int image_string_continue(i_ctx_t *);
+private int image_cleanup(i_ctx_t *);
 
 /* <width> <height> <bits/sample> <matrix> <datasrc> image - */
 int
diff --git a/gs/src/ziodevs.c b/gs/src/ziodevs.c
index 5b214275d..05ac00955 100644
--- a/gs/src/ziodevs.c
+++ b/gs/src/ziodevs.c
@@ -76,8 +76,8 @@ const gx_io_device gs_iodev_stderr =
  */
 
 private int
-    s_stdin_read_process(P4(stream_state *, stream_cursor_read *,
-			    stream_cursor_write *, bool));
+    s_stdin_read_process(stream_state *, stream_cursor_read *,
+			 stream_cursor_write *, bool);
 
 private int
 stdin_init(gx_io_device * iodev, gs_memory_t * mem)
diff --git a/gs/src/zmatrix.c b/gs/src/zmatrix.c
index 169f47cf1..dc4f6cede 100644
--- a/gs/src/zmatrix.c
+++ b/gs/src/zmatrix.c
@@ -24,9 +24,9 @@
 #include "store.h"
 
 /* Forward references */
-private int common_transform(P3(i_ctx_t *,
-		int (*)(P4(gs_state *, floatp, floatp, gs_point *)),
-		int (*)(P4(floatp, floatp, const gs_matrix *, gs_point *))));
+private int common_transform(i_ctx_t *,
+		int (*)(gs_state *, floatp, floatp, gs_point *),
+		int (*)(floatp, floatp, const gs_matrix *, gs_point *));
 
 /* - initmatrix - */
 private int
@@ -266,8 +266,8 @@ zidtransform(i_ctx_t *i_ctx_p)
 /* Common logic for [i][d]transform */
 private int
 common_transform(i_ctx_t *i_ctx_p,
-	int (*ptproc)(P4(gs_state *, floatp, floatp, gs_point *)),
-	int (*matproc)(P4(floatp, floatp, const gs_matrix *, gs_point *)))
+	int (*ptproc)(gs_state *, floatp, floatp, gs_point *),
+	int (*matproc)(floatp, floatp, const gs_matrix *, gs_point *))
 {
     os_ptr op = osp;
     double opxy[2];
diff --git a/gs/src/zmedia2.c b/gs/src/zmedia2.c
index 0745c1033..f1ed42b51 100644
--- a/gs/src/zmedia2.c
+++ b/gs/src/zmedia2.c
@@ -29,10 +29,10 @@
 /* <pagedict> <attrdict> <policydict> <keys> .matchmedia <key> true */
 /* <pagedict> <attrdict> <policydict> <keys> .matchmedia false */
 /* <pagedict> null <policydict> <keys> .matchmedia null true */
-private int zmatch_page_size(P8(const ref * pvreq, const ref * pvmed,
-				int policy, int orient, bool roll,
-				float *best_mismatch, gs_matrix * pmat,
-				gs_point * pmsize));
+private int zmatch_page_size(const ref * pvreq, const ref * pvmed,
+			     int policy, int orient, bool roll,
+			     float *best_mismatch, gs_matrix * pmat,
+			     gs_point * pmsize);
 typedef struct match_record_s {
     ref best_key, match_key;
     uint priority, no_match_priority;
@@ -265,11 +265,11 @@ zmatchpagesize(i_ctx_t *i_ctx_p)
     return 0;
 }
 /* Match the PageSize.  See below for details. */
-private bool match_page_size(P8(const gs_point * request,
-				const gs_rect * medium,
-				int policy, int orient, bool roll,
-				float *best_mismatch, gs_matrix * pmat,
-				gs_point * pmsize));
+private bool match_page_size(const gs_point * request,
+			     const gs_rect * medium,
+			     int policy, int orient, bool roll,
+			     float *best_mismatch, gs_matrix * pmat,
+			     gs_point * pmsize);
 private int
 zmatch_page_size(const ref * pvreq, const ref * pvmed,
 		 int policy, int orient, bool roll,
@@ -324,10 +324,10 @@ zmatch_page_size(const ref * pvreq, const ref * pvmed,
  * NOTE: The algorithm here doesn't work properly for variable-size media
  * when the match isn't exact.  We'll fix it if we ever need to.
  */
-private void make_adjustment_matrix(P5(const gs_point * request,
-				       const gs_rect * medium,
-				       gs_matrix * pmat,
-				       bool scale, int rotate));
+private void make_adjustment_matrix(const gs_point * request,
+				    const gs_rect * medium,
+				    gs_matrix * pmat,
+				    bool scale, int rotate);
 private bool
 match_page_size(const gs_point * request, const gs_rect * medium, int policy,
 		int orient, bool roll, float *best_mismatch, gs_matrix * pmat,
diff --git a/gs/src/zmisc1.c b/gs/src/zmisc1.c
index 0fb7730f6..2deee2190 100644
--- a/gs/src/zmisc1.c
+++ b/gs/src/zmisc1.c
@@ -29,8 +29,8 @@
 
 /* <state> <from_string> <to_string> .type1encrypt <new_state> <substring> */
 /* <state> <from_string> <to_string> .type1decrypt <new_state> <substring> */
-private int type1crypt(P2(i_ctx_t *,
-			int (*)(P4(byte *, const byte *, uint, ushort *))));
+private int type1crypt(i_ctx_t *,
+		       int (*)(byte *, const byte *, uint, ushort *));
 private int
 ztype1encrypt(i_ctx_t *i_ctx_p)
 {
@@ -43,7 +43,7 @@ ztype1decrypt(i_ctx_t *i_ctx_p)
 }
 private int
 type1crypt(i_ctx_t *i_ctx_p,
-	   int (*proc)(P4(byte *, const byte *, uint, ushort *)))
+	   int (*proc)(byte *, const byte *, uint, ushort *))
 {
     os_ptr op = osp;
     crypt_state state;
diff --git a/gs/src/zmisc2.c b/gs/src/zmisc2.c
index c926f6194..536bae8a6 100644
--- a/gs/src/zmisc2.c
+++ b/gs/src/zmisc2.c
@@ -32,7 +32,7 @@
 #include "store.h"
 
 /* Forward references */
-private int set_language_level(P2(i_ctx_t *, int));
+private int set_language_level(i_ctx_t *, int);
 
 /* ------ Language level operators ------ */
 
@@ -82,9 +82,9 @@ const op_def zmisc2_op_defs[] =
  * This is used for the .setlanguagelevel operator,
  * and (perhaps someday) after a restore.
  */
-private int swap_level_dict(P2(i_ctx_t *i_ctx_p, const char *dict_name));
-private int swap_entry(P4(i_ctx_t *i_ctx_p, ref elt[2], ref * pdict,
-			  ref * pdict2));
+private int swap_level_dict(i_ctx_t *i_ctx_p, const char *dict_name);
+private int swap_entry(i_ctx_t *i_ctx_p, ref elt[2], ref * pdict,
+		       ref * pdict2);
 private int
 set_language_level(i_ctx_t *i_ctx_p, int new_level)
 {
diff --git a/gs/src/zpath.c b/gs/src/zpath.c
index 1fb01b35c..21832e41c 100644
--- a/gs/src/zpath.c
+++ b/gs/src/zpath.c
@@ -25,10 +25,10 @@
 #include "store.h"
 
 /* Forward references */
-private int common_to(P2(i_ctx_t *,
-			 int (*)(P3(gs_state *, floatp, floatp))));
-private int common_curve(P2(i_ctx_t *,
-  int (*)(P7(gs_state *, floatp, floatp, floatp, floatp, floatp, floatp))));
+private int common_to(i_ctx_t *,
+		      int (*)(gs_state *, floatp, floatp));
+private int common_curve(i_ctx_t *,
+  int (*)(gs_state *, floatp, floatp, floatp, floatp, floatp, floatp));
 
 /* - newpath - */
 private int
@@ -84,7 +84,7 @@ zrlineto(i_ctx_t *i_ctx_p)
 /* Common code for [r](move/line)to */
 private int
 common_to(i_ctx_t *i_ctx_p,
-	  int (*add_proc)(P3(gs_state *, floatp, floatp)))
+	  int (*add_proc)(gs_state *, floatp, floatp))
 {
     os_ptr op = osp;
     double opxy[2];
@@ -115,7 +115,7 @@ zrcurveto(i_ctx_t *i_ctx_p)
 /* Common code for [r]curveto */
 private int
 common_curve(i_ctx_t *i_ctx_p,
-	     int (*add_proc)(P7(gs_state *, floatp, floatp, floatp, floatp, floatp, floatp)))
+	     int (*add_proc)(gs_state *, floatp, floatp, floatp, floatp, floatp, floatp))
 {
     os_ptr op = osp;
     double opxy[6];
diff --git a/gs/src/zpath1.c b/gs/src/zpath1.c
index 6b52e0c39..e8d3578d7 100644
--- a/gs/src/zpath1.c
+++ b/gs/src/zpath1.c
@@ -28,9 +28,9 @@
 #include "store.h"
 
 /* Forward references */
-private int common_arc(P2(i_ctx_t *,
-	  int (*)(P6(gs_state *, floatp, floatp, floatp, floatp, floatp))));
-private int common_arct(P2(i_ctx_t *, float *));
+private int common_arc(i_ctx_t *,
+	  int (*)(gs_state *, floatp, floatp, floatp, floatp, floatp));
+private int common_arct(i_ctx_t *, float *);
 
 /* <x> <y> <r> <ang1> <ang2> arc - */
 int
@@ -49,7 +49,7 @@ zarcn(i_ctx_t *i_ctx_p)
 /* Common code for arc[n] */
 private int
 common_arc(i_ctx_t *i_ctx_p,
-      int (*aproc)(P6(gs_state *, floatp, floatp, floatp, floatp, floatp)))
+      int (*aproc)(gs_state *, floatp, floatp, floatp, floatp, floatp))
 {
     os_ptr op = osp;
     double xyra[5];		/* x, y, r, ang1, ang2 */
@@ -162,8 +162,8 @@ zpathbbox(i_ctx_t *i_ctx_p)
 }
 
 /* <moveproc> <lineproc> <curveproc> <closeproc> pathforall - */
-private int path_continue(P1(i_ctx_t *));
-private int path_cleanup(P1(i_ctx_t *));
+private int path_continue(i_ctx_t *);
+private int path_cleanup(i_ctx_t *);
 private int
 zpathforall(i_ctx_t *i_ctx_p)
 {
@@ -194,7 +194,7 @@ zpathforall(i_ctx_t *i_ctx_p)
     return o_push_estack;
 }
 /* Continuation procedure for pathforall */
-private void pf_push(P3(i_ctx_t *, gs_point *, int));
+private void pf_push(i_ctx_t *, gs_point *, int);
 private int
 path_continue(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zpcolor.c b/gs/src/zpcolor.c
index f843a75d7..01ac0c084 100644
--- a/gs/src/zpcolor.c
+++ b/gs/src/zpcolor.c
@@ -42,9 +42,9 @@
 extern const gs_color_space_type gs_color_space_type_Pattern;
 
 /* Forward references */
-private int zPaintProc(P2(const gs_client_color *, gs_state *));
-private int pattern_paint_prepare(P1(i_ctx_t *));
-private int pattern_paint_finish(P1(i_ctx_t *));
+private int zPaintProc(const gs_client_color *, gs_state *);
+private int pattern_paint_prepare(i_ctx_t *);
+private int pattern_paint_finish(i_ctx_t *);
 
 /* GC descriptors */
 private_st_int_pattern();
@@ -178,7 +178,7 @@ const op_def zpcolor_l2_op_defs[] =
 /* ------ Internal procedures ------ */
 
 /* Render the pattern by calling the PaintProc. */
-private int pattern_paint_cleanup(P1(i_ctx_t *));
+private int pattern_paint_cleanup(i_ctx_t *);
 private int
 zPaintProc(const gs_client_color * pcc, gs_state * pgs)
 {
diff --git a/gs/src/zrelbit.c b/gs/src/zrelbit.c
index f03441e11..9976bb77f 100644
--- a/gs/src/zrelbit.c
+++ b/gs/src/zrelbit.c
@@ -40,7 +40,7 @@
   }
 
 /* Forward references */
-private int obj_le(P2(os_ptr, os_ptr));
+private int obj_le(os_ptr, os_ptr);
 
 /* <obj1> <obj2> eq <bool> */
 int
diff --git a/gs/src/zshade.c b/gs/src/zshade.c
index dfb33e6c7..d8d7cf055 100644
--- a/gs/src/zshade.c
+++ b/gs/src/zshade.c
@@ -38,7 +38,7 @@
 #include "store.h"
 
 /* Forward references */
-private int shading_param(P2(const_os_ptr op, const gs_shading_t ** ppsh));
+private int shading_param(const_os_ptr op, const gs_shading_t ** ppsh);
 
 /* ---------------- Standard operators ---------------- */
 
@@ -143,8 +143,8 @@ shading_param(const_os_ptr op, const gs_shading_t ** ppsh)
 extern_st(st_color_space);
 
 typedef int (*build_shading_proc_t)
-     (P5(i_ctx_t *i_ctx_p, const ref *op, const gs_shading_params_t *params,
-	 gs_shading_t **ppsh, gs_memory_t *mem));
+     (i_ctx_t *i_ctx_p, const ref *op, const gs_shading_params_t *params,
+      gs_shading_t **ppsh, gs_memory_t *mem);
 
 /* Operators */
 
diff --git a/gs/src/ztoken.c b/gs/src/ztoken.c
index d53575608..68143ad0f 100644
--- a/gs/src/ztoken.c
+++ b/gs/src/ztoken.c
@@ -35,8 +35,8 @@
 /* <file> token <obj> -true- */
 /* <string> token <post> <obj> -true- */
 /* <string|file> token -false- */
-private int ztoken_continue(P1(i_ctx_t *));
-private int token_continue(P4(i_ctx_t *, stream *, scanner_state *, bool));
+private int ztoken_continue(i_ctx_t *);
+private int token_continue(i_ctx_t *, stream *, scanner_state *, bool);
 int
 ztoken(i_ctx_t *i_ctx_p)
 {
@@ -149,8 +149,8 @@ again:
 /* Read a token and do what the interpreter would do with it. */
 /* This is different from token + exec because literal procedures */
 /* are not executed (although binary object sequences ARE executed). */
-int ztokenexec_continue(P1(i_ctx_t *));	/* export for interpreter */
-private int tokenexec_continue(P4(i_ctx_t *, stream *, scanner_state *, bool));
+int ztokenexec_continue(i_ctx_t *);	/* export for interpreter */
+private int tokenexec_continue(i_ctx_t *, stream *, scanner_state *, bool);
 int
 ztokenexec(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/ztrans.c b/gs/src/ztrans.c
index 7a463fa69..3226f7446 100644
--- a/gs/src/ztrans.c
+++ b/gs/src/ztrans.c
@@ -39,7 +39,7 @@
 /* ------ Utilities ------ */
 
 private int
-set_float_value(i_ctx_t *i_ctx_p, int (*set_value)(P2(gs_state *, floatp)))
+set_float_value(i_ctx_t *i_ctx_p, int (*set_value)(gs_state *, floatp))
 {
     os_ptr op = osp;
     double value;
@@ -55,7 +55,7 @@ set_float_value(i_ctx_t *i_ctx_p, int (*set_value)(P2(gs_state *, floatp)))
 
 private int
 current_float_value(i_ctx_t *i_ctx_p,
-		    float (*current_value)(P1(const gs_state *)))
+		    float (*current_value)(const gs_state *))
 {
     os_ptr op = osp;
 
@@ -185,7 +185,7 @@ rect_param(gs_rect *prect, os_ptr op)
 
 private int
 mask_op(i_ctx_t *i_ctx_p,
-	int (*mask_proc)(P2(gs_state *, gs_transparency_channel_selector_t)))
+	int (*mask_proc)(gs_state *, gs_transparency_channel_selector_t))
 {
     int csel;
     int code = int_param(osp, 1, &csel);
@@ -244,7 +244,7 @@ zendtransparencygroup(i_ctx_t *i_ctx_p)
 }
 
 /* <paramdict> <llx> <lly> <urx> <ury> .begintransparencymask - */
-private int tf_using_function(P3(floatp, float *, void *));
+private int tf_using_function(floatp, float *, void *);
 private int
 zbegintransparencymask(i_ctx_t *i_ctx_p)
 {
@@ -326,8 +326,8 @@ zinittransparencymask(i_ctx_t *i_ctx_p)
 /* ------ Soft-mask images ------ */
 
 /* <dict> .image3x - */
-private int mask_dict_param(P5(os_ptr, image_params *, const char *, int,
-			       gs_image3x_mask_t *));
+private int mask_dict_param(os_ptr, image_params *, const char *, int,
+			    gs_image3x_mask_t *);
 private int
 zimage3x(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/ztype.c b/gs/src/ztype.c
index 8315f60b8..71d88379d 100644
--- a/gs/src/ztype.c
+++ b/gs/src/ztype.c
@@ -39,8 +39,8 @@
  */
 
 /* Forward references */
-private int access_check(P3(i_ctx_t *, int, bool));
-private int convert_to_string(P2(os_ptr, os_ptr));
+private int access_check(i_ctx_t *, int, bool);
+private int convert_to_string(os_ptr, os_ptr);
 
 /*
  * Max and min integer values expressed as reals.
diff --git a/gs/src/zupath.c b/gs/src/zupath.c
index 8100ce155..71a1773a2 100644
--- a/gs/src/zupath.c
+++ b/gs/src/zupath.c
@@ -42,18 +42,18 @@ extern const gx_device gs_hit_device;
 extern const int gs_hit_detected;
 
 /* Forward references */
-private int upath_append(P2(os_ptr, i_ctx_t *));
-private int upath_stroke(P2(i_ctx_t *, gs_matrix *));
+private int upath_append(os_ptr, i_ctx_t *);
+private int upath_stroke(i_ctx_t *, gs_matrix *);
 
 /* ---------------- Insideness testing ---------------- */
 
 /* Forward references */
-private int in_test(P2(i_ctx_t *, int (*)(P1(gs_state *))));
-private int in_path(P3(os_ptr, i_ctx_t *, gx_device *));
-private int in_path_result(P3(i_ctx_t *, int, int));
-private int in_utest(P2(i_ctx_t *, int (*)(P1(gs_state *))));
-private int in_upath(P2(i_ctx_t *, gx_device *));
-private int in_upath_result(P3(i_ctx_t *, int, int));
+private int in_test(i_ctx_t *, int (*)(gs_state *));
+private int in_path(os_ptr, i_ctx_t *, gx_device *);
+private int in_path_result(i_ctx_t *, int, int);
+private int in_utest(i_ctx_t *, int (*)(gs_state *));
+private int in_upath(i_ctx_t *, gx_device *);
+private int in_upath_result(i_ctx_t *, int, int);
 
 /* <x> <y> ineofill <bool> */
 /* <userpath> ineofill <bool> */
@@ -129,7 +129,7 @@ zinustroke(i_ctx_t *i_ctx_p)
 
 /* Do the work of the non-user-path insideness operators. */
 private int
-in_test(i_ctx_t *i_ctx_p, int (*paintproc)(P1(gs_state *)))
+in_test(i_ctx_t *i_ctx_p, int (*paintproc)(gs_state *))
 {
     os_ptr op = osp;
     gx_device hdev;
@@ -217,7 +217,7 @@ in_path_result(i_ctx_t *i_ctx_p, int npop, int code)
 
 /* Do the work of the user-path insideness operators. */
 private int
-in_utest(i_ctx_t *i_ctx_p, int (*paintproc)(P1(gs_state *)))
+in_utest(i_ctx_t *i_ctx_p, int (*paintproc)(gs_state *))
 {
     gx_device hdev;
     int npop = in_upath(i_ctx_p, &hdev);
@@ -282,8 +282,8 @@ static const byte up_nargs[UPATH_MAX_OP + 1] = {
 };
 
 /* Declare operator procedures not declared in opextern.h. */
-int zsetbbox(P1(i_ctx_t *));
-private int zucache(P1(i_ctx_t *));
+int zsetbbox(i_ctx_t *);
+private int zucache(i_ctx_t *);
 
 #undef zp
 static const op_proc_t up_ops[UPATH_MAX_OP + 1] = {
@@ -398,8 +398,8 @@ zustrokepath(i_ctx_t *i_ctx_p)
 /* <with_ucache> upath <userpath> */
 /* We do all the work in a procedure that is also used to construct */
 /* the UnpaintedPath user path for ImageType 2 images. */
-int make_upath(P5(i_ctx_t *i_ctx_p, ref *rupath, gs_state *pgs, gx_path *ppath,
-		  bool with_ucache));
+int make_upath(i_ctx_t *i_ctx_p, ref *rupath, gs_state *pgs, gx_path *ppath,
+	       bool with_ucache);
 private int
 zupath(i_ctx_t *i_ctx_p)
 {
diff --git a/gs/src/zusparam.c b/gs/src/zusparam.c
index 1bb471198..3497b1a9c 100644
--- a/gs/src/zusparam.c
+++ b/gs/src/zusparam.c
@@ -54,8 +54,8 @@ typedef struct param_def_s {
 typedef struct long_param_def_s {
     param_def_common;
     long min_value, max_value;
-    long (*current)(P1(i_ctx_t *));
-    int (*set)(P2(i_ctx_t *, long));
+    long (*current)(i_ctx_t *);
+    int (*set)(i_ctx_t *, long);
 } long_param_def_t;
 
 #if arch_sizeof_long > arch_sizeof_int
@@ -66,14 +66,14 @@ typedef struct long_param_def_s {
 
 typedef struct bool_param_def_s {
     param_def_common;
-    bool (*current)(P1(i_ctx_t *));
-    int (*set)(P2(i_ctx_t *, bool));
+    bool (*current)(i_ctx_t *);
+    int (*set)(i_ctx_t *, bool);
 } bool_param_def_t;
 
 typedef struct string_param_def_s {
     param_def_common;
-    void (*current)(P2(i_ctx_t *, gs_param_string *));
-    int (*set)(P2(i_ctx_t *, gs_param_string *));
+    void (*current)(i_ctx_t *, gs_param_string *);
+    int (*set)(i_ctx_t *, gs_param_string *);
 } string_param_def_t;
 
 /* Define a parameter set (user or system). */
@@ -87,9 +87,9 @@ typedef struct param_set_s {
 } param_set;
 
 /* Forward references */
-private int setparams(P3(i_ctx_t *, gs_param_list *, const param_set *));
-private int currentparams(P2(i_ctx_t *, const param_set *));
-private int currentparam1(P2(i_ctx_t *, const param_set *));
+private int setparams(i_ctx_t *, gs_param_list *, const param_set *);
+private int currentparams(i_ctx_t *, const param_set *);
+private int currentparam1(i_ctx_t *, const param_set *);
 
 /* ------ Passwords ------ */
 
diff --git a/gs/src/zvmem.c b/gs/src/zvmem.c
index ac032b900..76799ae3d 100644
--- a/gs/src/zvmem.c
+++ b/gs/src/zvmem.c
@@ -100,9 +100,9 @@ zsave(i_ctx_t *i_ctx_p)
 }
 
 /* <save> restore - */
-private int restore_check_operand(P3(os_ptr, alloc_save_t **, gs_dual_memory_t *));
-private int restore_check_stack(P3(const ref_stack_t *, const alloc_save_t *, bool));
-private void restore_fix_stack(P3(ref_stack_t *, const alloc_save_t *, bool));
+private int restore_check_operand(os_ptr, alloc_save_t **, gs_dual_memory_t *);
+private int restore_check_stack(const ref_stack_t *, const alloc_save_t *, bool);
+private void restore_fix_stack(ref_stack_t *, const alloc_save_t *, bool);
 int
 zrestore(i_ctx_t *i_ctx_p)
 {