From 3ef65077e7553d1fbd75e4590751a5833a562e83 Mon Sep 17 00:00:00 2001 From: wk333 <13474090681@163.com> Date: Mon, 4 Aug 2025 17:09:06 +0800 Subject: [PATCH] Add patches from fedora, improve C compatibility and fix build failures caused by higher gcc versions (cherry picked from commit 744b96358379fb8d1ca818501f4928983a7c16a6) --- cvs-1.11.23-Adapt-to-changes-in-GCC-15.patch | 13804 ++++++++++++++++ cvs-1.11.23-c99.patch | 40 + ....11.23-tests-Call-nonobsolete-grep-F.patch | 45 + cvs.spec | 13 +- 4 files changed, 13901 insertions(+), 1 deletion(-) create mode 100644 cvs-1.11.23-Adapt-to-changes-in-GCC-15.patch create mode 100644 cvs-1.11.23-c99.patch create mode 100644 cvs-1.11.23-tests-Call-nonobsolete-grep-F.patch diff --git a/cvs-1.11.23-Adapt-to-changes-in-GCC-15.patch b/cvs-1.11.23-Adapt-to-changes-in-GCC-15.patch new file mode 100644 index 0000000..99823ee --- /dev/null +++ b/cvs-1.11.23-Adapt-to-changes-in-GCC-15.patch @@ -0,0 +1,13804 @@ +From faf7eadf8ade3ee2f8a7d5885917d1e8657d2be8 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Petr=20P=C3=ADsa=C5=99?= +Date: Thu, 23 Jan 2025 13:16:58 +0100 +Subject: [PATCH] Adapt to changes in GCC 15 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +GCC 15 moved a default C language standard to ISO 23. As a result +function declarations without an argument means no argument. That +caused a mismatch with how the functions are called. An example: + + getdate.y:76:26: error: conflicting types for ‘gmtime’; have ‘struct tm *(void)’ + 76 | extern struct tm *gmtime(); + | ^~~~~~ + In file included from xtime.h:23, + from getdate.y:46: + /usr/include/time.h:132:19: note: previous declaration of ‘gmtime’ with type ‘struct tm *(const time_t *)’ {aka ‘struct tm *(const long int *)’} + 132 | extern struct tm *gmtime (const time_t *__timer) __THROW; + | ^~~~~~ + +Also K&R protoype syntax is deprecated now and polluted the output with +warnings like this: + + getdate.y: In function ‘ToSeconds’: + getdate.y:579:1: warning: old-style function definition [-Wold-style-definition] + 579 | static time_t + | ^~~~~~~~~ + +This patch fixes them, where I or my compiler noticed them on my +glibc system. + +It also fixes const-correctness of bcmp_translate(), check_password(), +check_repository_password() and some warnings about incompatible +pointer types. + +Signed-off-by: Petr Písař +--- + diff/analyze.c | 51 ++-- + diff/cmpbuf.c | 3 +- + diff/context.c | 56 ++-- + diff/diff.c | 71 +++-- + diff/diff3.c | 170 ++++++----- + diff/dir.c | 19 +- + diff/ed.c | 18 +- + diff/ifdef.c | 48 ++-- + diff/io.c | 24 +- + diff/normal.c | 6 +- + diff/side.c | 31 +- + diff/util.c | 130 +++++---- + lib/argmatch.c | 14 +- + lib/getdate.y | 53 +--- + lib/getline.c | 32 +-- + lib/getopt.h | 6 + + lib/md5.c | 32 +-- + lib/regex.c | 260 +++++++++-------- + lib/regex.h | 9 +- + lib/savecwd.c | 12 +- + lib/sighandle.c | 17 +- + lib/stripslash.c | 3 +- + lib/xgetwd.c | 4 +- + src/add.c | 23 +- + src/admin.c | 34 +-- + src/annotate.c | 32 +-- + src/buffer.c | 246 ++++++++-------- + src/checkin.c | 14 +- + src/checkout.c | 50 ++-- + src/classify.c | 33 ++- + src/client.c | 701 ++++++++++++++++++++++---------------------- + src/client.h | 10 +- + src/commit.c | 205 +++++++------ + src/create_adm.c | 19 +- + src/cvs.h | 4 +- + src/cvsrc.c | 8 +- + src/diff.c | 61 ++-- + src/edit.c | 129 +++++---- + src/entries.c | 159 +++++----- + src/error.c | 2 +- + src/expand_path.c | 22 +- + src/fileattr.c | 56 ++-- + src/filesubr.c | 114 ++++---- + src/find_names.c | 52 ++-- + src/hash.c | 92 +++--- + src/hash.h | 2 +- + src/history.c | 60 ++-- + src/ignore.c | 31 +- + src/import.c | 121 ++++---- + src/lock.c | 93 +++--- + src/log.c | 170 ++++++----- + src/login.c | 30 +- + src/logmsg.c | 88 +++--- + src/main.c | 49 ++-- + src/mkmodules.c | 21 +- + src/modules.c | 75 +++-- + src/myndbm.c | 47 ++- + src/no_diff.c | 6 +- + src/parseinfo.c | 13 +- + src/patch.c | 51 ++-- + src/rcs.c | 720 ++++++++++++++++++++++------------------------ + src/rcs.h | 2 +- + src/rcscmds.c | 99 +++---- + src/recurse.c | 67 +++-- + src/release.c | 12 +- + src/remove.c | 30 +- + src/repos.c | 12 +- + src/root.c | 39 ++- + src/run.c | 53 ++-- + src/scramble.c | 6 +- + src/server.c | 537 +++++++++++++++------------------- + src/stack.c | 68 +++-- + src/status.c | 30 +- + src/subr.c | 129 ++++----- + src/tag.c | 145 +++++----- + src/update.c | 192 ++++++------- + src/vers_ts.c | 28 +- + src/version.c | 6 +- + src/watch.c | 60 ++-- + src/wrapper.c | 54 ++-- + src/zlib.c | 81 +++--- + 81 files changed, 3048 insertions(+), 3314 deletions(-) + +diff --git a/diff/analyze.c b/diff/analyze.c +index 3262444..ae5e265 100644 +--- a/diff/analyze.c ++++ b/diff/analyze.c +@@ -95,9 +95,13 @@ static void shift_boundaries PARAMS((struct file_data[])); + It cannot cause incorrect diff output. */ + + static int +-diag (xoff, xlim, yoff, ylim, minimal, part) +- int xoff, xlim, yoff, ylim, minimal; +- struct partition *part; ++diag ( ++ int xoff, ++ int xlim, ++ int yoff, ++ int ylim, ++ int minimal, ++ struct partition *part) + { + int *const fd = fdiag; /* Give the compiler a chance. */ + int *const bd = bdiag; /* Additional help for the compiler. */ +@@ -335,8 +339,12 @@ diag (xoff, xlim, yoff, ylim, minimal, part) + expensive it is. */ + + static void +-compareseq (xoff, xlim, yoff, ylim, minimal) +- int xoff, xlim, yoff, ylim, minimal; ++compareseq ( ++ int xoff, ++ int xlim, ++ int yoff, ++ int ylim, ++ int minimal) + { + int * const xv = xvec; /* Help the compiler. */ + int * const yv = yvec; +@@ -402,8 +410,7 @@ compareseq (xoff, xlim, yoff, ylim, minimal) + so that it will be printed in the output. */ + + static void +-discard_confusing_lines (filevec) +- struct file_data filevec[]; ++discard_confusing_lines (struct file_data filevec[]) + { + unsigned int f, i; + char *discarded[2]; +@@ -617,8 +624,7 @@ discard_confusing_lines (filevec) + int inhibit; + + static void +-shift_boundaries (filevec) +- struct file_data filevec[]; ++shift_boundaries (struct file_data filevec[]) + { + int f; + +@@ -726,9 +732,12 @@ shift_boundaries (filevec) + which the insertion was done; vice versa for INSERTED and LINE1. */ + + static struct change * +-add_change (line0, line1, deleted, inserted, old) +- int line0, line1, deleted, inserted; +- struct change *old; ++add_change ( ++ int line0, ++ int line1, ++ int deleted, ++ int inserted, ++ struct change *old) + { + struct change *new = (struct change *) xmalloc (sizeof (struct change)); + +@@ -744,8 +753,7 @@ add_change (line0, line1, deleted, inserted, old) + producing an edit script in reverse order. */ + + static struct change * +-build_reverse_script (filevec) +- struct file_data const filevec[]; ++build_reverse_script (struct file_data const filevec[]) + { + struct change *script = 0; + char *changed0 = filevec[0].changed_flag; +@@ -782,8 +790,7 @@ build_reverse_script (filevec) + producing an edit script in forward order. */ + + static struct change * +-build_script (filevec) +- struct file_data const filevec[]; ++build_script (struct file_data const filevec[]) + { + struct change *script = 0; + char *changed0 = filevec[0].changed_flag; +@@ -815,9 +822,9 @@ build_script (filevec) + + /* If CHANGES, briefly report that two files differed. */ + static void +-briefly_report (changes, filevec) +- int changes; +- struct file_data const filevec[]; ++briefly_report ( ++ int changes, ++ struct file_data const filevec[]) + { + if (changes) + message (no_details_flag ? "Files %s and %s differ\n" +@@ -828,9 +835,9 @@ briefly_report (changes, filevec) + /* Report the differences of two files. DEPTH is the current directory + depth. */ + int +-diff_2_files (filevec, depth) +- struct file_data filevec[]; +- int depth; ++diff_2_files ( ++ struct file_data filevec[], ++ int depth) + { + int diags; + int i; +diff --git a/diff/cmpbuf.c b/diff/cmpbuf.c +index 2820dfa..9ddbbec 100644 +--- a/diff/cmpbuf.c ++++ b/diff/cmpbuf.c +@@ -19,8 +19,7 @@ + /* Least common multiple of two buffer sizes A and B. */ + + size_t +-buffer_lcm (a, b) +- size_t a, b; ++buffer_lcm (size_t a, size_t b) + { + size_t m, n, r; + +diff --git a/diff/context.c b/diff/context.c +index c4562c9..a9d2398 100644 +--- a/diff/context.c ++++ b/diff/context.c +@@ -35,10 +35,10 @@ static int find_function_last_match; + /* Print a label for a context diff, with a file name and date or a label. */ + + static void +-print_context_label (mark, inf, label) +- char const *mark; +- struct file_data *inf; +- char const *label; ++print_context_label ( ++ char const *mark, ++ struct file_data *inf, ++ char const *label) + { + if (label) + printf_output ("%s %s\n", mark, label); +@@ -55,9 +55,9 @@ print_context_label (mark, inf, label) + /* Print a header for a context diff, with the file names and dates. */ + + void +-print_context_header (inf, unidiff_flag) +- struct file_data inf[]; +- int unidiff_flag; ++print_context_header ( ++ struct file_data inf[], ++ int unidiff_flag) + { + if (unidiff_flag) + { +@@ -74,9 +74,9 @@ print_context_header (inf, unidiff_flag) + /* Print an edit script in context format. */ + + void +-print_context_script (script, unidiff_flag) +- struct change *script; +- int unidiff_flag; ++print_context_script ( ++ struct change *script, ++ int unidiff_flag) + { + if (ignore_blank_lines_flag || ignore_regexp_list) + mark_ignorable (script); +@@ -103,9 +103,10 @@ print_context_script (script, unidiff_flag) + We print the translated (real) line numbers. */ + + static void +-print_context_number_range (file, a, b) +- struct file_data const *file; +- int a, b; ++print_context_number_range ( ++ struct file_data const *file, ++ int a, ++ int b) + { + int trans_a, trans_b; + translate_range (file, a, b, &trans_a, &trans_b); +@@ -127,8 +128,7 @@ print_context_number_range (file, a, b) + line with the appropriate flag-character. */ + + static void +-pr_context_hunk (hunk) +- struct change *hunk; ++pr_context_hunk (struct change *hunk) + { + int first0, last0, first1, last1, show_from, show_to, i; + struct change *next; +@@ -235,9 +235,10 @@ pr_context_hunk (hunk) + We print the translated (real) line numbers. */ + + static void +-print_unidiff_number_range (file, a, b) +- struct file_data const *file; +- int a, b; ++print_unidiff_number_range ( ++ struct file_data const *file, ++ int a, ++ int b) + { + int trans_a, trans_b; + translate_range (file, a, b, &trans_a, &trans_b); +@@ -259,8 +260,7 @@ print_unidiff_number_range (file, a, b) + line with the appropriate flag-character. */ + + static void +-pr_unidiff_hunk (hunk) +- struct change *hunk; ++pr_unidiff_hunk (struct change *hunk) + { + int first0, last0, first1, last1, show_from, show_to, i, j, k; + struct change *next; +@@ -356,8 +356,7 @@ pr_unidiff_hunk (hunk) + to the `struct change' for the last change before those lines. */ + + static struct change * +-find_hunk (start) +- struct change *start; ++find_hunk (struct change *start) + { + struct change *prev; + int top0, top1; +@@ -392,8 +391,7 @@ find_hunk (start) + are ignorable lines. */ + + static void +-mark_ignorable (script) +- struct change *script; ++mark_ignorable (struct change *script) + { + while (script) + { +@@ -423,11 +421,11 @@ mark_ignorable (script) + Do not store anything if no function-header is found. */ + + static void +-find_function (file, linenum, linep, lenp) +- struct file_data const *file; +- int linenum; +- char const **linep; +- size_t *lenp; ++find_function ( ++ struct file_data const *file, ++ int linenum, ++ char const **linep, ++ size_t *lenp) + { + int i = linenum; + int last = find_function_last_search; +diff --git a/diff/diff.c b/diff/diff.c +index 6d3c409..cd39017 100644 +--- a/diff/diff.c ++++ b/diff/diff.c +@@ -79,9 +79,9 @@ static int binary_I_O; + the length of that vector. */ + + static char * +-option_list (optionvec, count) +- char **optionvec; /* Was `vector', but that collides on Alliant. */ +- int count; ++option_list ( ++ char **optionvec, /* Was `vector', but that collides on Alliant. */ ++ int count) + { + int i; + size_t length = 0; +@@ -105,9 +105,9 @@ option_list (optionvec, count) + /* Convert STR to a positive integer, storing the result in *OUT. + If STR is not a valid integer, return -1 (otherwise 0). */ + static int +-ck_atoi (str, out) +- char const *str; +- int *out; ++ck_atoi ( ++ char const *str, ++ int *out) + { + char const *p; + for (p = str; *p; p++) +@@ -124,8 +124,7 @@ static char const **exclude; + static int exclude_alloc, exclude_count; + + int +-excluded_filename (f) +- char const *f; ++excluded_filename (char const *f) + { + int i; + for (i = 0; i < exclude_count; i++) +@@ -135,8 +134,7 @@ excluded_filename (f) + } + + static void +-add_exclude (pattern) +- char const *pattern; ++add_exclude (char const *pattern) + { + if (exclude_alloc <= exclude_count) + exclude = (char const **) +@@ -148,8 +146,7 @@ add_exclude (pattern) + } + + static int +-add_exclude_file (name) +- char const *name; ++add_exclude_file (char const *name) + { + struct file_data f; + char *p, *q, *lim; +@@ -236,11 +233,11 @@ static struct option const longopts[] = + + + int +-diff_run (argc, argv, out, callbacks_arg) +- int argc; +- char *argv[]; +- const char *out; +- const struct diff_callbacks *callbacks_arg; ++diff_run ( ++ int argc, ++ char *argv[], ++ const char *out, ++ const struct diff_callbacks *callbacks_arg) + { + int val; + int c; +@@ -725,9 +722,9 @@ diff_run (argc, argv, out, callbacks_arg) + /* Add the compiled form of regexp PATTERN to REGLIST. */ + + static void +-add_regexp (reglist, pattern) +- struct regexp_list **reglist; +- char const *pattern; ++add_regexp ( ++ struct regexp_list **reglist, ++ char const *pattern) + { + struct regexp_list *r; + char const *m; +@@ -745,8 +742,7 @@ add_regexp (reglist, pattern) + } + + static int +-try_help (reason) +- char const *reason; ++try_help (char const *reason) + { + if (reason) + diff_error ("%s", reason, 0); +@@ -755,8 +751,7 @@ try_help (reason) + } + + static void +-check_output (file) +- FILE *file; ++check_output (FILE *file) + { + if (ferror (file) || fflush (file) != 0) + fatal ("write error"); +@@ -856,9 +851,9 @@ usage () + } + + static int +-specify_format (var, value) +- char **var; +- char *value; ++specify_format ( ++ char **var, ++ char *value) + { + int err = *var ? strcmp (*var, value) : 0; + *var = value; +@@ -866,8 +861,7 @@ specify_format (var, value) + } + + static void +-specify_style (style) +- enum output_style style; ++specify_style (enum output_style style) + { + if (output_style != OUTPUT_NORMAL + && output_style != style) +@@ -876,8 +870,7 @@ specify_style (style) + } + + static char const * +-filetype (st) +- struct stat const *st; ++filetype (struct stat const *st) + { + /* See Posix.2 section 4.17.6.1.1 and Table 5-1 for these formats. + To keep diagnostics grammatical, the returned string must start +@@ -935,10 +928,12 @@ filetype (st) + 2 if there is a problem opening them. */ + + static int +-compare_files (dir0, name0, dir1, name1, depth) +- char const *dir0, *dir1; +- char const *name0, *name1; +- int depth; ++compare_files ( ++ char const *dir0, ++ char const *name0, ++ char const *dir1, ++ char const *name1, ++ int depth) + { + struct file_data inf[2]; + register int i; +@@ -1213,9 +1208,9 @@ compare_files (dir0, name0, dir1, name1, depth) + to permit repeated calls to diff_run. */ + + static void +-initialize_main (argcp, argvp) +- int *argcp; +- char ***argvp; ++initialize_main ( ++ int *argcp, ++ char ***argvp) + { + /* These variables really must be reset each time diff_run is called. */ + output_style = OUTPUT_NORMAL; +diff --git a/diff/diff3.c b/diff/diff3.c +index e9418ce..909b021 100644 +--- a/diff/diff3.c ++++ b/diff/diff3.c +@@ -250,11 +250,11 @@ static struct option const longopts[] = + * combines the two diffs, and outputs them. + */ + int +-diff3_run (argc, argv, out, callbacks_arg) +- int argc; +- char **argv; +- char *out; +- const struct diff_callbacks *callbacks_arg; ++diff3_run ( ++ int argc, ++ char **argv, ++ char *out, ++ const struct diff_callbacks *callbacks_arg) + { + int c, i; + int mapping[3]; +@@ -512,8 +512,7 @@ diff3_run (argc, argv, out, callbacks_arg) + } + + static int +-try_help (reason) +- char const *reason; ++try_help (char const *reason) + { + if (reason) + diff_error ("%s", reason, 0); +@@ -522,8 +521,7 @@ try_help (reason) + } + + static void +-check_output (stream) +- FILE *stream; ++check_output (FILE *stream) + { + if (ferror (stream) || fflush (stream) != 0) + diff3_fatal ("write error"); +@@ -641,8 +639,9 @@ usage () + * FILE1--the other file in diff12, and FILEC--the common file. + */ + static struct diff3_block * +-make_3way_diff (thread0, thread1) +- struct diff_block *thread0, *thread1; ++make_3way_diff ( ++ struct diff_block *thread0, ++ struct diff_block *thread1) + { + /* + * This routine works on the two diffs passed to it as threads. +@@ -824,12 +823,12 @@ make_3way_diff (thread0, thread1) + * are part of a diff3_block. + */ + static struct diff3_block * +-using_to_diff3_block (using, last_using, low_thread, high_thread, last_diff3) +- struct diff_block +- *using[2], +- *last_using[2]; +- int low_thread, high_thread; +- struct diff3_block const *last_diff3; ++using_to_diff3_block ( ++ struct diff_block *using[2], ++ struct diff_block *last_using[2], ++ int low_thread, ++ int high_thread, ++ struct diff3_block const *last_diff3) + { + int low[2], high[2]; + struct diff3_block *result; +@@ -948,12 +947,12 @@ using_to_diff3_block (using, last_using, low_thread, high_thread, last_diff3) + * Upon successful completion of the copy, it returns 1. + */ + static int +-copy_stringlist (fromptrs, fromlengths, toptrs, tolengths, copynum) +- char * const fromptrs[]; +- char *toptrs[]; +- size_t const fromlengths[]; +- size_t tolengths[]; +- int copynum; ++copy_stringlist ( ++ char * const fromptrs[], ++ size_t const fromlengths[], ++ char *toptrs[], ++ size_t tolengths[], ++ int copynum) + { + register char * const *f = fromptrs; + register char **t = toptrs; +@@ -978,8 +977,13 @@ copy_stringlist (fromptrs, fromlengths, toptrs, tolengths, copynum) + * on the arguments passed. Return the block as a result. + */ + static struct diff3_block * +-create_diff3_block (low0, high0, low1, high1, low2, high2) +- register int low0, high0, low1, high1, low2, high2; ++create_diff3_block ( ++ register int low0, ++ register int high0, ++ register int low1, ++ register int high1, ++ register int low2, ++ register int high2) + { + struct diff3_block *result = ALLOCATE (1, struct diff3_block); + int numlines; +@@ -1047,10 +1051,12 @@ create_diff3_block (low0, high0, low1, high1, low2, high2) + * Return 1 if they are equivalent, 0 if not. + */ + static int +-compare_line_list (list1, lengths1, list2, lengths2, nl) +- char * const list1[], * const list2[]; +- size_t const lengths1[], lengths2[]; +- int nl; ++compare_line_list ( ++ char * const list1[], ++ size_t const lengths1[], ++ char * const list2[], ++ size_t const lengths2[], ++ int nl) + { + char + * const *l1 = list1, +@@ -1075,10 +1081,11 @@ extern char **environ; + #endif + + static struct diff_block * +-process_diff (filea, fileb, last_block, diff_contents) +- char const *filea, *fileb; +- struct diff_block **last_block; +- char **diff_contents; ++process_diff ( ++ char const *filea, ++ char const *fileb, ++ struct diff_block **last_block, ++ char **diff_contents) + { + char *diff_limit; + char *scan_diff; +@@ -1192,9 +1199,9 @@ process_diff (filea, fileb, last_block, diff_contents) + */ + + static enum diff_type +-process_diff_control (string, db) +- char **string; +- struct diff_block *db; ++process_diff_control ( ++ char **string, ++ struct diff_block *db) + { + char *s = *string; + int holdnum; +@@ -1267,9 +1274,10 @@ process_diff_control (string, db) + } + + static char * +-read_diff (filea, fileb, output_placement) +- char const *filea, *fileb; +- char **output_placement; ++read_diff ( ++ char const *filea, ++ char const *fileb, ++ char **output_placement) + { + char *diff_result; + size_t bytes, current_chunk_size, total; +@@ -1376,11 +1384,12 @@ read_diff (filea, fileb, output_placement) + * are used as call-by-reference values. + */ + static char * +-scan_diff_line (scan_ptr, set_start, set_length, limit, leadingchar) +- char *scan_ptr, **set_start; +- size_t *set_length; +- char *limit; +- int leadingchar; ++scan_diff_line ( ++ char *scan_ptr, ++ char **set_start, ++ size_t *set_length, ++ char *limit, ++ int leadingchar) + { + char *line_ptr; + +@@ -1436,9 +1445,10 @@ scan_diff_line (scan_ptr, set_start, set_length, limit, leadingchar) + * REV_MAPPING is the inverse of MAPPING. + */ + static void +-output_diff3 (diff, mapping, rev_mapping) +- struct diff3_block *diff; +- int const mapping[3], rev_mapping[3]; ++output_diff3 ( ++ struct diff3_block *diff, ++ int const mapping[3], ++ int const rev_mapping[3]) + { + int i; + int oddoneout; +@@ -1524,9 +1534,9 @@ output_diff3 (diff, mapping, rev_mapping) + * Double any initial '.'s; yield nonzero if any initial '.'s were doubled. + */ + static int +-dotlines (b, filenum) +- struct diff3_block *b; +- int filenum; ++dotlines ( ++ struct diff3_block *b, ++ int filenum) + { + int i; + int leading_dot = 0; +@@ -1553,8 +1563,10 @@ dotlines (b, filenum) + * starting with line START and continuing for NUM lines. + */ + static void +-undotlines (leading_dot, start, num) +- int leading_dot, start, num; ++undotlines ( ++ int leading_dot, ++ int start, ++ int num) + { + write_output (".\n", 2); + if (leading_dot) +@@ -1587,10 +1599,13 @@ undotlines (leading_dot, start, num) + */ + + static int +-output_diff3_edscript (diff, mapping, rev_mapping, file0, file1, file2) +- struct diff3_block *diff; +- int const mapping[3], rev_mapping[3]; +- char const *file0, *file1, *file2; ++output_diff3_edscript ( ++ struct diff3_block *diff, ++ int const mapping[3], ++ int const rev_mapping[3], ++ char const *file0, ++ char const *file1, ++ char const *file2) + { + int leading_dot; + int conflicts_found = 0, conflict; +@@ -1710,12 +1725,14 @@ output_diff3_edscript (diff, mapping, rev_mapping, file0, file1, file2) + */ + + static int +-output_diff3_merge (infile, diff, mapping, rev_mapping, +- file0, file1, file2) +- FILE *infile; +- struct diff3_block *diff; +- int const mapping[3], rev_mapping[3]; +- char const *file0, *file1, *file2; ++output_diff3_merge ( ++ FILE *infile, ++ struct diff3_block *diff, ++ int const mapping[3], ++ int const rev_mapping[3], ++ char const *file0, ++ const char *file1, ++ const char *file2) + { + int c, i; + char cc; +@@ -1829,8 +1846,7 @@ output_diff3_merge (infile, diff, mapping, rev_mapping, + * Reverse the order of the list of diff3 blocks. + */ + static struct diff3_block * +-reverse_diff3_blocklist (diff) +- struct diff3_block *diff; ++reverse_diff3_blocklist (struct diff3_block *diff) + { + register struct diff3_block *tmp, *next, *prev; + +@@ -1845,10 +1861,10 @@ reverse_diff3_blocklist (diff) + } + + static size_t +-myread (fd, ptr, size) +- int fd; +- char *ptr; +- size_t size; ++myread ( ++ int fd, ++ char *ptr, ++ size_t size) + { + ssize_t result = read (fd, ptr, size); + if (result == -1) +@@ -1857,25 +1873,23 @@ myread (fd, ptr, size) + } + + static void +-diff3_fatal (string) +- char const *string; ++diff3_fatal (char const *string) + { + diff_error ("%s", string, 0); + DIFF3_ABORT (2); + } + + static void +-diff3_perror_with_exit (string) +- char const *string; ++diff3_perror_with_exit (char const *string) + { + perror_with_name (string); + DIFF3_ABORT (2); + } + + static void +-initialize_main (argcp, argvp) +- int *argcp; +- char ***argvp; ++initialize_main ( ++ int *argcp, ++ char ***argvp) + { + always_text = 0; + edscript = 0; +@@ -1891,8 +1905,7 @@ initialize_main (argcp, argvp) + } + + static void +-free_diff_blocks(p) +- struct diff_block *p; ++free_diff_blocks(struct diff_block *p) + { + register struct diff_block *next; + +@@ -1909,8 +1922,7 @@ free_diff_blocks(p) + } + + static void +-free_diff3_blocks(p) +- struct diff3_block *p; ++free_diff3_blocks(struct diff3_block *p) + { + register struct diff3_block *next; + +diff --git a/diff/dir.c b/diff/dir.c +index da497dc..3026e4c 100644 +--- a/diff/dir.c ++++ b/diff/dir.c +@@ -36,9 +36,9 @@ static int dir_sort PARAMS((struct file_data const *, struct dirdata *)); + #endif + + static int +-dir_sort (dir, dirdata) +- struct file_data const *dir; +- struct dirdata *dirdata; ++dir_sort ( ++ struct file_data const *dir, ++ struct dirdata *dirdata) + { + register struct dirent *next; + register int i; +@@ -127,8 +127,9 @@ dir_sort (dir, dirdata) + /* Sort the files now in the table. */ + + static int +-compare_names (file1, file2) +- void const *file1, *file2; ++compare_names ( ++ void const *file1, ++ void const *file2) + { + return filename_cmp (* (char const *const *) file1, + * (char const *const *) file2); +@@ -155,10 +156,10 @@ compare_names (file1, file2) + or 2 if trouble is encountered in opening files. */ + + int +-diff_dirs (filevec, handle_file, depth) +- struct file_data const filevec[]; +- int (*handle_file) PARAMS((char const *, char const *, char const *, char const *, int)); +- int depth; ++diff_dirs ( ++ struct file_data const filevec[], ++ int (*handle_file) PARAMS((char const *, char const *, char const *, char const *, int)), ++ int depth) + { + struct dirdata dirdata[2]; + int val = 0; /* Return value. */ +diff --git a/diff/ed.c b/diff/ed.c +index 74fc2a4..d5a77c8 100644 +--- a/diff/ed.c ++++ b/diff/ed.c +@@ -24,8 +24,7 @@ static void pr_forward_ed_hunk PARAMS((struct change *)); + /* Print our script as ed commands. */ + + void +-print_ed_script (script) +- struct change *script; ++print_ed_script (struct change *script) + { + print_script (script, find_reverse_change, print_ed_hunk); + } +@@ -33,8 +32,7 @@ print_ed_script (script) + /* Print a hunk of an ed diff */ + + static void +-print_ed_hunk (hunk) +- struct change *hunk; ++print_ed_hunk (struct change *hunk) + { + int f0, l0, f1, l1; + int deletes, inserts; +@@ -101,15 +99,13 @@ print_ed_hunk (hunk) + which means that the commands are not truly useful with ed. */ + + void +-pr_forward_ed_script (script) +- struct change *script; ++pr_forward_ed_script (struct change *script) + { + print_script (script, find_change, pr_forward_ed_hunk); + } + + static void +-pr_forward_ed_hunk (hunk) +- struct change *hunk; ++pr_forward_ed_hunk (struct change *hunk) + { + int i; + int f0, l0, f1, l1; +@@ -145,8 +141,7 @@ pr_forward_ed_hunk (hunk) + This format is used for RCS. */ + + void +-print_rcs_script (script) +- struct change *script; ++print_rcs_script (struct change *script) + { + print_script (script, find_change, print_rcs_hunk); + } +@@ -154,8 +149,7 @@ print_rcs_script (script) + /* Print a hunk of an RCS diff */ + + static void +-print_rcs_hunk (hunk) +- struct change *hunk; ++print_rcs_hunk (struct change *hunk) + { + int i; + int f0, l0, f1, l1; +diff --git a/diff/ifdef.c b/diff/ifdef.c +index 94fcfb5..4b791f2 100644 +--- a/diff/ifdef.c ++++ b/diff/ifdef.c +@@ -40,8 +40,7 @@ static int next_line; + /* Print the edit-script SCRIPT as a merged #ifdef file. */ + + void +-print_ifdef_script (script) +- struct change *script; ++print_ifdef_script (struct change *script) + { + next_line = - files[0].prefix_lines; + print_script (script, find_change, print_ifdef_hunk); +@@ -59,8 +58,7 @@ print_ifdef_script (script) + describing changes in consecutive lines. */ + + static void +-print_ifdef_hunk (hunk) +- struct change *hunk; ++print_ifdef_hunk (struct change *hunk) + { + int first0, last0, first1, last1, deletes, inserts; + char *format; +@@ -91,9 +89,12 @@ print_ifdef_hunk (hunk) + lines BEG1 up to END1 are from the second file. */ + + static void +-format_ifdef (format, beg0, end0, beg1, end1) +- char *format; +- int beg0, end0, beg1, end1; ++format_ifdef ( ++ char *format, ++ int beg0, ++ int end0, ++ int beg1, ++ int end1) + { + struct group groups[2]; + +@@ -113,11 +114,11 @@ format_ifdef (format, beg0, end0, beg1, end1) + If OUT is zero, do not actually print anything; just scan the format. */ + + static char * +-format_group (doit, format, endchar, groups) +- int doit; +- char *format; +- int endchar; +- struct group const *groups; ++format_group ( ++ int doit, ++ char *format, ++ int endchar, ++ struct group const *groups) + { + register char c; + register char *f = format; +@@ -241,9 +242,9 @@ format_group (doit, format, endchar, groups) + /* For the line group pair G, return the number corresponding to LETTER. + Return -1 if LETTER is not a group format letter. */ + static int +-groups_letter_value (g, letter) +- struct group const *g; +- int letter; ++groups_letter_value ( ++ struct group const *g, ++ int letter) + { + if (ISUPPER (letter)) + { +@@ -264,10 +265,10 @@ groups_letter_value (g, letter) + /* Output using FORMAT to print the line group GROUP. + But do nothing if DOIT is zero. */ + static void +-print_ifdef_lines (doit, format, group) +- int doit; +- char *format; +- struct group const *group; ++print_ifdef_lines ( ++ int doit, ++ char *format, ++ struct group const *group) + { + struct file_data const *file = group->file; + char const * const *linbuf = file->linbuf; +@@ -372,9 +373,9 @@ print_ifdef_lines (doit, format, group) + Yield the address of the first character after the closing apostrophe, + or zero if the literal is ill-formed. */ + static char * +-scan_char_literal (lit, intptr) +- char *lit; +- int *intptr; ++scan_char_literal ( ++ char *lit, ++ int *intptr) + { + register char *p = lit; + int value, digits; +@@ -413,8 +414,7 @@ scan_char_literal (lit, intptr) + /* Scan optional printf-style SPEC of the form `-*[0-9]*(.[0-9]*)?[cdoxX]'. + Return the address of the character following SPEC, or zero if failure. */ + static char * +-scan_printf_spec (spec) +- register char *spec; ++scan_printf_spec (register char *spec) + { + register unsigned char c; + +diff --git a/diff/io.c b/diff/io.c +index 31581cd..4c958c6 100644 +--- a/diff/io.c ++++ b/diff/io.c +@@ -79,9 +79,9 @@ static void prepare_text_end PARAMS((struct file_data *)); + and if it appears to be a binary file. */ + + int +-sip (current, skip_test) +- struct file_data *current; +- int skip_test; ++sip ( ++ struct file_data *current, ++ int skip_test) + { + /* If we have a nonexistent file at this stage, treat it as empty. */ + if (current->desc < 0) +@@ -125,8 +125,7 @@ sip (current, skip_test) + /* Slurp the rest of the current file completely into memory. */ + + void +-slurp (current) +- struct file_data *current; ++slurp (struct file_data *current) + { + ssize_t cc; + +@@ -185,8 +184,7 @@ slurp (current) + each line. */ + + static void +-find_and_hash_each_line (current) +- struct file_data *current; ++find_and_hash_each_line (struct file_data *current) + { + unsigned h; + unsigned char const *p = (unsigned char const *) current->prefix_end; +@@ -386,8 +384,7 @@ find_and_hash_each_line (current) + but remember that we had to add one. */ + + static void +-prepare_text_end (current) +- struct file_data *current; ++prepare_text_end (struct file_data *current) + { + size_t buffered_chars = current->buffered_chars; + char *p = current->buffer; +@@ -410,8 +407,7 @@ prepare_text_end (current) + prefixes and suffixes of each object. */ + + static void +-find_identical_ends (filevec) +- struct file_data filevec[]; ++find_identical_ends (struct file_data filevec[]) + { + word *w0, *w1; + char *p0, *p1, *buffer0, *buffer1; +@@ -658,9 +654,9 @@ static int const primes[] = + If PRETEND_BINARY is nonzero, pretend they are binary regardless. */ + + int +-read_files (filevec, pretend_binary) +- struct file_data filevec[]; +- int pretend_binary; ++read_files ( ++ struct file_data filevec[], ++ int pretend_binary) + { + int i; + int skip_test = always_text_flag | pretend_binary; +diff --git a/diff/normal.c b/diff/normal.c +index b1f4955..90cbf4f 100644 +--- a/diff/normal.c ++++ b/diff/normal.c +@@ -24,8 +24,7 @@ static void print_normal_hunk PARAMS((struct change *)); + INF points to an array of descriptions of the two files. */ + + void +-print_normal_script (script) +- struct change *script; ++print_normal_script (struct change *script) + { + print_script (script, find_change, print_normal_hunk); + } +@@ -35,8 +34,7 @@ print_normal_script (script) + describing changes in consecutive lines. */ + + static void +-print_normal_hunk (hunk) +- struct change *hunk; ++print_normal_hunk (struct change *hunk) + { + int first0, last0, first1, last1, deletes, inserts; + register int i; +diff --git a/diff/side.c b/diff/side.c +index d776e77..c2b7f99 100644 +--- a/diff/side.c ++++ b/diff/side.c +@@ -33,8 +33,7 @@ static int next0, next1; + /* Print the edit-script SCRIPT as a sdiff style output. */ + + void +-print_sdiff_script (script) +- struct change *script; ++print_sdiff_script (struct change *script) + { + begin_output (); + +@@ -47,8 +46,9 @@ print_sdiff_script (script) + /* Tab from column FROM to column TO, where FROM <= TO. Yield TO. */ + + static unsigned +-tab_from_to (from, to) +- unsigned from, to; ++tab_from_to ( ++ unsigned int from, ++ unsigned int to) + { + unsigned tab; + +@@ -69,9 +69,10 @@ tab_from_to (from, to) + * written (not the number of chars). + */ + static unsigned +-print_half_line (line, indent, out_bound) +- char const * const *line; +- unsigned indent, out_bound; ++print_half_line ( ++ char const * const *line, ++ unsigned int indent, ++ unsigned int out_bound) + { + register unsigned in_position = 0, out_position = 0; + register char const +@@ -173,10 +174,10 @@ print_half_line (line, indent, out_bound) + */ + + static void +-print_1sdiff_line (left, sep, right) +- char const * const *left; +- int sep; +- char const * const *right; ++print_1sdiff_line ( ++ char const * const *left, ++ int sep, ++ char const * const *right) + { + unsigned hw = sdiff_half_width, c2o = sdiff_column2_offset; + unsigned col = 0; +@@ -217,8 +218,9 @@ print_1sdiff_line (left, sep, right) + + /* Print lines common to both files in side-by-side format. */ + static void +-print_sdiff_common_lines (limit0, limit1) +- int limit0, limit1; ++print_sdiff_common_lines ( ++ int limit0, ++ int limit1) + { + int i0 = next0, i1 = next1; + +@@ -247,8 +249,7 @@ print_sdiff_common_lines (limit0, limit1) + describing changes in consecutive lines. */ + + static void +-print_sdiff_hunk (hunk) +- struct change *hunk; ++print_sdiff_hunk (struct change *hunk) + { + int first0, last0, first1, last1, deletes, inserts; + register int i, j; +diff --git a/diff/util.c b/diff/util.c +index c535075..8fa9553 100644 +--- a/diff/util.c ++++ b/diff/util.c +@@ -48,8 +48,7 @@ static struct msg **msg_chain_end = &msg_chain; + TEXT should normally be the file name. */ + + void +-perror_with_name (text) +- char const *text; ++perror_with_name (char const *text) + { + int e = errno; + +@@ -66,8 +65,7 @@ perror_with_name (text) + /* Use when a system call returns non-zero status and that is fatal. */ + + void +-pfatal_with_name (text) +- char const *text; ++pfatal_with_name (char const *text) + { + int e = errno; + print_message_queue (); +@@ -86,8 +84,10 @@ pfatal_with_name (text) + with args ARG1 and ARG2. */ + + void +-diff_error (format, arg, arg1) +- char const *format, *arg, *arg1; ++diff_error ( ++ char const *format, ++ char const *arg, ++ char const *arg1) + { + if (callbacks && callbacks->error) + (*callbacks->error) (format, arg, arg1); +@@ -102,8 +102,7 @@ diff_error (format, arg, arg1) + /* Print an error message containing the string TEXT, then exit. */ + + void +-fatal (m) +- char const *m; ++fatal (char const *m) + { + print_message_queue (); + diff_error ("%s", m, 0); +@@ -114,15 +113,21 @@ fatal (m) + This is used for things like "binary files differ" and "Only in ...". */ + + void +-message (format, arg1, arg2) +- char const *format, *arg1, *arg2; ++message ( ++ char const *format, ++ char const *arg1, ++ char const *arg2) + { + message5 (format, arg1, arg2, 0, 0); + } + + void +-message5 (format, arg1, arg2, arg3, arg4) +- char const *format, *arg1, *arg2, *arg3, *arg4; ++message5 ( ++ char const *format, ++ char const *arg1, ++ char const *arg2, ++ char const *arg3, ++ char const *arg4) + { + if (paginate_flag) + { +@@ -169,9 +174,10 @@ static int current_depth; + static int output_in_progress = 0; + + void +-setup_output (name0, name1, depth) +- char const *name0, *name1; +- int depth; ++setup_output ( ++ char const *name0, ++ char const *name1, ++ int depth) + { + current_name0 = name0; + current_name1 = name1; +@@ -322,9 +328,9 @@ finish_output () + /* Write something to the output file. */ + + void +-write_output (text, len) +- char const *text; +- size_t len; ++write_output ( ++ char const *text, ++ size_t len) + { + if (callbacks && callbacks->write_output) + (*callbacks->write_output) (text, len); +@@ -422,8 +428,9 @@ flush_output () + Return nonzero if the lines differ. */ + + int +-line_cmp (s1, s2) +- char const *s1, *s2; ++line_cmp ( ++ char const *s1, ++ char const *s2) + { + register unsigned char const *t1 = (unsigned char const *) s1; + register unsigned char const *t2 = (unsigned char const *) s2; +@@ -524,15 +531,13 @@ line_cmp (s1, s2) + Return the last link before the first gap. */ + + struct change * +-find_change (start) +- struct change *start; ++find_change (struct change *start) + { + return start; + } + + struct change * +-find_reverse_change (start) +- struct change *start; ++find_reverse_change (struct change *start) + { + return start; + } +@@ -549,10 +554,10 @@ find_reverse_change (start) + link at the end) and prints it. */ + + void +-print_script (script, hunkfun, printfun) +- struct change *script; +- struct change * (*hunkfun) PARAMS((struct change *)); +- void (*printfun) PARAMS((struct change *)); ++print_script ( ++ struct change *script, ++ struct change * (*hunkfun) PARAMS((struct change *)), ++ void (*printfun) PARAMS((struct change *))) + { + struct change *next = script; + +@@ -585,9 +590,9 @@ print_script (script, hunkfun, printfun) + the line is inserted, deleted, changed, etc.). */ + + void +-print_1_line (line_flag, line) +- char const *line_flag; +- char const * const *line; ++print_1_line ( ++ char const *line_flag, ++ char const * const *line) + { + char const *text = line[0], *limit = line[1]; /* Help the compiler. */ + char const *flag_format = 0; +@@ -614,8 +619,11 @@ print_1_line (line_flag, line) + internal carriage return, so that tab stops continue to line up. */ + + void +-output_1_line (text, limit, flag_format, line_flag) +- char const *text, *limit, *flag_format, *line_flag; ++output_1_line ( ++ char const *text, ++ char const *limit, ++ char const *flag_format, ++ char const *line_flag) + { + if (!tab_expand_flag) + write_output (text, limit - text); +@@ -666,8 +674,9 @@ output_1_line (text, limit, flag_format, line_flag) + } + + int +-change_letter (inserts, deletes) +- int inserts, deletes; ++change_letter ( ++ int inserts, ++ int deletes) + { + if (!inserts) + return 'd'; +@@ -685,18 +694,20 @@ change_letter (inserts, deletes) + Actual line numbers count from 1 within the entire file. */ + + int +-translate_line_number (file, lnum) +- struct file_data const *file; +- int lnum; ++translate_line_number ( ++ struct file_data const *file, ++ int lnum) + { + return lnum + file->prefix_lines + 1; + } + + void +-translate_range (file, a, b, aptr, bptr) +- struct file_data const *file; +- int a, b; +- int *aptr, *bptr; ++translate_range ( ++ struct file_data const *file, ++ int a, ++ int b, ++ int *aptr, ++ int *bptr) + { + *aptr = translate_line_number (file, a - 1) + 1; + *bptr = translate_line_number (file, b + 1) - 1; +@@ -709,10 +720,11 @@ translate_range (file, a, b, aptr, bptr) + We print the translated (real) line numbers. */ + + void +-print_number_range (sepchar, file, a, b) +- int sepchar; +- struct file_data *file; +- int a, b; ++print_number_range ( ++ int sepchar, ++ struct file_data *file, ++ int a, ++ int b) + { + int trans_a, trans_b; + translate_range (file, a, b, &trans_a, &trans_b); +@@ -740,10 +752,14 @@ print_number_range (sepchar, file, a, b) + set to 0. */ + + void +-analyze_hunk (hunk, first0, last0, first1, last1, deletes, inserts) +- struct change *hunk; +- int *first0, *last0, *first1, *last1; +- int *deletes, *inserts; ++analyze_hunk ( ++ struct change *hunk, ++ int *first0, ++ int *last0, ++ int *first1, ++ int *last1, ++ int *deletes, ++ int *inserts) + { + int l0, l1, show_from, show_to; + int i; +@@ -813,8 +829,10 @@ analyze_hunk (hunk, first0, last0, first1, last1, deletes, inserts) + /* Concatenate three strings, returning a newly malloc'd string. */ + + char * +-concat (s1, s2, s3) +- char const *s1, *s2, *s3; ++concat ( ++ char const *s1, ++ char const *s2, ++ char const *s3) + { + size_t len = strlen (s1) + strlen (s2) + strlen (s3); + char *new = xmalloc (len + 1); +@@ -826,16 +844,16 @@ concat (s1, s2, s3) + of the file in DIR whose filename is FILE. */ + + char * +-dir_file_pathname (dir, file) +- char const *dir, *file; ++dir_file_pathname ( ++ char const *dir, ++ char const *file) + { + char const *p = filename_lastdirchar (dir); + return concat (dir, "/" + (p && !p[1]), file); + } + + void +-debug_script (sp) +- struct change *sp; ++debug_script (struct change *sp) + { + fflush (stdout); + for (; sp; sp = sp->link) +diff --git a/lib/argmatch.c b/lib/argmatch.c +index 90b44c6..799286d 100644 +--- a/lib/argmatch.c ++++ b/lib/argmatch.c +@@ -32,9 +32,9 @@ extern char *program_name; + or -2 if it is ambiguous (is a prefix of more than one element). */ + + int +-argmatch (arg, optlist) +- char *arg; +- char **optlist; ++argmatch ( ++ char *arg, ++ char **optlist) + { + int i; /* Temporary index in OPTLIST. */ + size_t arglen; /* Length of ARG. */ +@@ -71,10 +71,10 @@ argmatch (arg, optlist) + PROBLEM is the return value from argmatch. */ + + void +-invalid_arg (kind, value, problem) +- char *kind; +- char *value; +- int problem; ++invalid_arg ( ++ char *kind, ++ char *value, ++ int problem) + { + fprintf (stderr, "%s: ", program_name); + if (problem == -1) +diff --git a/lib/getdate.y b/lib/getdate.y +index 007318c..18eb6fe 100644 +--- a/lib/getdate.y ++++ b/lib/getdate.y +@@ -73,8 +73,8 @@ + unportable getdate.c's), but that seems to cause as many problems + as it solves. */ + +-extern struct tm *gmtime(); +-extern struct tm *localtime(); ++extern struct tm *gmtime(const time_t *); ++extern struct tm *localtime(const time_t *); + + #define yyparse getdate_yyparse + #define yylex getdate_yylex +@@ -82,7 +82,7 @@ extern struct tm *localtime(); + + static int yyparse (); + static int yylex (); +-static int yyerror (); ++static int yyerror (char *); + + #define EPOCH 1970 + #define HOUR(x) ((time_t)(x) * 60) +@@ -569,19 +569,14 @@ static TABLE const MilitaryTable[] = { + + /* ARGSUSED */ + static int +-yyerror(s) +- char *s; ++yyerror(char *s) + { + return 0; + } + + + static time_t +-ToSeconds(Hours, Minutes, Seconds, Meridian) +- time_t Hours; +- time_t Minutes; +- time_t Seconds; +- MERIDIAN Meridian; ++ToSeconds(time_t Hours, time_t Minutes, time_t Seconds, MERIDIAN Meridian) + { + if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59) + return -1; +@@ -614,15 +609,8 @@ ToSeconds(Hours, Minutes, Seconds, Meridian) + * A number from 0 to 99, which means a year from 1900 to 1999, or + * The actual year (>=100). */ + static time_t +-Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode) +- time_t Month; +- time_t Day; +- time_t Year; +- time_t Hours; +- time_t Minutes; +- time_t Seconds; +- MERIDIAN Meridian; +- DSTMODE DSTmode; ++Convert(time_t Month, time_t Day, time_t Year, time_t Hours, time_t Minutes, ++ time_t Seconds, MERIDIAN Meridian, DSTMODE DSTmode) + { + static int DaysInMonth[12] = { + 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 +@@ -670,9 +658,7 @@ Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode) + + + static time_t +-DSTcorrect(Start, Future) +- time_t Start; +- time_t Future; ++DSTcorrect(time_t Start, time_t Future) + { + time_t StartDay; + time_t FutureDay; +@@ -684,10 +670,7 @@ DSTcorrect(Start, Future) + + + static time_t +-RelativeDate(Start, DayOrdinal, DayNumber) +- time_t Start; +- time_t DayOrdinal; +- time_t DayNumber; ++RelativeDate(time_t Start, time_t DayOrdinal, time_t DayNumber) + { + struct tm *tm; + time_t now; +@@ -701,9 +684,7 @@ RelativeDate(Start, DayOrdinal, DayNumber) + + + static time_t +-RelativeMonth(Start, RelMonth) +- time_t Start; +- time_t RelMonth; ++RelativeMonth(time_t Start, time_t RelMonth) + { + struct tm *tm; + time_t Month; +@@ -723,8 +704,7 @@ RelativeMonth(Start, RelMonth) + + + static int +-LookupWord(buff) +- char *buff; ++LookupWord(char *buff) + { + register char *p; + register char *q; +@@ -885,8 +865,7 @@ yylex() + + /* Yield A - B, measured in seconds. */ + static long +-difftm (a, b) +- struct tm *a, *b; ++difftm (struct tm *a, struct tm *b) + { + int ay = a->tm_year + (TM_YEAR_ORIGIN - 1); + int by = b->tm_year + (TM_YEAR_ORIGIN - 1); +@@ -906,9 +885,7 @@ difftm (a, b) + } + + time_t +-get_date(p, now) +- char *p; +- struct timeb *now; ++get_date(char *p, struct timeb *now) + { + struct tm *tm, gmt; + struct timeb ftz; +@@ -1006,9 +983,7 @@ get_date(p, now) + + /* ARGSUSED */ + int +-main(ac, av) +- int ac; +- char *av[]; ++main(int ac, char *av[]) + { + char buff[128]; + time_t d; +diff --git a/lib/getline.c b/lib/getline.c +index aebe245..e0ff215 100644 +--- a/lib/getline.c ++++ b/lib/getline.c +@@ -46,13 +46,13 @@ char *malloc (), *realloc (); + error. */ + + int +-getstr (lineptr, n, stream, terminator, offset, limit) +- char **lineptr; +- size_t *n; +- FILE *stream; +- int terminator; +- int offset; +- int limit; ++getstr ( ++ char **lineptr, ++ size_t *n, ++ FILE *stream, ++ int terminator, ++ int offset, ++ int limit) + { + int nchars_avail; /* Allocated but unused chars in *LINEPTR. */ + char *read_pos; /* Where we're reading into *LINEPTR. */ +@@ -155,20 +155,20 @@ getstr (lineptr, n, stream, terminator, offset, limit) + } + + ssize_t +-getline (lineptr, n, stream) +- char **lineptr; +- size_t *n; +- FILE *stream; ++getline ( ++ char **lineptr, ++ size_t *n, ++ FILE *stream) + { + return getstr (lineptr, n, stream, '\n', 0, GETLINE_NO_LIMIT); + } + + ssize_t +-getline_safe (lineptr, n, stream, limit) +- char **lineptr; +- size_t *n; +- FILE *stream; +- int limit; ++getline_safe ( ++ char **lineptr, ++ size_t *n, ++ FILE *stream, ++ int limit) + { + return getstr (lineptr, n, stream, '\n', 0, limit); + } +diff --git a/lib/getopt.h b/lib/getopt.h +index 9ba79f2..e962ec6 100644 +--- a/lib/getopt.h ++++ b/lib/getopt.h +@@ -115,6 +115,11 @@ struct option + #define optional_argument 2 + + #if __STDC__ ++#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 202311L ++/* CVS: ISO C 23 requires prototypes to match their definitions. ++ * If your system headers conflict, add here a new preprocessor branch. */ ++int getopt (int argc, char *const *argv, const char *optstring); ++#else + /* Many other libraries have conflicting prototypes for getopt, with + differences in the consts, in stdlib.h. We used to try to prototype + it if __GNU_LIBRARY__ but that wasn't problem free either (I'm not sure +@@ -122,6 +127,7 @@ struct option + We really shouldn't be trampling on the system's namespace at all by + declaring getopt() but that is a bigger issue. */ + extern int getopt (); ++#endif + + extern int getopt_long (int argc, char *const *argv, const char *shortopts, + const struct option *longopts, int *longind); +diff --git a/lib/md5.c b/lib/md5.c +index f9a3cad..e6e5684 100644 +--- a/lib/md5.c ++++ b/lib/md5.c +@@ -52,17 +52,16 @@ + surprised if they were a performance bottleneck for MD5. */ + + static cvs_uint32 +-getu32 (addr) +- const unsigned char *addr; ++getu32 (const unsigned char *addr) + { + return (((((unsigned long)addr[3] << 8) | addr[2]) << 8) + | addr[1]) << 8 | addr[0]; + } + + static void +-putu32 (data, addr) +- cvs_uint32 data; +- unsigned char *addr; ++putu32 ( ++ cvs_uint32 data, ++ unsigned char *addr) + { + addr[0] = (unsigned char)data; + addr[1] = (unsigned char)(data >> 8); +@@ -75,8 +74,7 @@ putu32 (data, addr) + * initialization constants. + */ + void +-cvs_MD5Init (ctx) +- struct cvs_MD5Context *ctx; ++cvs_MD5Init (struct cvs_MD5Context *ctx) + { + ctx->buf[0] = 0x67452301; + ctx->buf[1] = 0xefcdab89; +@@ -92,10 +90,10 @@ cvs_MD5Init (ctx) + * of bytes. + */ + void +-cvs_MD5Update (ctx, buf, len) +- struct cvs_MD5Context *ctx; +- unsigned char const *buf; +- unsigned len; ++cvs_MD5Update ( ++ struct cvs_MD5Context *ctx, ++ unsigned char const *buf, ++ unsigned len) + { + cvs_uint32 t; + +@@ -143,9 +141,9 @@ cvs_MD5Update (ctx, buf, len) + * 1 0* (64-bit count of bits processed, MSB-first) + */ + void +-cvs_MD5Final (digest, ctx) +- unsigned char digest[16]; +- struct cvs_MD5Context *ctx; ++cvs_MD5Final ( ++ unsigned char digest[16], ++ struct cvs_MD5Context *ctx) + { + unsigned count; + unsigned char *p; +@@ -206,9 +204,9 @@ cvs_MD5Final (digest, ctx) + * the data and converts bytes into longwords for this routine. + */ + void +-cvs_MD5Transform (buf, inraw) +- cvs_uint32 buf[4]; +- const unsigned char inraw[64]; ++cvs_MD5Transform ( ++ cvs_uint32 buf[4], ++ const unsigned char inraw[64]) + { + register cvs_uint32 a, b, c, d; + cvs_uint32 in[16]; +diff --git a/lib/regex.c b/lib/regex.c +index e824b5b..74585d0 100644 +--- a/lib/regex.c ++++ b/lib/regex.c +@@ -358,7 +358,9 @@ typedef char boolean; + #define false 0 + #define true 1 + +-static int re_match_2_internal (); ++static int re_match_2_internal (struct re_pattern_buffer *bufp, const char *string1, ++ int size1, const char *string2, int size2, int pos, ++ struct re_registers *regs, int stop); + + /* These are the command codes that appear in compiled regular + expressions. Some opcodes are followed by argument bytes. A +@@ -1047,8 +1049,7 @@ reg_syntax_t re_syntax_options; + defined in regex.h. We return the old syntax. */ + + reg_syntax_t +-re_set_syntax (syntax) +- reg_syntax_t syntax; ++re_set_syntax (reg_syntax_t syntax) + { + reg_syntax_t ret = re_syntax_options; + +@@ -1528,13 +1529,6 @@ static char reg_unset_dummy; + #define REG_UNSET_VALUE (®_unset_dummy) + #define REG_UNSET(e) ((e) == REG_UNSET_VALUE) + +-/* Subroutine declarations and macros for regex_compile. */ +- +-static void store_op1 (), store_op2 (); +-static void insert_op1 (), insert_op2 (); +-static boolean at_begline_loc_p (), at_endline_loc_p (); +-static boolean group_in_compile_stack (); +- + /* Fetch the next character in the uncompiled pattern---translating it + if necessary. Also cast from a signed character in the constant + string passed to us by the user to an unsigned char that we can use +@@ -1693,6 +1687,16 @@ typedef struct + unsigned avail; /* Offset of next open position. */ + } compile_stack_type; + ++/* Subroutine declarations and macros for regex_compile. */ ++ ++static void store_op1 (re_opcode_t op, unsigned char *loc, int arg); ++static void store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2); ++static void insert_op1 (re_opcode_t op, unsigned char *loc, int arg, unsigned char *end); ++static void insert_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2, unsigned char *end); ++static boolean at_begline_loc_p (const char *pattern, const char *p, reg_syntax_t syntax); ++static boolean at_endline_loc_p (const char *p, const char *pend, int syntax); ++static boolean group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum); ++ + + #define INIT_COMPILE_STACK_SIZE 32 + +@@ -1856,11 +1860,11 @@ regex_grow_registers (num_regs) + } while (0) + + static reg_errcode_t +-regex_compile (pattern, size, syntax, bufp) +- const char *pattern; +- int size; +- reg_syntax_t syntax; +- struct re_pattern_buffer *bufp; ++regex_compile ( ++ const char *pattern, ++ int size, ++ reg_syntax_t syntax, ++ struct re_pattern_buffer *bufp) + { + /* We fetch characters from PATTERN here. Even though PATTERN is + `char *' (i.e., signed), we declare these variables as unsigned, so +@@ -3031,10 +3035,10 @@ regex_compile (pattern, size, syntax, bufp) + /* Store OP at LOC followed by two-byte integer parameter ARG. */ + + static void +-store_op1 (op, loc, arg) +- re_opcode_t op; +- unsigned char *loc; +- int arg; ++store_op1 ( ++ re_opcode_t op, ++ unsigned char *loc, ++ int arg) + { + *loc = (unsigned char) op; + STORE_NUMBER (loc + 1, arg); +@@ -3044,10 +3048,10 @@ store_op1 (op, loc, arg) + /* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */ + + static void +-store_op2 (op, loc, arg1, arg2) +- re_opcode_t op; +- unsigned char *loc; +- int arg1, arg2; ++store_op2 ( ++ re_opcode_t op, ++ unsigned char *loc, ++ int arg1, int arg2) + { + *loc = (unsigned char) op; + STORE_NUMBER (loc + 1, arg1); +@@ -3059,11 +3063,11 @@ store_op2 (op, loc, arg1, arg2) + for OP followed by two-byte integer parameter ARG. */ + + static void +-insert_op1 (op, loc, arg, end) +- re_opcode_t op; +- unsigned char *loc; +- int arg; +- unsigned char *end; ++insert_op1 ( ++ re_opcode_t op, ++ unsigned char *loc, ++ int arg, ++ unsigned char *end) + { + register unsigned char *pfrom = end; + register unsigned char *pto = end + 3; +@@ -3078,11 +3082,11 @@ insert_op1 (op, loc, arg, end) + /* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */ + + static void +-insert_op2 (op, loc, arg1, arg2, end) +- re_opcode_t op; +- unsigned char *loc; +- int arg1, arg2; +- unsigned char *end; ++insert_op2 ( ++ re_opcode_t op, ++ unsigned char *loc, ++ int arg1, int arg2, ++ unsigned char *end) + { + register unsigned char *pfrom = end; + register unsigned char *pto = end + 5; +@@ -3099,9 +3103,7 @@ insert_op2 (op, loc, arg1, arg2, end) + least one character before the ^. */ + + static boolean +-at_begline_loc_p (pattern, p, syntax) +- const char *pattern, *p; +- reg_syntax_t syntax; ++at_begline_loc_p (const char *pattern, const char *p, reg_syntax_t syntax) + { + const char *prev = p - 2; + boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\'; +@@ -3118,9 +3120,7 @@ at_begline_loc_p (pattern, p, syntax) + at least one character after the $, i.e., `P < PEND'. */ + + static boolean +-at_endline_loc_p (p, pend, syntax) +- const char *p, *pend; +- int syntax; ++at_endline_loc_p (const char *p, const char *pend, int syntax) + { + const char *next = p; + boolean next_backslash = *next == '\\'; +@@ -3140,9 +3140,9 @@ at_endline_loc_p (p, pend, syntax) + false if it's not. */ + + static boolean +-group_in_compile_stack (compile_stack, regnum) +- compile_stack_type compile_stack; +- regnum_t regnum; ++group_in_compile_stack ( ++ compile_stack_type compile_stack, ++ regnum_t regnum) + { + int this_element; + +@@ -3169,8 +3169,7 @@ group_in_compile_stack (compile_stack, regnum) + Returns 0 if we succeed, -2 if an internal error. */ + + int +-re_compile_fastmap (bufp) +- struct re_pattern_buffer *bufp; ++re_compile_fastmap (struct re_pattern_buffer *bufp) + { + int i, j, k; + #ifdef MATCH_MAY_ALLOCATE +@@ -3628,11 +3627,11 @@ re_compile_fastmap (bufp) + freeing the old data. */ + + void +-re_set_registers (bufp, regs, num_regs, starts, ends) +- struct re_pattern_buffer *bufp; +- struct re_registers *regs; +- unsigned num_regs; +- regoff_t *starts, *ends; ++re_set_registers ( ++ struct re_pattern_buffer *bufp, ++ struct re_registers *regs, ++ unsigned num_regs, ++ regoff_t *starts, regoff_t *ends) + { + if (num_regs) + { +@@ -3655,11 +3654,11 @@ re_set_registers (bufp, regs, num_regs, starts, ends) + doesn't let you say where to stop matching. */ + + int +-re_search (bufp, string, size, startpos, range, regs) +- struct re_pattern_buffer *bufp; +- const char *string; +- int size, startpos, range; +- struct re_registers *regs; ++re_search ( ++ struct re_pattern_buffer *bufp, ++ const char *string, ++ int size, int startpos, int range, ++ struct re_registers *regs) + { + return re_search_2 (bufp, NULL, 0, string, size, startpos, range, + regs, size); +@@ -3695,14 +3694,16 @@ re_search (bufp, string, size, startpos, range, regs) + stack overflow). */ + + int +-re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop) +- struct re_pattern_buffer *bufp; +- const char *string1, *string2; +- int size1, size2; +- int startpos; +- int range; +- struct re_registers *regs; +- int stop; ++re_search_2 ( ++ struct re_pattern_buffer *bufp, ++ const char *string1, ++ int size1, ++ const char *string2, ++ int size2, ++ int startpos, ++ int range, ++ struct re_registers *regs, ++ int stop) + { + int val; + register char *fastmap = bufp->fastmap; +@@ -3936,10 +3937,14 @@ re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop) + + /* Declarations and macros for re_match_2. */ + +-static int bcmp_translate (); +-static boolean alt_match_null_string_p (), +- common_op_match_null_string_p (), +- group_match_null_string_p (); ++static int bcmp_translate (const unsigned char *s1, const unsigned char *s2, ++ register int len, RE_TRANSLATE_TYPE translate); ++static boolean alt_match_null_string_p (unsigned char *p, unsigned char *end, ++ register_info_type *reg_info); ++static boolean common_op_match_null_string_p (unsigned char **p, ++ unsigned char *end, register_info_type *reg_info); ++static boolean group_match_null_string_p (unsigned char **p, ++ unsigned char *end, register_info_type *reg_info); + + /* This converts PTR, a pointer into one of the search strings `string1' + and `string2' into an offset from the beginning of that string. */ +@@ -4035,11 +4040,11 @@ static boolean alt_match_null_string_p (), + /* re_match is like re_match_2 except it takes only a single string. */ + + int +-re_match (bufp, string, size, pos, regs) +- struct re_pattern_buffer *bufp; +- const char *string; +- int size, pos; +- struct re_registers *regs; ++re_match ( ++ struct re_pattern_buffer *bufp, ++ const char *string, ++ int size, int pos, ++ struct re_registers *regs) + { + int result = re_match_2_internal (bufp, NULL, 0, string, size, + pos, regs, size); +@@ -4072,13 +4077,15 @@ Lisp_Object re_match_object; + matched substring. */ + + int +-re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop) +- struct re_pattern_buffer *bufp; +- const char *string1, *string2; +- int size1, size2; +- int pos; +- struct re_registers *regs; +- int stop; ++re_match_2 ( ++ struct re_pattern_buffer *bufp, ++ const char *string1, ++ int size1, ++ const char *string2, ++ int size2, ++ int pos, ++ struct re_registers *regs, ++ int stop) + { + int result; + +@@ -4103,13 +4110,15 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop) + /* This is a separate function so that we can force an alloca cleanup + afterwards. */ + static int +-re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop) +- struct re_pattern_buffer *bufp; +- const char *string1, *string2; +- int size1, size2; +- int pos; +- struct re_registers *regs; +- int stop; ++re_match_2_internal ( ++ struct re_pattern_buffer *bufp, ++ const char *string1, ++ int size1, ++ const char *string2, ++ int size2, ++ int pos, ++ struct re_registers *regs, ++ int stop) + { + /* General temporaries. */ + int mcnt; +@@ -4908,7 +4917,7 @@ re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop) + /* Compare that many; failure if mismatch, else move + past them. */ + if (RE_TRANSLATE_P (translate) +- ? bcmp_translate (d, d2, mcnt, translate) ++ ? bcmp_translate ((const unsigned char *)d, (const unsigned char *)d2, mcnt, translate) + : bcmp (d, d2, mcnt)) + goto fail; + d += mcnt, d2 += mcnt; +@@ -5759,9 +5768,9 @@ re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop) + We don't handle duplicates properly (yet). */ + + static boolean +-group_match_null_string_p (p, end, reg_info) +- unsigned char **p, *end; +- register_info_type *reg_info; ++group_match_null_string_p ( ++ unsigned char **p, unsigned char *end, ++ register_info_type *reg_info) + { + int mcnt; + /* Point to after the args to the start_memory. */ +@@ -5868,9 +5877,9 @@ group_match_null_string_p (p, end, reg_info) + byte past the last. The alternative can contain groups. */ + + static boolean +-alt_match_null_string_p (p, end, reg_info) +- unsigned char *p, *end; +- register_info_type *reg_info; ++alt_match_null_string_p ( ++ unsigned char *p, unsigned char *end, ++ register_info_type *reg_info) + { + int mcnt; + unsigned char *p1 = p; +@@ -5905,9 +5914,9 @@ alt_match_null_string_p (p, end, reg_info) + Sets P to one after the op and its arguments, if any. */ + + static boolean +-common_op_match_null_string_p (p, end, reg_info) +- unsigned char **p, *end; +- register_info_type *reg_info; ++common_op_match_null_string_p ( ++ unsigned char **p, unsigned char *end, ++ register_info_type *reg_info) + { + int mcnt; + boolean ret; +@@ -5993,14 +6002,14 @@ common_op_match_null_string_p (p, end, reg_info) + bytes; nonzero otherwise. */ + + static int +-bcmp_translate (s1, s2, len, translate) +- unsigned char *s1, *s2; +- register int len; +- RE_TRANSLATE_TYPE translate; ++bcmp_translate ( ++ const unsigned char *s1, const unsigned char *s2, ++ register int len, ++ RE_TRANSLATE_TYPE translate) + { +- register unsigned char *p1 = s1, *p2 = s2; +- unsigned char *p1_end = s1 + len; +- unsigned char *p2_end = s2 + len; ++ register const unsigned char *p1 = s1, *p2 = s2; ++ const unsigned char *p1_end = s1 + len; ++ const unsigned char *p2_end = s2 + len; + + while (p1 != p1_end && p2 != p2_end) + { +@@ -6035,10 +6044,10 @@ bcmp_translate (s1, s2, len, translate) + We call regex_compile to do the actual compilation. */ + + const char * +-re_compile_pattern (pattern, length, bufp) +- const char *pattern; +- int length; +- struct re_pattern_buffer *bufp; ++re_compile_pattern ( ++ const char *pattern, ++ int length, ++ struct re_pattern_buffer *bufp) + { + reg_errcode_t ret; + +@@ -6076,8 +6085,7 @@ char * + regcomp/regexec below without link errors. */ + weak_function + #endif +-re_comp (s) +- const char *s; ++re_comp (const char *s) + { + reg_errcode_t ret; + +@@ -6122,8 +6130,7 @@ int + #ifdef _LIBC + weak_function + #endif +-re_exec (s) +- const char *s; ++re_exec (const char *s) + { + const int len = strlen (s); + return +@@ -6170,10 +6177,10 @@ re_exec (s) + the return codes and their meanings.) */ + + int +-regcomp (preg, pattern, cflags) +- regex_t *preg; +- const char *pattern; +- int cflags; ++regcomp ( ++ regex_t *preg, ++ const char *pattern, ++ int cflags) + { + reg_errcode_t ret; + unsigned syntax +@@ -6248,12 +6255,12 @@ regcomp (preg, pattern, cflags) + We return 0 if we find a match and REG_NOMATCH if not. */ + + int +-regexec (preg, string, nmatch, pmatch, eflags) +- const regex_t *preg; +- const char *string; +- size_t nmatch; +- regmatch_t pmatch[]; +- int eflags; ++regexec ( ++ const regex_t *preg, ++ const char *string, ++ size_t nmatch, ++ regmatch_t pmatch[], ++ int eflags) + { + int ret; + struct re_registers regs; +@@ -6313,11 +6320,11 @@ regexec (preg, string, nmatch, pmatch, eflags) + from either regcomp or regexec. We don't use PREG here. */ + + size_t +-regerror (errorCode, preg, errbuf, errbuf_size) +- int errorCode; +- const regex_t *preg; +- char *errbuf; +- size_t errbuf_size; ++regerror ( ++ int errorCode, ++ const regex_t *preg, ++ char *errbuf, ++ size_t errbuf_size) + { + const char *msg; + size_t msg_size; +@@ -6352,8 +6359,7 @@ regerror (errorCode, preg, errbuf, errbuf_size) + /* Free dynamically allocated space used by PREG. */ + + void +-regfree (preg) +- regex_t *preg; ++regfree (regex_t *preg) + { + if (preg->buffer != NULL) + free (preg->buffer); +diff --git a/lib/regex.h b/lib/regex.h +index 6c0c850..02798ee 100644 +--- a/lib/regex.h ++++ b/lib/regex.h +@@ -288,7 +288,7 @@ typedef enum + private to the regex routines. */ + + #ifndef RE_TRANSLATE_TYPE +-#define RE_TRANSLATE_TYPE char * ++#define RE_TRANSLATE_TYPE unsigned char * + #define RE_TRANSLATE(TBL, C) ((TBL)[C]) + #define RE_TRANSLATE_P(TBL) (TBL) + #endif +@@ -484,10 +484,17 @@ extern void re_set_registers + + #ifdef _REGEX_RE_COMP + /* 4.2 bsd compatibility. */ ++#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 202311L ++/* CVS: ISO C 23 requires prototypes to match their definitions. ++ * If your system headers conflict, add here a new preprocessor branch. */ ++extern char *re_comp _RE_ARGS ((const char *regex)); ++extern int re_exec _RE_ARGS ((const char *string)); ++#else + /* CVS: don't use prototypes: they may conflict with system headers. */ + extern char *re_comp _RE_ARGS (()); + extern int re_exec _RE_ARGS (()); + #endif ++#endif + + /* POSIX compatibility. */ + /* CVS - DRP +diff --git a/lib/savecwd.c b/lib/savecwd.c +index 2d687c3..9dd6a7d 100644 +--- a/lib/savecwd.c ++++ b/lib/savecwd.c +@@ -47,8 +47,7 @@ char *xgetwd __PROTO((void)); + called, but doing so is ok. Otherwise, return zero. */ + + int +-save_cwd (cwd) +- struct saved_cwd *cwd; ++save_cwd (struct saved_cwd *cwd) + { + static int have_working_fchdir = 1; + +@@ -108,9 +107,9 @@ save_cwd (cwd) + */ + + int +-restore_cwd (cwd, dest) +- const struct saved_cwd *cwd; +- const char *dest; ++restore_cwd ( ++ const struct saved_cwd *cwd, ++ const char *dest) + { + int fail = 0; + if (cwd->desc >= 0) +@@ -131,8 +130,7 @@ restore_cwd (cwd, dest) + } + + void +-free_cwd (cwd) +- struct saved_cwd *cwd; ++free_cwd (struct saved_cwd *cwd) + { + if (cwd->desc >= 0) + close (cwd->desc); +diff --git a/lib/sighandle.c b/lib/sighandle.c +index 2d21df8..e30320f 100644 +--- a/lib/sighandle.c ++++ b/lib/sighandle.c +@@ -65,7 +65,7 @@ char *malloc(); + + /* Define linked list of signal handlers structure */ + struct SIG_hlist { +- RETSIGTYPE (*handler)(); ++ RETSIGTYPE (*handler)(int); + struct SIG_hlist *next; + }; + +@@ -146,8 +146,7 @@ static int SIG_init() + */ + static RETSIGTYPE SIG_handle PROTO ((int)); + +-static RETSIGTYPE SIG_handle(sig) +-int sig; ++static RETSIGTYPE SIG_handle(int sig) + { + struct SIG_hlist *this; + +@@ -170,9 +169,9 @@ int sig; + * restoration later. + */ + +-int SIG_register(sig,fn) +-int sig; +-RETSIGTYPE (*fn)(); ++int SIG_register( ++ int sig, ++ RETSIGTYPE (*fn)(int)) + { + int val; + struct SIG_hlist *this; +@@ -273,9 +272,9 @@ RETSIGTYPE (*fn)(); + * a given signal is deregistered, the default sigvec information is restored. + */ + +-int SIG_deregister(sig,fn) +-int sig; +-RETSIGTYPE (*fn)(); ++int SIG_deregister( ++ int sig, ++ RETSIGTYPE (*fn)(int)) + { + int val; + struct SIG_hlist *this; +diff --git a/lib/stripslash.c b/lib/stripslash.c +index ece8ec8..03c38ca 100644 +--- a/lib/stripslash.c ++++ b/lib/stripslash.c +@@ -29,8 +29,7 @@ + /* Remove trailing slashes from PATH. */ + + void +-strip_trailing_slashes (path) +- char *path; ++strip_trailing_slashes (char *path) + { + int last; + +diff --git a/lib/xgetwd.c b/lib/xgetwd.c +index bbae81d..6449691 100644 +--- a/lib/xgetwd.c ++++ b/lib/xgetwd.c +@@ -29,8 +29,8 @@ extern int errno; + /* Amount by which to increase buffer size when allocating more space. */ + #define PATH_INCR 32 + +-char *xmalloc (); +-char *xrealloc (); ++void *xmalloc (size_t bytes); ++void *xrealloc (void *ptr, size_t bytes); + + /* Return the current directory, newly allocated, arbitrarily long. + Return NULL and set errno on error. */ +diff --git a/src/add.c b/src/add.c +index 228ae69..2484f3f 100644 +--- a/src/add.c ++++ b/src/add.c +@@ -50,9 +50,9 @@ static const char *const add_usage[] = + }; + + int +-add (argc, argv) +- int argc; +- char **argv; ++add ( ++ int argc, ++ char **argv) + { + char *message = NULL; + int i; +@@ -733,8 +733,7 @@ skip_this_file: + * Returns 1 on failure, 0 on success. + */ + static int +-add_directory (finfo) +- struct file_info *finfo; ++add_directory (struct file_info *finfo) + { + const char *repository = finfo->repository; + List *entries = finfo->entries; +@@ -909,13 +908,13 @@ out: + * interrogating the user. Returns non-zero on error. + */ + static int +-build_entry (repository, user, options, message, entries, tag) +- const char *repository; +- const char *user; +- const char *options; +- const char *message; +- List *entries; +- const char *tag; ++build_entry ( ++ const char *repository, ++ const char *user, ++ const char *options, ++ const char *message, ++ List *entries, ++ const char *tag) + { + char *fname; + char *line; +diff --git a/src/admin.c b/src/admin.c +index 186e27c..6b2eb83 100644 +--- a/src/admin.c ++++ b/src/admin.c +@@ -117,10 +117,10 @@ struct admin_data + happen depends on whether the option was specified as optional to + getopt). */ + static void +-arg_add (dat, opt, arg) +- struct admin_data *dat; +- int opt; +- char *arg; ++arg_add ( ++ struct admin_data *dat, ++ int opt, ++ char *arg) + { + char *newelt = xmalloc ((arg == NULL ? 0 : strlen (arg)) + 3); + strcpy (newelt, "-"); +@@ -145,14 +145,14 @@ arg_add (dat, opt, arg) + } + + int +-admin (argc, argv) +- int argc; +- char **argv; ++admin ( ++ int argc, ++ char **argv) + { + int err; + #ifdef CVS_ADMIN_GROUP + struct group *grp; +- struct group *getgrnam(); ++ struct group *getgrnam(const char *name); + #endif + struct admin_data admin_data; + int c; +@@ -549,9 +549,9 @@ admin (argc, argv) + */ + /* ARGSUSED */ + static int +-admin_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++admin_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + struct admin_data *admin_data = (struct admin_data *) callerdat; + Vers_TS *vers; +@@ -937,12 +937,12 @@ admin_fileproc (callerdat, finfo) + */ + /* ARGSUSED */ + static Dtype +-admin_dirproc (callerdat, dir, repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repos; +- const char *update_dir; +- List *entries; ++admin_dirproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + if (!quiet) + error (0, 0, "Administrating %s", update_dir); +diff --git a/src/annotate.c b/src/annotate.c +index d6d0acc..47edfc4 100644 +--- a/src/annotate.c ++++ b/src/annotate.c +@@ -51,9 +51,9 @@ static const char *const annotate_usage[] = + file was modified. */ + + int +-annotate (argc, argv) +- int argc; +- char **argv; ++annotate ( ++ int argc, ++ char **argv) + { + int local = 0; + int err = 0; +@@ -157,16 +157,16 @@ annotate (argc, argv) + + + static int +-rannotate_proc (argc, argv, xwhere, mwhere, mfile, shorten, local, mname, msg) +- int argc; +- char **argv; +- char *xwhere; +- char *mwhere; +- char *mfile; +- int shorten; +- int local; +- char *mname; +- char *msg; ++rannotate_proc ( ++ int argc, ++ char **argv, ++ char *xwhere, ++ char *mwhere, ++ char *mfile, ++ int shorten, ++ int local, ++ char *mname, ++ char *msg) + { + /* Begin section which is identical to patch_proc--should this + be abstracted out somehow? */ +@@ -263,9 +263,9 @@ rannotate_proc (argc, argv, xwhere, mwhere, mfile, shorten, local, mname, msg) + + + static int +-annotate_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++annotate_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + char *expand, *version; + +diff --git a/src/buffer.c b/src/buffer.c +index 6da0433..cec5ebb 100644 +--- a/src/buffer.c ++++ b/src/buffer.c +@@ -43,14 +43,14 @@ static struct buffer_data *get_buffer_data PROTO((void)); + /* Initialize a buffer structure. */ + + struct buffer * +-buf_initialize (input, output, flush, block, shutdown, memory, closure) +- int (*input) PROTO((void *, char *, int, int, int *)); +- int (*output) PROTO((void *, const char *, int, int *)); +- int (*flush) PROTO((void *)); +- int (*block) PROTO((void *, int)); +- int (*shutdown) PROTO((struct buffer *)); +- void (*memory) PROTO((struct buffer *)); +- void *closure; ++buf_initialize ( ++ int (*input) PROTO((void *, char *, int, int, int *)), ++ int (*output) PROTO((void *, const char *, int, int *)), ++ int (*flush) PROTO((void *)), ++ int (*block) PROTO((void *, int)), ++ int (*shutdown) PROTO((struct buffer *)), ++ void (*memory) PROTO((struct buffer *)), ++ void *closure) + { + struct buffer *buf; + +@@ -71,8 +71,7 @@ buf_initialize (input, output, flush, block, shutdown, memory, closure) + /* Free a buffer structure. */ + + void +-buf_free (buf) +- struct buffer *buf; ++buf_free (struct buffer *buf) + { + if (buf->closure != NULL) + { +@@ -90,8 +89,7 @@ buf_free (buf) + /* Initialize a buffer structure which is not to be used for I/O. */ + + struct buffer * +-buf_nonio_initialize (memory) +- void (*memory) PROTO((struct buffer *)); ++buf_nonio_initialize (void (*memory) PROTO((struct buffer *))) + { + return (buf_initialize + ((int (*) PROTO((void *, char *, int, int, int *))) NULL, +@@ -106,8 +104,7 @@ buf_nonio_initialize (memory) + /* Default memory error handler. */ + + static void +-buf_default_memory_error (buf) +- struct buffer *buf; ++buf_default_memory_error (struct buffer *buf) + { + error (1, 0, "out of memory"); + } +@@ -162,8 +159,7 @@ get_buffer_data () + + /* See whether a buffer and its file descriptor is empty. */ + int +-buf_empty (buf) +- struct buffer *buf; ++buf_empty (struct buffer *buf) + { + /* Try and read any data on the file descriptor first. + * We already know the descriptor is non-blocking. +@@ -176,8 +172,7 @@ buf_empty (buf) + + /* See whether a buffer is empty. */ + int +-buf_empty_p (buf) +- struct buffer *buf; ++buf_empty_p (struct buffer *buf) + { + struct buffer_data *data; + +@@ -196,8 +191,7 @@ buf_empty_p (buf) + */ + + int +-buf_count_mem (buf) +- struct buffer *buf; ++buf_count_mem (struct buffer *buf) + { + struct buffer_data *data; + int mem = 0; +@@ -212,10 +206,10 @@ buf_count_mem (buf) + /* Add data DATA of length LEN to BUF. */ + + void +-buf_output (buf, data, len) +- struct buffer *buf; +- const char *data; +- int len; ++buf_output ( ++ struct buffer *buf, ++ const char *data, ++ int len) + { + if (buf->data != NULL + && (((buf->last->text + BUFFER_DATA_SIZE) +@@ -267,9 +261,9 @@ buf_output (buf, data, len) + /* Add a '\0' terminated string to BUF. */ + + void +-buf_output0 (buf, string) +- struct buffer *buf; +- const char *string; ++buf_output0 ( ++ struct buffer *buf, ++ const char *string) + { + buf_output (buf, string, strlen (string)); + } +@@ -277,9 +271,9 @@ buf_output0 (buf, string) + /* Add a single character to BUF. */ + + void +-buf_append_char (buf, ch) +- struct buffer *buf; +- int ch; ++buf_append_char ( ++ struct buffer *buf, ++ int ch) + { + if (buf->data != NULL + && (buf->last->text + BUFFER_DATA_SIZE +@@ -304,8 +298,7 @@ buf_append_char (buf, ch) + */ + + int +-buf_send_output (buf) +- struct buffer *buf; ++buf_send_output (struct buffer *buf) + { + if (buf->output == NULL) + abort (); +@@ -367,9 +360,9 @@ buf_send_output (buf) + */ + + int +-buf_flush (buf, block) +- struct buffer *buf; +- int block; ++buf_flush ( ++ struct buffer *buf, ++ int block) + { + int nonblocking; + int status; +@@ -407,8 +400,7 @@ buf_flush (buf, block) + */ + + int +-set_nonblock (buf) +- struct buffer *buf; ++set_nonblock (struct buffer *buf) + { + int status; + +@@ -429,8 +421,7 @@ set_nonblock (buf) + */ + + int +-set_block (buf) +- struct buffer *buf; ++set_block (struct buffer *buf) + { + int status; + +@@ -454,8 +445,7 @@ set_block (buf) + */ + + int +-buf_send_counted (buf) +- struct buffer *buf; ++buf_send_counted (struct buffer *buf) + { + int size; + struct buffer_data *data; +@@ -494,9 +484,9 @@ buf_send_counted (buf) + */ + + int +-buf_send_special_count (buf, count) +- struct buffer *buf; +- int count; ++buf_send_special_count ( ++ struct buffer *buf, ++ int count) + { + struct buffer_data *data; + +@@ -523,10 +513,10 @@ buf_send_special_count (buf, count) + /* Append a list of buffer_data structures to an buffer. */ + + void +-buf_append_data (buf, data, last) +- struct buffer *buf; +- struct buffer_data *data; +- struct buffer_data *last; ++buf_append_data ( ++ struct buffer *buf, ++ struct buffer_data *data, ++ struct buffer_data *last) + { + if (data != NULL) + { +@@ -542,9 +532,9 @@ buf_append_data (buf, data, last) + from the source buffer. */ + + void +-buf_append_buffer (to, from) +- struct buffer *to; +- struct buffer *from; ++buf_append_buffer ( ++ struct buffer *to, ++ struct buffer *from) + { + buf_append_data (to, from->data, from->last); + from->data = NULL; +@@ -562,11 +552,11 @@ buf_append_buffer (to, from) + */ + + int +-buf_read_file (f, size, retp, lastp) +- FILE *f; +- long size; +- struct buffer_data **retp; +- struct buffer_data **lastp; ++buf_read_file ( ++ FILE *f, ++ long size, ++ struct buffer_data **retp, ++ struct buffer_data **lastp) + { + int status; + +@@ -631,10 +621,10 @@ buf_read_file (f, size, retp, lastp) + */ + + int +-buf_read_file_to_eof (f, retp, lastp) +- FILE *f; +- struct buffer_data **retp; +- struct buffer_data **lastp; ++buf_read_file_to_eof ( ++ FILE *f, ++ struct buffer_data **retp, ++ struct buffer_data **lastp) + { + int status; + +@@ -690,8 +680,7 @@ buf_read_file_to_eof (f, retp, lastp) + /* Return the number of bytes in a chain of buffer_data structures. */ + + int +-buf_chain_length (buf) +- struct buffer_data *buf; ++buf_chain_length (struct buffer_data *buf) + { + int size = 0; + while (buf) +@@ -705,8 +694,7 @@ buf_chain_length (buf) + /* Return the number of bytes in a buffer. */ + + int +-buf_length (buf) +- struct buffer *buf; ++buf_length (struct buffer *buf) + { + return buf_chain_length (buf->data); + } +@@ -720,9 +708,9 @@ buf_length (buf) + */ + + int +-buf_input_data (buf, countp) +- struct buffer *buf; +- int *countp; ++buf_input_data ( ++ struct buffer *buf, ++ int *countp) + { + if (buf->input == NULL) + abort (); +@@ -795,10 +783,10 @@ buf_input_data (buf, countp) + */ + + int +-buf_read_line (buf, line, lenp) +- struct buffer *buf; +- char **line; +- int *lenp; ++buf_read_line ( ++ struct buffer *buf, ++ char **line, ++ int *lenp) + { + if (buf->input == NULL) + abort (); +@@ -932,11 +920,11 @@ buf_read_line (buf, line, lenp) + */ + + int +-buf_read_data (buf, want, retdata, got) +- struct buffer *buf; +- int want; +- char **retdata; +- int *got; ++buf_read_data ( ++ struct buffer *buf, ++ int want, ++ char **retdata, ++ int *got) + { + if (buf->input == NULL) + abort (); +@@ -1007,10 +995,10 @@ buf_read_data (buf, want, retdata, got) + */ + + void +-buf_copy_lines (outbuf, inbuf, command) +- struct buffer *outbuf; +- struct buffer *inbuf; +- int command; ++buf_copy_lines ( ++ struct buffer *outbuf, ++ struct buffer *inbuf, ++ int command) + { + while (1) + { +@@ -1091,10 +1079,10 @@ buf_copy_lines (outbuf, inbuf, command) + */ + + int +-buf_copy_counted (outbuf, inbuf, special) +- struct buffer *outbuf; +- struct buffer *inbuf; +- int *special; ++buf_copy_counted ( ++ struct buffer *outbuf, ++ struct buffer *inbuf, ++ int *special) + { + *special = 0; + +@@ -1238,8 +1226,7 @@ buf_copy_counted (outbuf, inbuf, special) + /* Shut down a buffer. This returns 0 on success, or an errno code. */ + + int +-buf_shutdown (buf) +- struct buffer *buf; ++buf_shutdown (struct buffer *buf) + { + if (buf->shutdown) + return (*buf->shutdown) (buf); +@@ -1270,11 +1257,11 @@ struct stdio_buffer_closure + + + struct buffer * +-stdio_buffer_initialize (fp, child_pid, input, memory) +- FILE *fp; +- int child_pid; +- int input; +- void (*memory) PROTO((struct buffer *)); ++stdio_buffer_initialize ( ++ FILE *fp, ++ int child_pid, ++ int input, ++ void (*memory) PROTO((struct buffer *))) + { + struct stdio_buffer_closure *bc = xmalloc (sizeof (*bc)); + +@@ -1292,8 +1279,7 @@ stdio_buffer_initialize (fp, child_pid, input, memory) + + /* Return the file associated with a stdio buffer. */ + FILE * +-stdio_buffer_get_file (buf) +- struct buffer *buf; ++stdio_buffer_get_file (struct buffer *buf) + { + struct stdio_buffer_closure *bc; + +@@ -1307,12 +1293,12 @@ stdio_buffer_get_file (buf) + /* The buffer input function for a buffer built on a stdio FILE. */ + + static int +-stdio_buffer_input (closure, data, need, size, got) +- void *closure; +- char *data; +- int need; +- int size; +- int *got; ++stdio_buffer_input ( ++ void *closure, ++ char *data, ++ int need, ++ int size, ++ int *got) + { + struct stdio_buffer_closure *bc = (struct stdio_buffer_closure *) closure; + int nbytes; +@@ -1362,11 +1348,11 @@ stdio_buffer_input (closure, data, need, size, got) + /* The buffer output function for a buffer built on a stdio FILE. */ + + static int +-stdio_buffer_output (closure, data, have, wrote) +- void *closure; +- const char *data; +- int have; +- int *wrote; ++stdio_buffer_output ( ++ void *closure, ++ const char *data, ++ int have, ++ int *wrote) + { + struct stdio_buffer_closure *bc = (struct stdio_buffer_closure *) closure; + +@@ -1398,8 +1384,7 @@ stdio_buffer_output (closure, data, have, wrote) + + /* The buffer flush function for a buffer built on a stdio FILE. */ + static int +-stdio_buffer_flush (closure) +- void *closure; ++stdio_buffer_flush (void *closure) + { + struct stdio_buffer_closure *bc = (struct stdio_buffer_closure *) closure; + +@@ -1417,8 +1402,7 @@ stdio_buffer_flush (closure) + + + static int +-stdio_buffer_shutdown (buf) +- struct buffer *buf; ++stdio_buffer_shutdown (struct buffer *buf) + { + struct stdio_buffer_closure *bc = buf->closure; + struct stat s; +@@ -1600,12 +1584,12 @@ static int packetizing_buffer_shutdown PROTO((struct buffer *)); + /* Create a packetizing buffer. */ + + struct buffer * +-packetizing_buffer_initialize (buf, inpfn, outfn, fnclosure, memory) +- struct buffer *buf; +- int (*inpfn) PROTO ((void *, const char *, char *, int)); +- int (*outfn) PROTO ((void *, const char *, char *, int, int *)); +- void *fnclosure; +- void (*memory) PROTO((struct buffer *)); ++packetizing_buffer_initialize ( ++ struct buffer *buf, ++ int (*inpfn) PROTO ((void *, const char *, char *, int)), ++ int (*outfn) PROTO ((void *, const char *, char *, int, int *)), ++ void *fnclosure, ++ void (*memory) PROTO((struct buffer *))) + { + struct packetizing_buffer *pb; + +@@ -1638,12 +1622,12 @@ packetizing_buffer_initialize (buf, inpfn, outfn, fnclosure, memory) + /* Input data from a packetizing buffer. */ + + static int +-packetizing_buffer_input (closure, data, need, size, got) +- void *closure; +- char *data; +- int need; +- int size; +- int *got; ++packetizing_buffer_input ( ++ void *closure, ++ char *data, ++ int need, ++ int size, ++ int *got) + { + struct packetizing_buffer *pb = (struct packetizing_buffer *) closure; + +@@ -1851,11 +1835,11 @@ packetizing_buffer_input (closure, data, need, size, got) + /* Output data to a packetizing buffer. */ + + static int +-packetizing_buffer_output (closure, data, have, wrote) +- void *closure; +- const char *data; +- int have; +- int *wrote; ++packetizing_buffer_output ( ++ void *closure, ++ const char *data, ++ int have, ++ int *wrote) + { + struct packetizing_buffer *pb = (struct packetizing_buffer *) closure; + char inbuf[BUFFER_DATA_SIZE + 2]; +@@ -1936,8 +1920,7 @@ packetizing_buffer_output (closure, data, have, wrote) + + /* Flush data to a packetizing buffer. */ + static int +-packetizing_buffer_flush (closure) +- void *closure; ++packetizing_buffer_flush (void *closure) + { + struct packetizing_buffer *pb = (struct packetizing_buffer *) closure; + +@@ -1952,9 +1935,9 @@ packetizing_buffer_flush (closure) + + /* The block routine for a packetizing buffer. */ + static int +-packetizing_buffer_block (closure, block) +- void *closure; +- int block; ++packetizing_buffer_block ( ++ void *closure, ++ int block) + { + struct packetizing_buffer *pb = (struct packetizing_buffer *) closure; + +@@ -1967,8 +1950,7 @@ packetizing_buffer_block (closure, block) + /* Shut down a packetizing buffer. */ + + static int +-packetizing_buffer_shutdown (buf) +- struct buffer *buf; ++packetizing_buffer_shutdown (struct buffer *buf) + { + struct packetizing_buffer *pb = (struct packetizing_buffer *) buf->closure; + +diff --git a/src/checkin.c b/src/checkin.c +index 06d431f..af40a43 100644 +--- a/src/checkin.c ++++ b/src/checkin.c +@@ -26,13 +26,13 @@ + #include "edit.h" + + int +-Checkin (type, finfo, rev, tag, options, message) +- int type; +- struct file_info *finfo; +- char *rev; +- char *tag; +- char *options; +- char *message; ++Checkin ( ++ int type, ++ struct file_info *finfo, ++ char *rev, ++ char *tag, ++ char *options, ++ char *message) + { + Vers_TS *vers; + int set_time; +diff --git a/src/checkout.c b/src/checkout.c +index e4d80ea..d89f57a 100644 +--- a/src/checkout.c ++++ b/src/checkout.c +@@ -102,9 +102,9 @@ static char *history_name; + static enum mtype m_type; + + int +-checkout (argc, argv) +- int argc; +- char **argv; ++checkout ( ++ int argc, ++ char **argv) + { + int i; + int c; +@@ -417,8 +417,7 @@ checkout (argc, argv) + * being able to resolve a path or failing ot chdir to a path. + */ + int +-safe_location (where) +- char *where; ++safe_location (char *where) + { + char *current; + char *where_location; +@@ -543,10 +542,10 @@ static int build_dirs_and_chdir PROTO ((struct dir_to_build *list, + static void build_one_dir PROTO ((char *, char *, int)); + + static void +-build_one_dir (repository, dirpath, sticky) +- char *repository; +- char *dirpath; +- int sticky; ++build_one_dir ( ++ char *repository, ++ char *dirpath, ++ int sticky) + { + FILE *fp; + +@@ -592,17 +591,16 @@ build_one_dir (repository, dirpath, sticky) + */ + /* ARGSUSED */ + static int +-checkout_proc (argc, argv, where_orig, mwhere, mfile, shorten, +- local_specified, omodule, msg) +- int argc; +- char **argv; +- char *where_orig; +- char *mwhere; +- char *mfile; +- int shorten; +- int local_specified; +- char *omodule; +- char *msg; ++checkout_proc ( ++ int argc, ++ char **argv, ++ char *where_orig, ++ char *mwhere, ++ char *mfile, ++ int shorten, ++ int local_specified, ++ char *omodule, ++ char *msg) + { + char *myargv[2]; + int err = 0; +@@ -1166,9 +1164,9 @@ out: + } + + static char * +-findslash (start, p) +- char *start; +- char *p; ++findslash ( ++ char *start, ++ char *p) + { + for (;;) + { +@@ -1229,9 +1227,9 @@ emptydir_name () + * The only nonfatal error this function may return is if the CHDIR fails. + */ + static int +-build_dirs_and_chdir (dirs, sticky) +- struct dir_to_build *dirs; +- int sticky; ++build_dirs_and_chdir ( ++ struct dir_to_build *dirs, ++ int sticky) + { + int retval = 0; + struct dir_to_build *nextdir; +diff --git a/src/classify.c b/src/classify.c +index d8bf399..d5d9249 100644 +--- a/src/classify.c ++++ b/src/classify.c +@@ -21,9 +21,9 @@ static void sticky_ck PROTO ((struct file_info *finfo, int aflag, + + static inline int keywords_may_change PROTO ((int aflag, Vers_TS * vers)); + static inline int +-keywords_may_change (aflag, vers) +- int aflag; +- Vers_TS * vers; ++keywords_may_change ( ++ int aflag, ++ Vers_TS * vers) + { + int retval; + +@@ -65,20 +65,19 @@ keywords_may_change (aflag, vers) + * Classify the state of a file + */ + Ctype +-Classify_File (finfo, tag, date, options, force_tag_match, aflag, versp, +- pipeout) +- struct file_info *finfo; +- char *tag; +- char *date; ++Classify_File ( ++ struct file_info *finfo, ++ char *tag, ++ char *date, + + /* Keyword expansion options. Can be either NULL or "" to + indicate none are specified here. */ +- char *options; ++ char *options, + +- int force_tag_match; +- int aflag; +- Vers_TS **versp; +- int pipeout; ++ int force_tag_match, ++ int aflag, ++ Vers_TS **versp, ++ int pipeout) + { + Vers_TS *vers; + Ctype ret; +@@ -433,10 +432,10 @@ Classify_File (finfo, tag, date, options, force_tag_match, aflag, versp, + } + + static void +-sticky_ck (finfo, aflag, vers) +- struct file_info *finfo; +- int aflag; +- Vers_TS *vers; ++sticky_ck ( ++ struct file_info *finfo, ++ int aflag, ++ Vers_TS *vers) + { + if (aflag || vers->tag || vers->date) + { +diff --git a/src/client.c b/src/client.c +index e87cda9..cfc0e92 100644 +--- a/src/client.c ++++ b/src/client.c +@@ -55,7 +55,7 @@ + # endif + + # ifndef strerror +-extern char *strerror (); ++extern char *strerror (int errnum); + # endif + # endif /* ! SOCK_STRERROR */ + +@@ -156,9 +156,9 @@ List *dirs_sent_to_server = NULL; + static int is_arg_a_parent_or_listed_dir PROTO((Node *, void *)); + + static int +-is_arg_a_parent_or_listed_dir (n, d) +- Node *n; +- void *d; ++is_arg_a_parent_or_listed_dir ( ++ Node *n, ++ void *d) + { + char *directory = n->key; /* name of the dir sent to server */ + char *this_argv_elem = xstrdup (d); /* this argv element */ +@@ -185,8 +185,7 @@ static int arg_should_not_be_sent_to_server PROTO((char *)); + server. */ + + static int +-arg_should_not_be_sent_to_server (arg) +- char *arg; ++arg_should_not_be_sent_to_server (char *arg) + { + /* Decide if we should send this directory name to the server. We + should always send argv[i] if: +@@ -342,10 +341,10 @@ mode_to_string (mode) + * If RESPECT_UMASK is set, then honor the umask. + */ + int +-change_mode (filename, mode_string, respect_umask) +- char *filename; +- char *mode_string; +- int respect_umask; ++change_mode ( ++ char *filename, ++ char *mode_string, ++ int respect_umask) + { + #ifdef CHMOD_BROKEN + char *p; +@@ -494,11 +493,11 @@ static int log_buffer_shutdown PROTO((struct buffer *)); + /* Create a log buffer. */ + + static struct buffer * +-log_buffer_initialize (buf, fp, input, memory) +- struct buffer *buf; +- FILE *fp; +- int input; +- void (*memory) PROTO((struct buffer *)); ++log_buffer_initialize ( ++ struct buffer *buf, ++ FILE *fp, ++ int input, ++ void (*memory) PROTO((struct buffer *))) + { + struct log_buffer *n; + +@@ -517,12 +516,12 @@ log_buffer_initialize (buf, fp, input, memory) + /* The input function for a log buffer. */ + + static int +-log_buffer_input (closure, data, need, size, got) +- void *closure; +- char *data; +- int need; +- int size; +- int *got; ++log_buffer_input ( ++ void *closure, ++ char *data, ++ int need, ++ int size, ++ int *got) + { + struct log_buffer *lb = (struct log_buffer *) closure; + int status; +@@ -548,11 +547,11 @@ log_buffer_input (closure, data, need, size, got) + /* The output function for a log buffer. */ + + static int +-log_buffer_output (closure, data, have, wrote) +- void *closure; +- const char *data; +- int have; +- int *wrote; ++log_buffer_output ( ++ void *closure, ++ const char *data, ++ int have, ++ int *wrote) + { + struct log_buffer *lb = (struct log_buffer *) closure; + int status; +@@ -578,8 +577,7 @@ log_buffer_output (closure, data, have, wrote) + /* The flush function for a log buffer. */ + + static int +-log_buffer_flush (closure) +- void *closure; ++log_buffer_flush (void *closure) + { + struct log_buffer *lb = (struct log_buffer *) closure; + +@@ -598,9 +596,9 @@ log_buffer_flush (closure) + /* The block function for a log buffer. */ + + static int +-log_buffer_block (closure, block) +- void *closure; +- int block; ++log_buffer_block ( ++ void *closure, ++ int block) + { + struct log_buffer *lb = (struct log_buffer *) closure; + +@@ -613,8 +611,7 @@ log_buffer_block (closure, block) + /* The shutdown function for a log buffer. */ + + static int +-log_buffer_shutdown (buf) +- struct buffer *buf; ++log_buffer_shutdown (struct buffer *buf) + { + struct log_buffer *lb = (struct log_buffer *) buf->closure; + int retval; +@@ -667,10 +664,10 @@ static int socket_buffer_shutdown PROTO((struct buffer *)); + /* Create a buffer based on a socket. */ + + static struct buffer * +-socket_buffer_initialize (socket, input, memory) +- int socket; +- int input; +- void (*memory) PROTO((struct buffer *)); ++socket_buffer_initialize ( ++ int socket, ++ int input, ++ void (*memory) PROTO((struct buffer *))) + { + struct socket_buffer *n; + +@@ -690,12 +687,12 @@ socket_buffer_initialize (socket, input, memory) + /* The buffer input function for a buffer built on a socket. */ + + static int +-socket_buffer_input (closure, data, need, size, got) +- void *closure; +- char *data; +- int need; +- int size; +- int *got; ++socket_buffer_input ( ++ void *closure, ++ char *data, ++ int need, ++ int size, ++ int *got) + { + struct socket_buffer *sb = (struct socket_buffer *) closure; + int nbytes; +@@ -751,11 +748,11 @@ socket_buffer_input (closure, data, need, size, got) + /* The buffer output function for a buffer built on a socket. */ + + static int +-socket_buffer_output (closure, data, have, wrote) +- void *closure; +- const char *data; +- int have; +- int *wrote; ++socket_buffer_output ( ++ void *closure, ++ const char *data, ++ int have, ++ int *wrote) + { + struct socket_buffer *sb = (struct socket_buffer *) closure; + +@@ -793,8 +790,7 @@ socket_buffer_output (closure, data, have, wrote) + + /*ARGSUSED*/ + static int +-socket_buffer_flush (closure) +- void *closure; ++socket_buffer_flush (void *closure) + { + /* Nothing to do. Sockets are always flushed. */ + return 0; +@@ -803,8 +799,7 @@ socket_buffer_flush (closure) + + + static int +-socket_buffer_shutdown (buf) +- struct buffer *buf; ++socket_buffer_shutdown (struct buffer *buf) + { + struct socket_buffer *n = (struct socket_buffer *) buf->closure; + char tmp; +@@ -863,8 +858,7 @@ socket_buffer_shutdown (buf) + * Returns number of bytes read. + */ + static int +-read_line (resultp) +- char **resultp; ++read_line (char **resultp) + { + int status; + char *result; +@@ -919,17 +913,17 @@ static char *toplevel_repos = NULL; + char *toplevel_wd; + + static void +-handle_ok (args, len) +- char *args; +- int len; ++handle_ok ( ++ char *args, ++ int len) + { + return; + } + + static void +-handle_error (args, len) +- char *args; +- int len; ++handle_error ( ++ char *args, ++ int len) + { + int something_printed; + +@@ -963,9 +957,9 @@ handle_error (args, len) + } + + static void +-handle_valid_requests (args, len) +- char *args; +- int len; ++handle_valid_requests ( ++ char *args, ++ int len) + { + char *p = args; + char *q; +@@ -1024,9 +1018,9 @@ handle_valid_requests (args, len) + * False Otherwise. + */ + static +-int path_list_prefixed (p, closure) +- Node *p; +- void *closure; ++int path_list_prefixed ( ++ Node *p, ++ void *closure) + { + const char *questionable = closure; + const char *prefix = p->key; +@@ -1054,8 +1048,7 @@ int path_list_prefixed (p, closure) + * False Otherwise. + */ + static +-int is_valid_client_path (pathname) +- const char *pathname; ++int is_valid_client_path (const char *pathname) + { + /* 1. Absolute paths. */ + if (isabsolute (pathname)) return 0; +@@ -1081,11 +1074,11 @@ int is_valid_client_path (pathname) + * the directory portion of SHORT_PATHNAME. */ + + static void +-call_in_directory (pathname, func, data) +- char *pathname; ++call_in_directory ( ++ char *pathname, + void (*func) PROTO((char *data, List *ent_list, char *short_pathname, +- char *filename)); +- char *data; ++ char *filename)), ++ char *data) + { + /* This variable holds the result of Entries_Open. */ + List *last_entries = NULL; +@@ -1426,11 +1419,11 @@ warning: server is not creating directories one at a time"); + } + + static void +-copy_a_file (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++copy_a_file ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + char *newname; + #ifdef USE_VMS_FILENAMES +@@ -1457,9 +1450,9 @@ copy_a_file (data, ent_list, short_pathname, filename) + } + + static void +-handle_copy_file (args, len) +- char *args; +- int len; ++handle_copy_file ( ++ char *args, ++ int len) + { + call_in_directory (args, copy_a_file, (char *)NULL); + } +@@ -1510,9 +1503,9 @@ static void read_counted_file PROTO ((char *, char *)); + extend this to deal with compressed files and make update_entries + use it. On error, gives a fatal error. */ + static void +-read_counted_file (filename, fullname) +- char *filename; +- char *fullname; ++read_counted_file ( ++ char *filename, ++ char *fullname) + { + char *size_string; + size_t size; +@@ -1631,9 +1624,9 @@ static int stored_checksum_valid; + static unsigned char stored_checksum[16]; + + static void +-handle_checksum (args, len) +- char *args; +- int len; ++handle_checksum ( ++ char *args, ++ int len) + { + char *s; + char buf[3]; +@@ -1667,9 +1660,9 @@ static char *stored_mode; + static void handle_mode PROTO ((char *, int)); + + static void +-handle_mode (args, len) +- char *args; +- int len; ++handle_mode ( ++ char *args, ++ int len) + { + if (stored_mode != NULL) + error (1, 0, "protocol error: duplicate Mode"); +@@ -1684,9 +1677,9 @@ static time_t stored_modtime; + static void handle_mod_time PROTO ((char *, int)); + + static void +-handle_mod_time (args, len) +- char *args; +- int len; ++handle_mod_time ( ++ char *args, ++ int len) + { + if (stored_modtime_valid) + error (0, 0, "protocol error: duplicate Mod-time"); +@@ -1749,11 +1742,11 @@ struct update_entries_data + + /* Update the Entries line for this file. */ + static void +-update_entries (data_arg, ent_list, short_pathname, filename) +- char *data_arg; +- List *ent_list; +- char *short_pathname; +- char *filename; ++update_entries ( ++ char *data_arg, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + char *entries_line; + struct update_entries_data *data = (struct update_entries_data *)data_arg; +@@ -2289,9 +2282,9 @@ update_entries (data_arg, ent_list, short_pathname, filename) + } + + static void +-handle_checked_in (args, len) +- char *args; +- int len; ++handle_checked_in ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_CHECKIN; +@@ -2301,9 +2294,9 @@ handle_checked_in (args, len) + } + + static void +-handle_new_entry (args, len) +- char *args; +- int len; ++handle_new_entry ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_CHECKIN; +@@ -2313,9 +2306,9 @@ handle_new_entry (args, len) + } + + static void +-handle_updated (args, len) +- char *args; +- int len; ++handle_updated ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_UPDATE; +@@ -2327,9 +2320,9 @@ handle_updated (args, len) + static void handle_created PROTO((char *, int)); + + static void +-handle_created (args, len) +- char *args; +- int len; ++handle_created ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_UPDATE; +@@ -2341,9 +2334,9 @@ handle_created (args, len) + static void handle_update_existing PROTO((char *, int)); + + static void +-handle_update_existing (args, len) +- char *args; +- int len; ++handle_update_existing ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_UPDATE; +@@ -2353,9 +2346,9 @@ handle_update_existing (args, len) + } + + static void +-handle_merged (args, len) +- char *args; +- int len; ++handle_merged ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_UPDATE; +@@ -2366,9 +2359,9 @@ handle_merged (args, len) + } + + static void +-handle_patched (args, len) +- char *args; +- int len; ++handle_patched ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_PATCH; +@@ -2379,9 +2372,9 @@ handle_patched (args, len) + } + + static void +-handle_rcs_diff (args, len) +- char *args; +- int len; ++handle_rcs_diff ( ++ char *args, ++ int len) + { + struct update_entries_data dat; + dat.contents = UPDATE_ENTRIES_RCS_DIFF; +@@ -2392,29 +2385,29 @@ handle_rcs_diff (args, len) + } + + static void +-remove_entry (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++remove_entry ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + Scratch_Entry (ent_list, filename); + } + + static void +-handle_remove_entry (args, len) +- char *args; +- int len; ++handle_remove_entry ( ++ char *args, ++ int len) + { + call_in_directory (args, remove_entry, (char *)NULL); + } + + static void +-remove_entry_and_file (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++remove_entry_and_file ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + Scratch_Entry (ent_list, filename); + /* Note that we don't ignore existence_error's here. The server +@@ -2427,17 +2420,16 @@ remove_entry_and_file (data, ent_list, short_pathname, filename) + } + + static void +-handle_removed (args, len) +- char *args; +- int len; ++handle_removed ( ++ char *args, ++ int len) + { + call_in_directory (args, remove_entry_and_file, (char *)NULL); + } + + /* Is this the top level (directory containing CVSROOT)? */ + static int +-is_cvsroot_level (pathname) +- char *pathname; ++is_cvsroot_level (char *pathname) + { + if (strcmp (toplevel_repos, current_parsed_root->directory) != 0) + return 0; +@@ -2446,11 +2438,11 @@ is_cvsroot_level (pathname) + } + + static void +-set_static (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++set_static ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + FILE *fp; + fp = open_file (CVSADM_ENTSTAT, "w+"); +@@ -2459,9 +2451,9 @@ set_static (data, ent_list, short_pathname, filename) + } + + static void +-handle_set_static_directory (args, len) +- char *args; +- int len; ++handle_set_static_directory ( ++ char *args, ++ int len) + { + if (strcmp (cvs_cmd_name, "export") == 0) + { +@@ -2473,20 +2465,20 @@ handle_set_static_directory (args, len) + } + + static void +-clear_static (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++clear_static ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + if (unlink_file (CVSADM_ENTSTAT) < 0 && ! existence_error (errno)) + error (1, errno, "cannot remove file %s", CVSADM_ENTSTAT); + } + + static void +-handle_clear_static_directory (pathname, len) +- char *pathname; +- int len; ++handle_clear_static_directory ( ++ char *pathname, ++ int len) + { + if (strcmp (cvs_cmd_name, "export") == 0) + { +@@ -2507,11 +2499,11 @@ handle_clear_static_directory (pathname, len) + } + + static void +-set_sticky (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++set_sticky ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + char *tagspec; + FILE *f; +@@ -2540,9 +2532,9 @@ set_sticky (data, ent_list, short_pathname, filename) + } + + static void +-handle_set_sticky (pathname, len) +- char *pathname; +- int len; ++handle_set_sticky ( ++ char *pathname, ++ int len) + { + if (strcmp (cvs_cmd_name, "export") == 0) + { +@@ -2570,20 +2562,20 @@ handle_set_sticky (pathname, len) + } + + static void +-clear_sticky (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++clear_sticky ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + if (unlink_file (CVSADM_TAG) < 0 && ! existence_error (errno)) + error (1, errno, "cannot remove %s", CVSADM_TAG); + } + + static void +-handle_clear_sticky (pathname, len) +- char *pathname; +- int len; ++handle_clear_sticky ( ++ char *pathname, ++ int len) + { + if (strcmp (cvs_cmd_name, "export") == 0) + { +@@ -2608,11 +2600,11 @@ handle_clear_sticky (pathname, len) + static void template PROTO ((char *, List *, char *, char *)); + + static void +-template (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++template ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + char *buf = xmalloc ( strlen ( short_pathname ) + + strlen ( CVSADM_TEMPLATE ) +@@ -2625,9 +2617,9 @@ template (data, ent_list, short_pathname, filename) + static void handle_template PROTO ((char *, int)); + + static void +-handle_template (pathname, len) +- char *pathname; +- int len; ++handle_template ( ++ char *pathname, ++ int len) + { + call_in_directory (pathname, template, NULL); + } +@@ -2642,8 +2634,7 @@ struct save_dir { + struct save_dir *prune_candidates; + + static void +-add_prune_candidate (dir) +- const char *dir; ++add_prune_candidate (const char *dir) + { + struct save_dir *p; + +@@ -2703,10 +2694,10 @@ static char *last_update_dir; + static void send_repository PROTO((const char *, const char *, const char *)); + + static void +-send_repository (dir, repos, update_dir) +- const char *dir; +- const char *repos; +- const char *update_dir; ++send_repository ( ++ const char *dir, ++ const char *repos, ++ const char *update_dir) + { + char *adm_name; + +@@ -2851,10 +2842,10 @@ send_repository (dir, repos, update_dir) + /* Send a Repository line and set toplevel_repos. */ + + void +-send_a_repository (dir, repository, update_dir_in) +- const char *dir; +- const char *repository; +- const char *update_dir_in; ++send_a_repository ( ++ const char *dir, ++ const char *repository, ++ const char *update_dir_in) + { + char *update_dir; + +@@ -2957,9 +2948,9 @@ static int modules_allocated; + static char **modules_vector; + + static void +-handle_module_expansion (args, len) +- char *args; +- int len; ++handle_module_expansion ( ++ char *args, ++ int len) + { + if (modules_vector == NULL) + { +@@ -2984,10 +2975,10 @@ static int module_argc; + static char **module_argv; + + void +-client_expand_modules (argc, argv, local) +- int argc; +- char **argv; +- int local; ++client_expand_modules ( ++ int argc, ++ char **argv, ++ int local) + { + int errs; + int i; +@@ -3016,10 +3007,10 @@ client_expand_modules (argc, argv, local) + } + + void +-client_send_expansions (local, where, build_dirs) +- int local; +- char *where; +- int build_dirs; ++client_send_expansions ( ++ int local, ++ char *where, ++ int build_dirs) + { + int i; + char *argv[1]; +@@ -3058,9 +3049,9 @@ client_nonexpanded_setup () + read the file in text or binary mode. */ + + static void +-handle_wrapper_rcs_option (args, len) +- char *args; +- int len; ++handle_wrapper_rcs_option ( ++ char *args, ++ int len) + { + char *p; + +@@ -3086,9 +3077,9 @@ handle_wrapper_rcs_option (args, len) + + + static void +-handle_m (args, len) +- char *args; +- int len; ++handle_m ( ++ char *args, ++ int len) + { + /* In the case where stdout and stderr point to the same place, + fflushing stderr will make output happen in the correct order. +@@ -3104,9 +3095,9 @@ handle_m (args, len) + static void handle_mbinary PROTO ((char *, int)); + + static void +-handle_mbinary (args, len) +- char *args; +- int len; ++handle_mbinary ( ++ char *args, ++ int len) + { + char *size_string; + size_t size; +@@ -3140,9 +3131,9 @@ handle_mbinary (args, len) + } + + static void +-handle_e (args, len) +- char *args; +- int len; ++handle_e ( ++ char *args, ++ int len) + { + /* In the case where stdout and stderr point to the same place, + fflushing stdout will make output happen in the correct order. */ +@@ -3153,9 +3144,9 @@ handle_e (args, len) + + /*ARGSUSED*/ + static void +-handle_f (args, len) +- char *args; +- int len; ++handle_f ( ++ char *args, ++ int len) + { + fflush (stderr); + } +@@ -3163,9 +3154,9 @@ handle_f (args, len) + static void handle_mt PROTO ((char *, int)); + + static void +-handle_mt (args, len) +- char *args; +- int len; ++handle_mt ( ++ char *args, ++ int len) + { + char *p; + char *tag = args; +@@ -3359,9 +3350,9 @@ struct response responses[] = + * contain 0's. + */ + void +-send_to_server (str, len) +- const char *str; +- size_t len; ++send_to_server ( ++ const char *str, ++ size_t len) + { + static int nbytes; + +@@ -3389,9 +3380,9 @@ send_to_server (str, len) + bytes read, which will always be at least one; blocks if there is + no data available at all. Gives a fatal error on EOF or error. */ + static size_t +-try_read_from_server (buf, len) +- char *buf; +- size_t len; ++try_read_from_server ( ++ char *buf, ++ size_t len) + { + int status, nread; + char *data; +@@ -3417,9 +3408,9 @@ try_read_from_server (buf, len) + * Read LEN bytes from the server or die trying. + */ + void +-read_from_server (buf, len) +- char *buf; +- size_t len; ++read_from_server ( ++ char *buf, ++ size_t len) + { + size_t red = 0; + while (red < len) +@@ -3567,8 +3558,7 @@ static void start_rsh_server PROTO((cvsroot_t *, struct buffer **, struct buffer + #endif + + int +-supported_request (name) +- char *name; ++supported_request (char *name) + { + struct request *rq; + +@@ -3594,10 +3584,10 @@ supported_request (name) + * defaultport + */ + static int +-get_port_number (envname, portname, defaultport) +- const char *envname; +- const char *portname; +- int defaultport; ++get_port_number ( ++ const char *envname, ++ const char *portname, ++ int defaultport) + { + struct servent *s; + char *port_s; +@@ -3642,8 +3632,7 @@ get_port_number (envname, portname, defaultport) + * will need to do it to save the canonical CVSROOT. -DRP + */ + int +-get_cvs_port_number (root) +- const cvsroot_t *root; ++get_cvs_port_number (const cvsroot_t *root) + { + + if (root->port) return root->port; +@@ -3675,13 +3664,13 @@ get_cvs_port_number (root) + + + void +-make_bufs_from_fds (tofd, fromfd, child_pid, to_server, from_server, is_sock) +- int tofd; +- int fromfd; +- int child_pid; +- struct buffer **to_server; +- struct buffer **from_server; +- int is_sock; ++make_bufs_from_fds ( ++ int tofd, ++ int fromfd, ++ int child_pid, ++ struct buffer **to_server, ++ struct buffer **from_server, ++ int is_sock) + { + FILE *to_server_fp; + FILE *from_server_fp; +@@ -3749,12 +3738,12 @@ make_bufs_from_fds (tofd, fromfd, child_pid, to_server, from_server, is_sock) + If we fail to connect or if access is denied, then die with fatal + error. */ + void +-connect_to_pserver (root, to_server_p, from_server_p, verify_only, do_gssapi) +- cvsroot_t *root; +- struct buffer **to_server_p; +- struct buffer **from_server_p; +- int verify_only; +- int do_gssapi; ++connect_to_pserver ( ++ cvsroot_t *root, ++ struct buffer **to_server_p, ++ struct buffer **from_server_p, ++ int verify_only, ++ int do_gssapi) + { + int sock; + int port_number; +@@ -3862,9 +3851,9 @@ connect_to_pserver (root, to_server_p, from_server_p, verify_only, do_gssapi) + + + static void +-proxy_connect (root, port_number) +- cvsroot_t *root; +- int port_number; ++proxy_connect ( ++ cvsroot_t *root, ++ int port_number) + { + #define CONNECT_STRING "CONNECT %s:%d HTTP/1.0\r\n\r\n" + /* Send a "CONNECT" command to proxy: */ +@@ -3902,13 +3891,13 @@ proxy_connect (root, port_number) + + + static void +-auth_server (root, lto_server, lfrom_server, verify_only, do_gssapi, hostname) +- cvsroot_t *root; +- struct buffer *lto_server; +- struct buffer *lfrom_server; +- int verify_only; +- int do_gssapi; +- char *hostname; ++auth_server ( ++ cvsroot_t *root, ++ struct buffer *lto_server, ++ struct buffer *lfrom_server, ++ int verify_only, ++ int do_gssapi, ++ char *hostname) + { + char *username = ""; /* the username we use to connect */ + char no_passwd = 0; /* gets set if no password found */ +@@ -4086,9 +4075,9 @@ auth_server (root, lto_server, lfrom_server, verify_only, do_gssapi, hostname) + * Connect to a forked server process. + */ + void +-connect_to_forked_server (to_server, from_server) +- struct buffer **to_server; +- struct buffer **from_server; ++connect_to_forked_server ( ++ struct buffer **to_server, ++ struct buffer **from_server) + { + int tofd, fromfd; + int child_pid; +@@ -4127,10 +4116,10 @@ connect_to_forked_server (to_server, from_server) + on such a system (OS/2, Windows 95, and maybe others) will have to + take care of this. */ + void +-start_tcp_server (root, to_server, from_server) +- cvsroot_t *root; +- struct buffer **to_server; +- struct buffer **from_server; ++start_tcp_server ( ++ cvsroot_t *root, ++ struct buffer **to_server, ++ struct buffer **from_server) + { + int s; + const char *portenv; +@@ -4242,10 +4231,10 @@ start_tcp_server (root, to_server, from_server) + /* Receive a given number of bytes. */ + + static void +-recv_bytes (sock, buf, need) +- int sock; +- char *buf; +- int need; ++recv_bytes ( ++ int sock, ++ char *buf, ++ int need) + { + while (need > 0) + { +@@ -4279,10 +4268,10 @@ recv_bytes (sock, buf, need) + */ + #define BUFSIZE 1024 + static int +-connect_to_gserver (root, sock, hostname) +- cvsroot_t *root; +- int sock; +- char *hostname; ++connect_to_gserver ( ++ cvsroot_t *root, ++ int sock, ++ char *hostname) + { + char *str; + char buf[BUFSIZE]; +@@ -4400,9 +4389,9 @@ connect_to_gserver (root, sock, hostname) + static int send_variable_proc PROTO ((Node *, void *)); + + static int +-send_variable_proc (node, closure) +- Node *node; +- void *closure; ++send_variable_proc ( ++ Node *node, ++ void *closure) + { + send_to_server ("Set ", 0); + send_to_server (node->key, 0); +@@ -4823,10 +4812,10 @@ start_server () + up and running, and that's most important. */ + + static void +-start_rsh_server (root, to_server, from_server) +- cvsroot_t *root; +- struct buffer **to_server; +- struct buffer **from_server; ++start_rsh_server ( ++ cvsroot_t *root, ++ struct buffer **to_server, ++ struct buffer **from_server) + { + int pipes[2]; + int child_pid; +@@ -4896,10 +4885,10 @@ start_rsh_server (root, to_server, from_server) + # else /* ! START_RSH_WITH_POPEN_RW */ + + static void +-start_rsh_server (root, to_server, from_server) +- cvsroot_t *root; +- struct buffer **to_server; +- struct buffer **from_server; ++start_rsh_server ( ++ cvsroot_t *root, ++ struct buffer **to_server, ++ struct buffer **from_server) + { + /* If you're working through firewalls, you can set the + CVS_RSH environment variable to a script which uses rsh to +@@ -4980,8 +4969,7 @@ start_rsh_server (root, to_server, from_server) + + /* Send an argument STRING. */ + void +-send_arg (string) +- const char *string; ++send_arg (const char *string) + { + char buf[1]; + const char *p = string; +@@ -5013,10 +5001,10 @@ static void send_modified PROTO ((const char *, const char *, Vers_TS *)); + client_process_import_file to set them up. */ + + static void +-send_modified (file, short_pathname, vers) +- const char *file; +- const char *short_pathname; +- Vers_TS *vers; ++send_modified ( ++ const char *file, ++ const char *short_pathname, ++ Vers_TS *vers) + { + /* File was modified, send it. */ + struct stat sb; +@@ -5172,9 +5160,9 @@ static int send_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + + /* Deal with one file. */ + static int +-send_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++send_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + struct send_data *args = (struct send_data *) callerdat; + Vers_TS *vers; +@@ -5330,9 +5318,9 @@ warning: ignoring -k options due to server limitations"); + static void send_ignproc PROTO ((const char *, const char *)); + + static void +-send_ignproc (file, dir) +- const char *file; +- const char *dir; ++send_ignproc ( ++ const char *file, ++ const char *dir) + { + if (ign_inhibit_server || !supported_request ("Questionable")) + { +@@ -5355,12 +5343,12 @@ static int send_filesdoneproc PROTO ((void *, int, const char *, const char *, + List *)); + + static int +-send_filesdoneproc (callerdat, err, repository, update_dir, entries) +- void *callerdat; +- int err; +- const char *repository; +- const char *update_dir; +- List *entries; ++send_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + /* if this directory has an ignore list, process it then free it */ + if (ignlist) +@@ -5384,12 +5372,12 @@ static Dtype send_dirent_proc PROTO ((void *, const char *, const char *, + * + */ + static Dtype +-send_dirent_proc (callerdat, dir, repository, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repository; +- const char *update_dir; +- List *entries; ++send_dirent_proc ( ++ void *callerdat, ++ const char *dir, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + struct send_data *args = (struct send_data *) callerdat; + int dir_exists; +@@ -5470,12 +5458,12 @@ static int send_dirleave_proc PROTO ((void *, const char *, int, const char *, + */ + /* ARGSUSED */ + static int +-send_dirleave_proc (callerdat, dir, err, update_dir, entries) +- void *callerdat; +- const char *dir; +- int err; +- const char *update_dir; +- List *entries; ++send_dirleave_proc ( ++ void *callerdat, ++ const char *dir, ++ int err, ++ const char *update_dir, ++ List *entries) + { + + /* Delete the ignore list if it hasn't already been done. */ +@@ -5500,10 +5488,10 @@ send_options (int argc, char *const *argv) + + /* Send the names of all the argument files to the server. */ + void +-send_file_names (argc, argv, flags) +- int argc; +- char **argv; +- unsigned int flags; ++send_file_names ( ++ int argc, ++ char **argv, ++ unsigned int flags) + { + int i; + +@@ -5657,9 +5645,9 @@ send_file_names (argc, argv, flags) + + /* Calculate and send max-dotdot to the server */ + static void +-send_max_dotdot (argc, argv) +- int argc; +- char **argv; ++send_max_dotdot ( ++ int argc, ++ char **argv) + { + int i; + int level = 0; +@@ -5709,12 +5697,12 @@ send_max_dotdot (argc, argv) + _whether_ a file is modified, not the contents. Also sends Argument + lines for argc and argv, so should be called after options are sent. */ + void +-send_files (argc, argv, local, aflag, flags) +- int argc; +- char **argv; +- int local; +- int aflag; +- unsigned int flags; ++send_files ( ++ int argc, ++ char **argv, ++ int local, ++ int aflag, ++ unsigned int flags) + { + struct send_data args; + int err; +@@ -5750,8 +5738,7 @@ send_files (argc, argv, local, aflag, flags) + } + + void +-client_import_setup (repository) +- char *repository; ++client_import_setup (char *repository) + { + if (toplevel_repos == NULL) /* should always be true */ + send_a_repository ("", repository, ""); +@@ -5761,18 +5748,17 @@ client_import_setup (repository) + * Process the argument import file. + */ + int +-client_process_import_file (message, vfile, vtag, targc, targv, repository, +- all_files_binary, modtime) +- char *message; +- char *vfile; +- char *vtag; +- int targc; +- char *targv[]; +- char *repository; +- int all_files_binary; ++client_process_import_file ( ++ char *message, ++ char *vfile, ++ char *vtag, ++ int targc, ++ char *targv[], ++ char *repository, ++ int all_files_binary, + + /* Nonzero for "import -d". */ +- int modtime; ++ int modtime) + { + char *update_dir; + char *fullname; +@@ -5871,11 +5857,11 @@ client_import_done () + + + static void +-notified_a_file (data, ent_list, short_pathname, filename) +- char *data; +- List *ent_list; +- char *short_pathname; +- char *filename; ++notified_a_file ( ++ char *data, ++ List *ent_list, ++ char *short_pathname, ++ char *filename) + { + FILE *fp; + FILE *newf; +@@ -5979,20 +5965,20 @@ notified_a_file (data, ent_list, short_pathname, filename) + } + + static void +-handle_notified (args, len) +- char *args; +- int len; ++handle_notified ( ++ char *args, ++ int len) + { + call_in_directory (args, notified_a_file, NULL); + } + + void +-client_notify (repository, update_dir, filename, notif_type, val) +- const char *repository; +- const char *update_dir; +- const char *filename; +- int notif_type; +- const char *val; ++client_notify ( ++ const char *repository, ++ const char *update_dir, ++ const char *filename, ++ int notif_type, ++ const char *val) + { + char buf[2]; + +@@ -6012,9 +5998,9 @@ client_notify (repository, update_dir, filename, notif_type, val) + * the argument. If ARG is NULL, forget the whole thing. + */ + void +-option_with_arg (option, arg) +- char *option; +- char *arg; ++option_with_arg ( ++ char *option, ++ char *arg) + { + if (arg == NULL) + return; +@@ -6034,8 +6020,7 @@ option_with_arg (option, arg) + cvsclient.texi, RFC 822/1123 format is preferred. */ + + void +-client_senddate (date) +- const char *date; ++client_senddate (const char *date) + { + char buf[MAXDATELEN]; + +diff --git a/src/client.h b/src/client.h +index 5a05d09..2f1abb9 100644 +--- a/src/client.h ++++ b/src/client.h +@@ -55,8 +55,14 @@ extern int cvs_gssapi_encrypt; + # ifdef HAVE_GSSAPI + + /* We can't declare the arguments without including gssapi.h, and I +- don't want to do that in every file. */ +-extern struct buffer *cvs_gssapi_wrap_buffer_initialize (); ++ don't want to do that in every file. But we need it the arguments for ++ ISO C23. */ ++#include "xgssapi.h" ++extern struct buffer *cvs_gssapi_wrap_buffer_initialize ( ++ struct buffer *buf, ++ int input, ++ gss_ctx_id_t gcontext, ++ void (*memory) PROTO((struct buffer *))); + + # endif /* HAVE_GSSAPI */ + +diff --git a/src/commit.c b/src/commit.c +index 7d168c3..d895315 100644 +--- a/src/commit.c ++++ b/src/commit.c +@@ -146,12 +146,12 @@ static Dtype find_dirent_proc PROTO ((void *callerdat, const char *dir, + List *entries)); + + static Dtype +-find_dirent_proc (callerdat, dir, repository, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repository; +- const char *update_dir; +- List *entries; ++find_dirent_proc ( ++ void *callerdat, ++ const char *dir, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + struct find_data *find_data = (struct find_data *)callerdat; + +@@ -185,9 +185,9 @@ static struct find_data *find_data_static; + static void find_ignproc PROTO ((const char *, const char *)); + + static void +-find_ignproc (file, dir) +- const char *file; +- const char *dir; ++find_ignproc ( ++ const char *file, ++ const char *dir) + { + struct question *p; + +@@ -207,12 +207,12 @@ static int find_filesdoneproc PROTO ((void *callerdat, int err, + List *entries)); + + static int +-find_filesdoneproc (callerdat, err, repository, update_dir, entries) +- void *callerdat; +- int err; +- const char *repository; +- const char *update_dir; +- List *entries; ++find_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + struct find_data *find_data = (struct find_data *)callerdat; + find_data->repository = repository; +@@ -239,9 +239,9 @@ static int find_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + merging it with classify_file is almost sure to be a mess, though, + because classify_file has all kinds of repository processing. */ + static int +-find_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++find_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + Vers_TS *vers; + enum classify_type status; +@@ -353,9 +353,9 @@ find_fileproc (callerdat, finfo) + static int copy_ulist PROTO ((Node *, void *)); + + static int +-copy_ulist (node, data) +- Node *node; +- void *data; ++copy_ulist ( ++ Node *node, ++ void *data) + { + struct find_data *args = (struct find_data *)data; + args->argv[args->argc++] = node->key; +@@ -369,9 +369,9 @@ copy_ulist (node, data) + # define COMMIT_OPTIONS "+lRm:fF:r:" + #endif /* SERVER_SUPPORT */ + int +-commit (argc, argv) +- int argc; +- char **argv; ++commit ( ++ int argc, ++ char **argv) + { + int c; + int err = 0; +@@ -734,9 +734,9 @@ commit (argc, argv) + + static + Ctype +-classify_file_internal (finfo, vers) +- struct file_info *finfo; +- Vers_TS **vers; ++classify_file_internal ( ++ struct file_info *finfo, ++ Vers_TS **vers) + { + int save_noexec, save_quiet, save_really_quiet; + Ctype status; +@@ -824,9 +824,9 @@ classify_file_internal (finfo, vers) + */ + /* ARGSUSED */ + static int +-check_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++check_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + Ctype status; + const char *xdir; +@@ -1108,12 +1108,12 @@ warning: file `%s' seems to still contain conflict indicators", + */ + /* ARGSUSED */ + static Dtype +-check_direntproc (callerdat, dir, repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repos; +- const char *update_dir; +- List *entries; ++check_direntproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + if (!isdir (dir)) + return R_SKIP_ALL; +@@ -1130,9 +1130,9 @@ check_direntproc (callerdat, dir, repos, update_dir, entries) + * Walklist proc to run pre-commit checks + */ + static int +-precommit_list_proc (p, closure) +- Node *p; +- void *closure; ++precommit_list_proc ( ++ Node *p, ++ void *closure) + { + struct logfile_info *li = p->data; + if (li->type == T_ADDED +@@ -1150,9 +1150,9 @@ precommit_list_proc (p, closure) + * Callback proc for pre-commit checking + */ + static int +-precommit_proc (repository, filter) +- const char *repository; +- const char *filter; ++precommit_proc ( ++ const char *repository, ++ const char *filter) + { + /* see if the filter is there, only if it's a full path */ + if (isabsolute (filter)) +@@ -1188,12 +1188,12 @@ precommit_proc (repository, filter) + */ + /* ARGSUSED */ + static int +-check_filesdoneproc (callerdat, err, repos, update_dir, entries) +- void *callerdat; +- int err; +- const char *repos; +- const char *update_dir; +- List *entries; ++check_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + int n; + Node *p; +@@ -1229,9 +1229,9 @@ static char *sbranch; + + /* ARGSUSED */ + static int +-commit_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++commit_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + Node *p; + int err = 0; +@@ -1451,12 +1451,12 @@ out: + */ + /* ARGSUSED */ + static int +-commit_filesdoneproc (callerdat, err, repository, update_dir, entries) +- void *callerdat; +- int err; +- const char *repository; +- const char *update_dir; +- List *entries; ++commit_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + Node *p; + List *ulist; +@@ -1525,12 +1525,12 @@ commit_filesdoneproc (callerdat, err, repository, update_dir, entries) + */ + /* ARGSUSED */ + static Dtype +-commit_direntproc (callerdat, dir, repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repos; +- const char *update_dir; +- List *entries; ++commit_direntproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + Node *p; + List *ulist; +@@ -1567,12 +1567,12 @@ commit_direntproc (callerdat, dir, repos, update_dir, entries) + */ + /* ARGSUSED */ + static int +-commit_dirleaveproc (callerdat, dir, err, update_dir, entries) +- void *callerdat; +- const char *dir; +- int err; +- const char *update_dir; +- List *entries; ++commit_dirleaveproc ( ++ void *callerdat, ++ const char *dir, ++ int err, ++ const char *update_dir, ++ List *entries) + { + /* update the per-directory tag info */ + /* FIXME? Why? The "commit examples" node of cvs.texinfo briefly +@@ -1595,9 +1595,9 @@ commit_dirleaveproc (callerdat, dir, err, update_dir, entries) + * find the maximum major rev number in an entries file + */ + static int +-findmaxrev (p, closure) +- Node *p; +- void *closure; ++findmaxrev ( ++ Node *p, ++ void *closure) + { + int thisrev; + Entnode *entdata = p->data; +@@ -1619,10 +1619,10 @@ findmaxrev (p, closure) + Return value is 0 on success, or >0 on error (in which case we have + printed an error message). */ + static int +-remove_file (finfo, tag, message) +- struct file_info *finfo; +- char *tag; +- char *message; ++remove_file ( ++ struct file_info *finfo, ++ char *tag, ++ char *message) + { + int retcode; + +@@ -1782,11 +1782,11 @@ remove_file (finfo, tag, message) + * Do the actual checkin for added files + */ + static int +-finaladd (finfo, rev, tag, options) +- struct file_info *finfo; +- char *rev; +- char *tag; +- char *options; ++finaladd ( ++ struct file_info *finfo, ++ char *rev, ++ char *tag, ++ char *options) + { + int ret; + +@@ -1815,8 +1815,7 @@ finaladd (finfo, rev, tag, options) + * Unlock an rcs file + */ + static void +-unlockrcs (rcs) +- RCSNode *rcs; ++unlockrcs (RCSNode *rcs) + { + int retcode; + +@@ -1837,8 +1836,7 @@ unlockrcs (rcs) + * to be removed without reparsing the file as we do below. + */ + static void +-fixaddfile (rcs) +- const char *rcs; ++fixaddfile (const char *rcs) + { + RCSNode *rcsfile; + int save_really_quiet; +@@ -1861,9 +1859,9 @@ fixaddfile (rcs) + * put the branch back on an rcs file + */ + static void +-fixbranch (rcs, branch) +- RCSNode *rcs; +- char *branch; ++fixbranch ( ++ RCSNode *rcs, ++ char *branch) + { + int retcode; + +@@ -1907,12 +1905,12 @@ fixbranch (rcs, branch) + */ + + static int +-checkaddfile (file, repository, tag, options, rcsnode) +- const char *file; +- const char *repository; +- const char *tag; +- const char *options; +- RCSNode **rcsnode; ++checkaddfile ( ++ const char *file, ++ const char *repository, ++ const char *tag, ++ const char *options, ++ RCSNode **rcsnode) + { + RCSNode *rcs; + char *fname; +@@ -2303,11 +2301,11 @@ checkaddfile (file, repository, tag, options, rcsnode) + * put the branch back as the head if there are any errors. + */ + static int +-lock_RCS (user, rcs, rev, repository) +- const char *user; +- RCSNode *rcs; +- const char *rev; +- const char *repository; ++lock_RCS ( ++ const char *user, ++ RCSNode *rcs, ++ const char *rev, ++ const char *repository) + { + char *branch = NULL; + int err = 0; +@@ -2385,8 +2383,7 @@ lock_RCS (user, rcs, rev, repository) + * free an UPDATE node's data + */ + void +-update_delproc (p) +- Node *p; ++update_delproc (Node *p) + { + struct logfile_info *li = p->data; + +@@ -2403,8 +2400,7 @@ update_delproc (p) + * Free the commit_info structure in p. + */ + static void +-ci_delproc (p) +- Node *p; ++ci_delproc (Node *p) + { + struct commit_info *ci = p->data; + +@@ -2421,8 +2417,7 @@ ci_delproc (p) + * Free the commit_info structure in p. + */ + static void +-masterlist_delproc (p) +- Node *p; ++masterlist_delproc (Node *p) + { + struct master_lists *ml = p->data; + +diff --git a/src/create_adm.c b/src/create_adm.c +index d6aa45a..0d79906 100644 +--- a/src/create_adm.c ++++ b/src/create_adm.c +@@ -27,16 +27,15 @@ + don't print warnings; all errors are fatal then. */ + + int +-Create_Admin (dir, update_dir, repository, tag, date, nonbranch, warn, +- dotemplate) +- const char *dir; +- const char *update_dir; +- const char *repository; +- const char *tag; +- const char *date; +- int nonbranch; +- int warn; +- int dotemplate; ++Create_Admin ( ++ const char *dir, ++ const char *update_dir, ++ const char *repository, ++ const char *tag, ++ const char *date, ++ int nonbranch, ++ int warn, ++ int dotemplate) + { + FILE *fout; + char *cp; +diff --git a/src/cvs.h b/src/cvs.h +index cd6ffc9..1e05799 100644 +--- a/src/cvs.h ++++ b/src/cvs.h +@@ -69,7 +69,7 @@ extern char *getenv(); + #ifdef SERVER_SUPPORT + /* If the system doesn't provide strerror, it won't be declared in + string.h. */ +-char *strerror (); ++char *strerror (int errnum); + #endif + + #ifdef HAVE_FNMATCH +@@ -484,7 +484,7 @@ int Parse_Info PROTO((const char *infofile, const char *repository, + CALLPROC callproc, int all)); + extern int parse_config PROTO ((char *)); + +-typedef RETSIGTYPE (*SIGCLEANUPPROC) PROTO(()); ++typedef RETSIGTYPE (*SIGCLEANUPPROC) PROTO((int sig)); + int SIG_register PROTO((int sig, SIGCLEANUPPROC sigcleanup)); + int SIG_deregister PROTO((int sig, SIGCLEANUPPROC sigcleanup)); + int isdir PROTO((const char *file)); +diff --git a/src/cvsrc.c b/src/cvsrc.c +index 0941eba..07a8e77 100644 +--- a/src/cvsrc.c ++++ b/src/cvsrc.c +@@ -30,10 +30,10 @@ char cvsrc[] = CVSRC_FILENAME; + options, and update *ARGC and *ARGV accordingly. */ + + void +-read_cvsrc (argc, argv, cmdname) +- int *argc; +- char ***argv; +- const char *cmdname; ++read_cvsrc ( ++ int *argc, ++ char ***argv, ++ const char *cmdname) + { + char *homedir; + char *homeinit; +diff --git a/src/diff.c b/src/diff.c +index e362753..6f2f78d 100644 +--- a/src/diff.c ++++ b/src/diff.c +@@ -292,9 +292,9 @@ add_diff_args (char opt, const char *longopt, const char *argument) + a larger issue than the changes included here. */ + + int +-diff (argc, argv) +- int argc; +- char **argv; ++diff ( ++ int argc, ++ char **argv) + { + int c, err = 0; + int local = 0; +@@ -487,9 +487,9 @@ diff (argc, argv) + */ + /* ARGSUSED */ + static int +-diff_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++diff_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + int status, err = 2; /* 2 == trouble, like rcsdiff */ + Vers_TS *vers; +@@ -835,8 +835,7 @@ out: + * Remember the exit status for each file. + */ + static void +-diff_mark_errors (err) +- int err; ++diff_mark_errors (int err) + { + if (err > diff_errors) + diff_errors = err; +@@ -849,12 +848,12 @@ diff_mark_errors (err) + */ + /* ARGSUSED */ + static Dtype +-diff_dirproc (callerdat, dir, pos_repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *pos_repos; +- const char *update_dir; +- List *entries; ++diff_dirproc ( ++ void *callerdat, ++ const char *dir, ++ const char *pos_repos, ++ const char *update_dir, ++ List *entries) + { + /* XXX - check for dirs we don't want to process??? */ + +@@ -872,12 +871,12 @@ diff_dirproc (callerdat, dir, pos_repos, update_dir, entries) + */ + /* ARGSUSED */ + static int +-diff_filesdoneproc (callerdat, err, repos, update_dir, entries) +- void *callerdat; +- int err; +- const char *repos; +- const char *update_dir; +- List *entries; ++diff_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + return (diff_errors); + } +@@ -887,12 +886,12 @@ diff_filesdoneproc (callerdat, err, repos, update_dir, entries) + */ + /* ARGSUSED */ + static int +-diff_dirleaveproc (callerdat, dir, err, update_dir, entries) +- void *callerdat; +- const char *dir; +- int err; +- const char *update_dir; +- List *entries; ++diff_dirleaveproc ( ++ void *callerdat, ++ const char *dir, ++ int err, ++ const char *update_dir, ++ List *entries) + { + return (diff_errors); + } +@@ -901,11 +900,11 @@ diff_dirleaveproc (callerdat, dir, err, update_dir, entries) + * verify that a file is different + */ + static enum diff_file +-diff_file_nodiff( finfo, vers, empty_file, rev1_cache ) +- struct file_info *finfo; +- Vers_TS *vers; +- enum diff_file empty_file; +- char **rev1_cache; /* Cache the content of rev1 if we have to look ++diff_file_nodiff( ++ struct file_info *finfo, ++ Vers_TS *vers, ++ enum diff_file empty_file, ++ char **rev1_cache) /* Cache the content of rev1 if we have to look + * it up. + */ + { +diff --git a/src/edit.c b/src/edit.c +index d3e2894..b2c2f5b 100644 +--- a/src/edit.c ++++ b/src/edit.c +@@ -28,9 +28,9 @@ static int setting_tcommit; + static int onoff_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + + static int +-onoff_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++onoff_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + char *watched = fileattr_get0 (finfo->file, "_watched"); + fileattr_set (finfo->file, "_watched", turning_on ? "" : NULL); +@@ -45,12 +45,12 @@ static int onoff_filesdoneproc PROTO ((void *, int, const char *, const char *, + List *)); + + static int +-onoff_filesdoneproc (callerdat, err, repository, update_dir, entries) +- void *callerdat; +- int err; +- const char *repository; +- const char *update_dir; +- List *entries; ++onoff_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + if (setting_default) + { +@@ -63,9 +63,9 @@ onoff_filesdoneproc (callerdat, err, repository, update_dir, entries) + } + + static int +-watch_onoff (argc, argv) +- int argc; +- char **argv; ++watch_onoff ( ++ int argc, ++ char **argv) + { + int c; + int local = 0; +@@ -122,18 +122,18 @@ watch_onoff (argc, argv) + } + + int +-watch_on (argc, argv) +- int argc; +- char **argv; ++watch_on ( ++ int argc, ++ char **argv) + { + turning_on = 1; + return watch_onoff (argc, argv); + } + + int +-watch_off (argc, argv) +- int argc; +- char **argv; ++watch_off ( ++ int argc, ++ char **argv) + { + turning_on = 0; + return watch_onoff (argc, argv); +@@ -142,9 +142,9 @@ watch_off (argc, argv) + static int dummy_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + + static int +-dummy_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++dummy_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + /* This is a pretty hideous hack, but the gist of it is that recurse.c + won't call cvs_notify_check unless there is a fileproc, so we +@@ -161,9 +161,9 @@ static int ncheck_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + processed the directory. */ + + static int +-ncheck_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++ncheck_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + int notif_type; + char *filename; +@@ -237,10 +237,10 @@ static int send_notifications PROTO ((int, char **, int)); + /* Look through the CVSADM_NOTIFY file and process each item there + accordingly. */ + static int +-send_notifications (argc, argv, local) +- int argc; +- char **argv; +- int local; ++send_notifications ( ++ int argc, ++ char **argv, ++ int local) + { + int err = 0; + +@@ -285,9 +285,9 @@ send_notifications (argc, argv, local) + static int edit_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + + static int +-edit_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++edit_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + FILE *fp; + time_t now; +@@ -376,9 +376,9 @@ static const char *const edit_usage[] = + }; + + int +-edit (argc, argv) +- int argc; +- char **argv; ++edit ( ++ int argc, ++ char **argv) + { + int local = 0; + int c; +@@ -466,9 +466,9 @@ edit (argc, argv) + static int unedit_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + + static int +-unedit_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++unedit_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + FILE *fp; + time_t now; +@@ -589,9 +589,9 @@ static const char *const unedit_usage[] = + }; + + int +-unedit (argc, argv) +- int argc; +- char **argv; ++unedit ( ++ int argc, ++ char **argv) + { + int local = 0; + int c; +@@ -633,8 +633,7 @@ unedit (argc, argv) + } + + void +-mark_up_to_date (file) +- const char *file; ++mark_up_to_date (const char *file) + { + char *base; + +@@ -652,10 +651,10 @@ mark_up_to_date (file) + + + void +-editor_set (filename, editor, val) +- const char *filename; +- const char *editor; +- const char *val; ++editor_set ( ++ const char *filename, ++ const char *editor, ++ const char *val) + { + char *edlist; + char *newlist; +@@ -696,9 +695,9 @@ static struct notify_proc_args *notify_args; + static int notify_proc PROTO ((const char *repository, const char *filter)); + + static int +-notify_proc (repository, filter) +- const char *repository; +- const char *filter; ++notify_proc ( ++ const char *repository, ++ const char *filter) + { + FILE *pipefp; + char *prog; +@@ -766,13 +765,13 @@ notify_proc (repository, filter) + an error so that server.c can know whether to report Notified back + to the client. */ + void +-notify_do (type, filename, who, val, watches, repository) +- int type; +- const char *filename; +- const char *who; +- const char *val; +- const char *watches; +- const char *repository; ++notify_do ( ++ int type, ++ const char *filename, ++ const char *who, ++ const char *val, ++ const char *watches, ++ const char *repository) + { + static struct addremove_args blank; + struct addremove_args args; +@@ -993,9 +992,9 @@ notify_do (type, filename, who, val, watches, repository) + #ifdef CLIENT_SUPPORT + /* Check and send notifications. This is only for the client. */ + void +-cvs_notify_check (repository, update_dir) +- const char *repository; +- const char *update_dir; ++cvs_notify_check ( ++ const char *repository, ++ const char *update_dir) + { + FILE *fp; + char *line = NULL; +@@ -1062,9 +1061,9 @@ static const char *const editors_usage[] = + static int editors_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + + static int +-editors_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++editors_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + char *them; + char *p; +@@ -1114,9 +1113,9 @@ editors_fileproc (callerdat, finfo) + } + + int +-editors (argc, argv) +- int argc; +- char **argv; ++editors ( ++ int argc, ++ char **argv) + { + int local = 0; + int c; +diff --git a/src/entries.c b/src/entries.c +index 79389d1..4e728f1 100644 +--- a/src/entries.c ++++ b/src/entries.c +@@ -40,15 +40,15 @@ static Entnode *Entnode_Create PROTO ((enum ent_type, const char *, + const char *, const char *)); + + static Entnode * +-Entnode_Create(type, user, vn, ts, options, tag, date, ts_conflict) +- enum ent_type type; +- const char *user; +- const char *vn; +- const char *ts; +- const char *options; +- const char *tag; +- const char *date; +- const char *ts_conflict; ++Entnode_Create( ++ enum ent_type type, ++ const char *user, ++ const char *vn, ++ const char *ts, ++ const char *options, ++ const char *tag, ++ const char *date, ++ const char *ts_conflict) + { + Entnode *ent; + +@@ -72,8 +72,7 @@ Entnode_Create(type, user, vn, ts, options, tag, date, ts_conflict) + static void Entnode_Destroy PROTO ((Entnode *)); + + static void +-Entnode_Destroy (ent) +- Entnode *ent; ++Entnode_Destroy (Entnode *ent) + { + free (ent->user); + free (ent->version); +@@ -93,9 +92,9 @@ Entnode_Destroy (ent) + */ + static int write_ent_proc PROTO ((Node *, void *)); + static int +-write_ent_proc (node, closure) +- Node *node; +- void *closure; ++write_ent_proc ( ++ Node *node, ++ void *closure) + { + Entnode *entnode = node->data; + +@@ -113,8 +112,7 @@ write_ent_proc (node, closure) + * first of course + */ + static void +-write_entries (list) +- List *list; ++write_entries (List *list) + { + int sawdir; + +@@ -174,9 +172,9 @@ write_entries (list) + * Removes the argument file from the Entries file if necessary. + */ + void +-Scratch_Entry (list, fname) +- List *list; +- const char *fname; ++Scratch_Entry ( ++ List *list, ++ const char *fname) + { + Node *node; + +@@ -217,15 +215,15 @@ Scratch_Entry (list, fname) + * removing the old entry first, if necessary. + */ + void +-Register (list, fname, vn, ts, options, tag, date, ts_conflict) +- List *list; +- const char *fname; +- const char *vn; +- const char *ts; +- const char *options; +- const char *tag; +- const char *date; +- const char *ts_conflict; ++Register ( ++ List *list, ++ const char *fname, ++ const char *vn, ++ const char *ts, ++ const char *options, ++ const char *tag, ++ const char *date, ++ const char *ts_conflict) + { + Entnode *entnode; + Node *node; +@@ -278,8 +276,7 @@ Register (list, fname, vn, ts, options, tag, date, ts_conflict) + * Node delete procedure for list-private sticky dir tag/date info + */ + static void +-freesdt (p) +- Node *p; ++freesdt (Node *p) + { + struct stickydirtag *sdtp = p->data; + +@@ -294,10 +291,10 @@ freesdt (p) + On error, prints an error message and returns NULL. */ + + static Entnode * +-fgetentent(fpin, cmd, sawdir) +- FILE *fpin; +- char *cmd; +- int *sawdir; ++fgetentent( ++ FILE *fpin, ++ char *cmd, ++ int *sawdir) + { + Entnode *ent; + char *line; +@@ -417,9 +414,9 @@ fgetentent(fpin, cmd, sawdir) + } + + static int +-fputentent(fp, p) +- FILE *fp; +- Entnode *p; ++fputentent( ++ FILE *fp, ++ Entnode *p) + { + switch (p->type) + { +@@ -467,9 +464,9 @@ fputentent(fp, p) + messages, or NULL if not known (that is, noone has gotten around + to updating the caller to pass in the information). */ + List * +-Entries_Open (aflag, update_dir) +- int aflag; +- char *update_dir; ++Entries_Open ( ++ int aflag, ++ char *update_dir) + { + List *entries; + struct stickydirtag *sdtp = NULL; +@@ -581,8 +578,8 @@ Entries_Open (aflag, update_dir) + } + + void +-Entries_Close(list) +- List *list; ++Entries_Close( ++ List *list) + { + if (list) + { +@@ -601,8 +598,7 @@ Entries_Close(list) + * node + */ + static void +-Entries_delproc (node) +- Node *node; ++Entries_delproc (Node *node) + { + Entnode *p = node->data; + +@@ -614,9 +610,9 @@ Entries_delproc (node) + * list + */ + static Node * +-AddEntryNode (list, entdata) +- List *list; +- Entnode *entdata; ++AddEntryNode ( ++ List *list, ++ Entnode *entdata) + { + Node *p; + +@@ -648,13 +644,13 @@ AddEntryNode (list, entdata) + * Write out/Clear the CVS/Tag file. + */ + void +-WriteTag (dir, tag, date, nonbranch, update_dir, repository) +- const char *dir; +- const char *tag; +- const char *date; +- int nonbranch; +- const char *update_dir; +- const char *repository; ++WriteTag ( ++ const char *dir, ++ const char *tag, ++ const char *date, ++ int nonbranch, ++ const char *update_dir, ++ const char *repository) + { + FILE *fout; + char *tmp; +@@ -722,10 +718,10 @@ WriteTag (dir, tag, date, nonbranch, update_dir, repository) + If there is an error, print an error message, set *DATEP and *TAGP + to NULL, and return. */ + void +-ParseTag (tagp, datep, nonbranchp) +- char **tagp; +- char **datep; +- int *nonbranchp; ++ParseTag ( ++ char **tagp, ++ char **datep, ++ int *nonbranchp) + { + FILE *fp; + +@@ -804,8 +800,7 @@ ParseTag (tagp, datep, nonbranchp) + */ + + void +-Subdirs_Known (entries) +- List *entries; ++Subdirs_Known (List *entries) + { + struct stickydirtag *sdtp = entries->list->data; + +@@ -844,10 +839,10 @@ Subdirs_Known (entries) + /* Record subdirectory information. */ + + static Entnode * +-subdir_record (cmd, parent, dir) +- int cmd; +- const char *parent; +- const char *dir; ++subdir_record ( ++ int cmd, ++ const char *parent, ++ const char *dir) + { + Entnode *entnode; + +@@ -925,10 +920,10 @@ subdir_record (cmd, parent, dir) + */ + + void +-Subdir_Register (entries, parent, dir) +- List *entries; +- const char *parent; +- const char *dir; ++Subdir_Register ( ++ List *entries, ++ const char *parent, ++ const char *dir) + { + Entnode *entnode; + +@@ -951,10 +946,10 @@ Subdir_Register (entries, parent, dir) + */ + + void +-Subdir_Deregister (entries, parent, dir) +- List *entries; +- const char *parent; +- const char *dir; ++Subdir_Deregister ( ++ List *entries, ++ const char *parent, ++ const char *dir) + { + Entnode *entnode; + +@@ -1015,10 +1010,10 @@ static void base_walk PROTO ((enum base_walk, struct file_info *, char **)); + for CODE. */ + + static void +-base_walk (code, finfo, rev) +- enum base_walk code; +- struct file_info *finfo; +- char **rev; ++base_walk ( ++ enum base_walk code, ++ struct file_info *finfo, ++ char **rev) + { + FILE *fp; + char *line; +@@ -1173,8 +1168,7 @@ base_walk (code, finfo, rev) + or NULL if not listed. */ + + char * +-base_get (finfo) +- struct file_info *finfo; ++base_get (struct file_info *finfo) + { + char *rev; + base_walk (BASE_GET, finfo, &rev); +@@ -1184,9 +1178,9 @@ base_get (finfo) + /* Set the revision for FILE to REV. */ + + void +-base_register (finfo, rev) +- struct file_info *finfo; +- char *rev; ++base_register ( ++ struct file_info *finfo, ++ char *rev) + { + base_walk (BASE_REGISTER, finfo, &rev); + } +@@ -1194,8 +1188,7 @@ base_register (finfo, rev) + /* Remove FILE. */ + + void +-base_deregister (finfo) +- struct file_info *finfo; ++base_deregister (struct file_info *finfo) + { + base_walk (BASE_DEREGISTER, finfo, NULL); + } +diff --git a/src/error.c b/src/error.c +index 5fbd9c4..2e859a2 100644 +--- a/src/error.c ++++ b/src/error.c +@@ -60,7 +60,7 @@ void exit (); + void + error_exit PROTO ((void)) + { +- rcs_cleanup (); ++ rcs_cleanup (0); + Lock_Cleanup (); + #ifdef SERVER_SUPPORT + if (server_active) +diff --git a/src/expand_path.c b/src/expand_path.c +index 1c960f3..c52368d 100644 +--- a/src/expand_path.c ++++ b/src/expand_path.c +@@ -39,8 +39,7 @@ List *variable_list = NULL; + static void variable_delproc PROTO ((Node *)); + + static void +-variable_delproc (node) +- Node *node; ++variable_delproc (Node *node) + { + free (node->data); + } +@@ -49,8 +48,7 @@ variable_delproc (node) + variables in a file in the $CVSROOT/CVSROOT directory too. */ + + void +-variable_set (nameval) +- char *nameval; ++variable_set (char *nameval) + { + char *p; + char *name; +@@ -104,10 +102,10 @@ variable_set (nameval) + to something; LINE can be zero to indicate the line number is not + known. */ + char * +-expand_path (name, file, line) +- const char *name; +- const char *file; +- int line; ++expand_path ( ++ const char *name, ++ const char *file, ++ int line) + { + size_t s, d, p; + char *e; +@@ -249,10 +247,10 @@ expand_path (name, file, line) + } + + static char * +-expand_variable (name, file, line) +- const char *name; +- const char *file; +- int line; ++expand_variable ( ++ const char *name, ++ const char *file, ++ int line) + { + if (strcmp (name, CVSROOT_ENV) == 0) + return current_parsed_root->directory; +diff --git a/src/fileattr.c b/src/fileattr.c +index 63fff38..d786ef5 100644 +--- a/src/fileattr.c ++++ b/src/fileattr.c +@@ -42,8 +42,7 @@ static struct unrecog *unrecog_head; + /* Note that if noone calls fileattr_get, this is very cheap. No stat(), + no open(), no nothing. */ + void +-fileattr_startdir (repos) +- const char *repos; ++fileattr_startdir (const char *repos) + { + assert (fileattr_stored_repos == NULL); + fileattr_stored_repos = xstrdup (repos); +@@ -53,8 +52,7 @@ fileattr_startdir (repos) + } + + static void +-fileattr_delproc (node) +- Node *node; ++fileattr_delproc (Node *node) + { + assert (node->data != NULL); + free (node->data); +@@ -166,9 +164,9 @@ fileattr_read () + } + + char * +-fileattr_get (filename, attrname) +- const char *filename; +- const char *attrname; ++fileattr_get ( ++ const char *filename, ++ const char *attrname) + { + Node *node; + size_t attrname_len = strlen (attrname); +@@ -209,9 +207,9 @@ fileattr_get (filename, attrname) + } + + char * +-fileattr_get0 (filename, attrname) +- const char *filename; +- const char *attrname; ++fileattr_get0 ( ++ const char *filename, ++ const char *attrname) + { + char *cp; + char *cpend; +@@ -230,12 +228,12 @@ fileattr_get0 (filename, attrname) + } + + char * +-fileattr_modify (list, attrname, attrval, namevalsep, entsep) +- char *list; +- const char *attrname; +- const char *attrval; +- int namevalsep; +- int entsep; ++fileattr_modify ( ++ char *list, ++ const char *attrname, ++ const char *attrval, ++ int namevalsep, ++ int entsep) + { + char *retval; + char *rp; +@@ -327,10 +325,10 @@ fileattr_modify (list, attrname, attrval, namevalsep, entsep) + } + + void +-fileattr_set (filename, attrname, attrval) +- const char *filename; +- const char *attrname; +- const char *attrval; ++fileattr_set ( ++ const char *filename, ++ const char *attrname, ++ const char *attrval) + { + Node *node; + char *p; +@@ -387,8 +385,7 @@ fileattr_set (filename, attrname, attrval) + } + + char * +-fileattr_getall (filename) +- const char *filename; ++fileattr_getall (const char *filename) + { + Node *node; + char *p; +@@ -414,9 +411,9 @@ fileattr_getall (filename) + } + + void +-fileattr_setall (filename, attrs) +- const char *filename; +- const char *attrs; ++fileattr_setall ( ++ const char *filename, ++ const char *attrs) + { + Node *node; + +@@ -467,8 +464,7 @@ fileattr_setall (filename, attrs) + } + + void +-fileattr_newfile (filename) +- const char *filename; ++fileattr_newfile (const char *filename) + { + Node *node; + +@@ -496,9 +492,9 @@ fileattr_newfile (filename) + } + + static int +-writeattr_proc (node, data) +- Node *node; +- void *data; ++writeattr_proc ( ++ Node *node, ++ void *data) + { + FILE *fp = (FILE *)data; + fputs ("F", fp); +diff --git a/src/filesubr.c b/src/filesubr.c +index 8524564..b668628 100644 +--- a/src/filesubr.c ++++ b/src/filesubr.c +@@ -28,9 +28,9 @@ static int deep_remove_dir PROTO((const char *path)); + * Copies "from" to "to". + */ + void +-copy_file (from, to) +- const char *from; +- const char *to; ++copy_file ( ++ const char *from, ++ const char *to) + { + struct stat sb; + struct utimbuf t; +@@ -122,8 +122,7 @@ copy_file (from, to) + * link which points to a directory. + */ + int +-isdir (file) +- const char *file; ++isdir (const char *file) + { + struct stat sb; + +@@ -136,8 +135,7 @@ isdir (file) + * Returns non-zero if the argument file is a symbolic link. + */ + int +-islink (file) +- const char *file; ++islink (const char *file) + { + #ifdef S_ISLNK + struct stat sb; +@@ -155,8 +153,7 @@ islink (file) + * character special device. + */ + int +-isdevice (file) +- const char *file; ++isdevice (const char *file) + { + struct stat sb; + +@@ -177,8 +174,7 @@ isdevice (file) + * Returns non-zero if the argument file exists. + */ + int +-isfile (file) +- const char *file; ++isfile (const char *file) + { + return isaccessible(file, F_OK); + } +@@ -187,8 +183,7 @@ isfile (file) + * Returns non-zero if the argument file is readable. + */ + int +-isreadable (file) +- const char *file; ++isreadable (const char *file) + { + return isaccessible(file, R_OK); + } +@@ -197,8 +192,7 @@ isreadable (file) + * Returns non-zero if the argument file is writable. + */ + int +-iswritable (file) +- const char *file; ++iswritable (const char *file) + { + return isaccessible(file, W_OK); + } +@@ -209,9 +203,9 @@ iswritable (file) + * bits set. + */ + int +-isaccessible (file, mode) +- const char *file; +- const int mode; ++isaccessible ( ++ const char *file, ++ const int mode) + { + #ifdef SETXID_SUPPORT + struct stat sb; +@@ -268,9 +262,9 @@ isaccessible (file, mode) + * Open a file and die if it fails + */ + FILE * +-open_file (name, mode) +- const char *name; +- const char *mode; ++open_file ( ++ const char *name, ++ const char *mode) + { + FILE *fp; + +@@ -283,8 +277,7 @@ open_file (name, mode) + * Make a directory and die if it fails + */ + void +-make_directory (name) +- const char *name; ++make_directory (const char *name) + { + struct stat sb; + +@@ -299,8 +292,7 @@ make_directory (name) + * goes wrong. + */ + void +-make_directories (name) +- const char *name; ++make_directories (const char *name) + { + char *cp; + +@@ -328,8 +320,7 @@ make_directories (name) + other errors. Returns 0 if directory was created; 1 if it already + existed. */ + int +-mkdir_if_needed (name) +- const char *name; ++mkdir_if_needed (const char *name) + { + if (mkdir (name, 0777) < 0) + { +@@ -349,9 +340,9 @@ mkdir_if_needed (name) + * have unexpected consequences for some uses of xchmod. + */ + void +-xchmod (fname, writable) +- const char *fname; +- int writable; ++xchmod ( ++ const char *fname, ++ int writable) + { + struct stat sb; + mode_t mode, oumask; +@@ -394,9 +385,9 @@ xchmod (fname, writable) + * Rename a file and die if it fails + */ + void +-rename_file (from, to) +- const char *from; +- const char *to; ++rename_file ( ++ const char *from, ++ const char *to) + { + if (trace) + (void) fprintf (stderr, "%s-> rename(%s,%s)\n", +@@ -412,8 +403,7 @@ rename_file (from, to) + * unlink a file, if possible. + */ + int +-unlink_file (f) +- const char *f; ++unlink_file (const char *f) + { + if (trace) + (void) fprintf (stderr, "%s-> unlink_file(%s)\n", +@@ -430,8 +420,7 @@ unlink_file (f) + * (in which case errno is set). + */ + int +-unlink_file_dir (f) +- const char *f; ++unlink_file_dir (const char *f) + { + struct stat sb; + +@@ -471,8 +460,7 @@ unlink_file_dir (f) + */ + + static int +-deep_remove_dir (path) +- const char *path; ++deep_remove_dir (const char *path) + { + DIR *dirp; + struct dirent *dp; +@@ -551,10 +539,10 @@ deep_remove_dir (path) + Return the number of characters successfully read. + The number returned is always NCHARS unless end-of-file or error. */ + static size_t +-block_read (fd, buf, nchars) +- int fd; +- char *buf; +- size_t nchars; ++block_read ( ++ int fd, ++ char *buf, ++ size_t nchars) + { + char *bp = buf; + size_t nread; +@@ -588,9 +576,9 @@ block_read (fd, buf, nchars) + * (i.e. major/minor device numbers, links, etc. + */ + int +-xcmp (file1, file2) +- const char *file1; +- const char *file2; ++xcmp ( ++ const char *file1, ++ const char *file2) + { + char *buf1, *buf2; + struct stat sb1, sb2; +@@ -741,8 +729,7 @@ cvs_temp_name () + * bother. + */ + FILE * +-cvs_temp_file (filename) +- char **filename; ++cvs_temp_file (char **filename) + { + char *fn; + FILE *fp; +@@ -883,8 +870,7 @@ cvs_temp_file (filename) + #define MAXSIZE (SIZE_MAX < SSIZE_MAX ? SIZE_MAX : SSIZE_MAX) + + char * +-xreadlink (link) +- const char *link; ++xreadlink (const char *link) + { + char *file = NULL; + size_t buflen = BUFSIZ; +@@ -943,8 +929,7 @@ xreadlink (link) + * any reason. + */ + char * +-xresolvepath ( path ) +- const char *path; ++xresolvepath (const char *path) + { + char *hardpath; + char *owd; +@@ -970,8 +955,7 @@ xresolvepath ( path ) + + /* Return a pointer into PATH's last component. */ + const char * +-last_component (path) +- const char *path; ++last_component (const char *path) + { + const char *last = strrchr (path, '/'); + +@@ -1037,9 +1021,9 @@ get_homedir () + * the GPL and the Artistic license - we might be able to use it. + */ + char * +-strcat_filename_onto_homedir (dir, file) +- const char *dir; +- const char *file; ++strcat_filename_onto_homedir ( ++ const char *dir, ++ const char *file) + { + char *path = xmalloc (strlen (dir) + 1 + strlen(file) + 1); + sprintf (path, "%s/%s", dir, file); +@@ -1049,11 +1033,11 @@ strcat_filename_onto_homedir (dir, file) + /* See cvs.h for description. On unix this does nothing, because the + shell expands the wildcards. */ + void +-expand_wild (argc, argv, pargc, pargv) +- int argc; +- char **argv; +- int *pargc; +- char ***pargv; ++expand_wild ( ++ int argc, ++ char **argv, ++ int *pargc, ++ char ***pargv) + { + int i; + assert (argv || !argc); +@@ -1078,9 +1062,9 @@ expand_wild (argc, argv, pargc, pargv) + looked into whether this is a performance bottleneck; I would guess + not). */ + int +-cvs_casecmp (str1, str2) +- const char *str1; +- const char *str2; ++cvs_casecmp ( ++ const char *str1, ++ const char *str2) + { + const char *p; + const char *q; +diff --git a/src/find_names.c b/src/find_names.c +index 5bfd895..0546d10 100644 +--- a/src/find_names.c ++++ b/src/find_names.c +@@ -34,9 +34,9 @@ static int register_subdir_proc PROTO((Node *, void *)); + */ + static int add_entries_proc PROTO((Node *, void *)); + static int +-add_entries_proc (node, closure) +- Node *node; +- void *closure; ++add_entries_proc ( ++ Node *node, ++ void *closure) + { + Node *fnode; + List *filelist = closure; +@@ -59,11 +59,11 @@ add_entries_proc (node, closure) + list). */ + + List * +-Find_Names (repository, which, aflag, optentries) +- char *repository; +- int which; +- int aflag; +- List **optentries; ++Find_Names ( ++ char *repository, ++ int which, ++ int aflag, ++ List **optentries) + { + List *entries; + List *files; +@@ -127,9 +127,9 @@ Find_Names (repository, which, aflag, optentries) + */ + + static int +-add_subdir_proc (p, closure) +- Node *p; +- void *closure; ++add_subdir_proc ( ++ Node *p, ++ void *closure) + { + List *dirlist = closure; + Entnode *entnode = p->data; +@@ -152,9 +152,9 @@ add_subdir_proc (p, closure) + + /*ARGSUSED*/ + static int +-register_subdir_proc (p, closure) +- Node *p; +- void *closure; ++register_subdir_proc ( ++ Node *p, ++ void *closure) + { + List *entries = (List *) closure; + +@@ -166,10 +166,10 @@ register_subdir_proc (p, closure) + * create a list of directories to traverse from the current directory + */ + List * +-Find_Directories (repository, which, entries) +- char *repository; +- int which; +- List *entries; ++Find_Directories ( ++ char *repository, ++ int which, ++ List *entries) + { + List *dirlist; + +@@ -257,9 +257,9 @@ Find_Directories (repository, which, entries) + * containing the files which were found before the error occurred). + */ + static int +-find_rcs (dir, list) +- char *dir; +- List *list; ++find_rcs ( ++ char *dir, ++ List *list) + { + Node *p; + struct dirent *dp; +@@ -306,11 +306,11 @@ find_rcs (dir, list) + * error, in which case errno is set to indicate the error. + */ + static int +-find_dirs (dir, list, checkadm, entries) +- char *dir; +- List *list; +- int checkadm; +- List *entries; ++find_dirs ( ++ char *dir, ++ List *list, ++ int checkadm, ++ List *entries) + { + Node *p; + char *tmp = NULL; +diff --git a/src/hash.c b/src/hash.c +index d9bc12c..577b8d1 100644 +--- a/src/hash.c ++++ b/src/hash.c +@@ -26,8 +26,7 @@ static void freenode_mem PROTO((Node * p)); + + /* hash function */ + static int +-hashp (key) +- const char *key; ++hashp (const char *key) + { + unsigned int h = 0; + unsigned int g; +@@ -82,8 +81,7 @@ getlist () + * free up a list + */ + void +-dellist (listp) +- List **listp; ++dellist (List **listp) + { + int i; + Node *p; +@@ -161,8 +159,7 @@ getnode () + * remove a node from it's list (maybe hash list too) and free it + */ + void +-delnode (p) +- Node *p; ++delnode (Node *p) + { + if (p == (Node *) NULL) + return; +@@ -186,10 +183,9 @@ delnode (p) + * free up the storage associated with a node + */ + static void +-freenode_mem (p) +- Node *p; ++freenode_mem (Node *p) + { +- if (p->delproc != (void (*) ()) NULL) ++ if (p->delproc != NULL) + p->delproc (p); /* call the specified delproc */ + else + { +@@ -201,15 +197,14 @@ freenode_mem (p) + + /* to be safe, re-initialize these */ + p->key = p->data = NULL; +- p->delproc = (void (*) ()) NULL; ++ p->delproc = NULL; + } + + /* + * free up the storage associated with a node and recycle it + */ + void +-freenode (p) +- Node *p; ++freenode (Node *p) + { + /* first free the memory */ + freenode_mem (p); +@@ -232,10 +227,10 @@ freenode (p) + * return 0 on success + */ + int +-insert_before (list, marker, p) +- List *list; +- Node *marker; +- Node *p; ++insert_before ( ++ List *list, ++ Node *marker, ++ Node *p) + { + if (p->key != NULL) /* hash it too? */ + { +@@ -279,9 +274,9 @@ insert_before (list, marker, p) + * return 0 on success + */ + int +-addnode (list, p) +- List *list; +- Node *p; ++addnode ( ++ List *list, ++ Node *p) + { + return insert_before (list, list->list, p); + } +@@ -291,9 +286,9 @@ addnode (list, p) + * necessary to preserve last-to-first output order for some RCS functions. + */ + int +-addnode_at_front (list, p) +- List *list; +- Node *p; ++addnode_at_front ( ++ List *list, ++ Node *p) + { + return insert_before (list, list->list->next, p); + } +@@ -302,9 +297,9 @@ addnode_at_front (list, p) + node. Return NULL if not found. Abort with a fatal error for + errors. */ + Node * +-findnode (list, key) +- List *list; +- const char *key; ++findnode ( ++ List *list, ++ const char *key) + { + Node *head, *p; + +@@ -331,9 +326,9 @@ findnode (list, key) + * Like findnode, but for a filename. + */ + Node * +-findnode_fn (list, key) +- List *list; +- const char *key; ++findnode_fn ( ++ List *list, ++ const char *key) + { + Node *head, *p; + +@@ -359,10 +354,10 @@ findnode_fn (list, key) + * walk a list with a specific proc + */ + int +-walklist (list, proc, closure) +- List *list; +- int (*proc) PROTO ((Node *, void *)); +- void *closure; ++walklist ( ++ List *list, ++ int (*proc) PROTO ((Node *, void *)), ++ void *closure) + { + Node *head, *p; + int err = 0; +@@ -377,8 +372,7 @@ walklist (list, proc, closure) + } + + int +-list_isempty (list) +- List *list; ++list_isempty (List *list) + { + return list == NULL || list->list->next == list->list; + } +@@ -387,9 +381,9 @@ static int (*client_comp) PROTO ((const Node *, const Node *)); + static int qsort_comp PROTO ((const void *, const void *)); + + static int +-qsort_comp (elem1, elem2) +- const void *elem1; +- const void *elem2; ++qsort_comp ( ++ const void *elem1, ++ const void *elem2) + { + Node **node1 = (Node **) elem1; + Node **node2 = (Node **) elem2; +@@ -400,9 +394,9 @@ qsort_comp (elem1, elem2) + * sort the elements of a list (in place) + */ + void +-sortlist (list, comp) +- List *list; +- int (*comp) PROTO ((const Node *, const Node *)); ++sortlist ( ++ List *list, ++ int (*comp) PROTO ((const Node *, const Node *))) + { + Node *head, *remain, *p, **array; + int i, n; +@@ -448,9 +442,9 @@ sortlist (list, comp) + * compare two files list node (for sort) + */ + int +-fsortcmp (p, q) +- const Node *p; +- const Node *q; ++fsortcmp ( ++ const Node *p, ++ const Node *q) + { + return (strcmp (p->key, q->key)); + } +@@ -460,8 +454,7 @@ fsortcmp (p, q) + static char *nodetypestring PROTO ((Ntype)); + + static char * +-nodetypestring (type) +- Ntype type; ++nodetypestring (Ntype type) + { + switch (type) { + case NT_UNKNOWN: return("UNKNOWN"); +@@ -486,9 +479,9 @@ nodetypestring (type) + + static int printnode PROTO ((Node *, void *)); + static int +-printnode (node, closure) +- Node *node; +- void *closure; ++printnode ( ++ Node *node, ++ void *closure) + { + if (node == NULL) + { +@@ -510,8 +503,7 @@ printnode (node, closure) + void printlist PROTO ((List *)); + + void +-printlist (list) +- List *list; ++printlist (List *list) + { + if (list == NULL) + { +diff --git a/src/hash.h b/src/hash.h +index 77d095a..4e93e77 100644 +--- a/src/hash.h ++++ b/src/hash.h +@@ -36,7 +36,7 @@ struct hashnode + struct hashnode *hashprev; + char *key; + void *data; +- void (*delproc) (); ++ void (*delproc) (struct hashnode *node); + }; + typedef struct hashnode Node; + +diff --git a/src/history.c b/src/history.c +index acb0d00..8db2cac 100644 +--- a/src/history.c ++++ b/src/history.c +@@ -327,9 +327,9 @@ static const char *const history_usg[] = + - Always sort timestamp last. + */ + static int +-sort_order (l, r) +- const PTR l; +- const PTR r; ++sort_order ( ++ const PTR l, ++ const PTR r) + { + int i; + const struct hrec *left = (const struct hrec *) l; +@@ -378,9 +378,9 @@ sort_order (l, r) + } + + int +-history (argc, argv) +- int argc; +- char **argv; ++history ( ++ int argc, ++ char **argv) + { + int i, c; + char *fname; +@@ -711,12 +711,12 @@ history (argc, argv) + } + + void +-history_write (type, update_dir, revs, name, repository) +- int type; +- const char *update_dir; +- const char *revs; +- const char *name; +- const char *repository; ++history_write ( ++ int type, ++ const char *update_dir, ++ const char *revs, ++ const char *name, ++ const char *repository) + { + char *fname; + char *workdir; +@@ -920,8 +920,7 @@ history_write (type, update_dir, revs, name, repository) + * username ("") matches any user. + */ + static void +-save_user (name) +- char *name; ++save_user (char *name) + { + if (user_count == user_max) + { +@@ -950,10 +949,10 @@ save_user (name) + * - else it is matched against the file name. + */ + static void +-save_file (dir, name, module) +- char *dir; +- char *name; +- char *module; ++save_file ( ++ char *dir, ++ char *name, ++ char *module) + { + char *cp; + struct file_list_str *fl; +@@ -1003,8 +1002,7 @@ save_file (dir, name, module) + } + + static void +-save_module (module) +- char *module; ++save_module (char *module) + { + if (mod_count == mod_max) + { +@@ -1044,9 +1042,9 @@ expand_modules () + } while (0) + + static void +-fill_hrec (line, hr) +- char *line; +- struct hrec *hr; ++fill_hrec ( ++ char *line, ++ struct hrec *hr) + { + char *cp; + int c; +@@ -1103,8 +1101,7 @@ fill_hrec (line, hr) + * than the whole block, we're done. + */ + static void +-read_hrecs (fname) +- char *fname; ++read_hrecs (char *fname) + { + unsigned char *cpstart, *cpend, *cp, *nl; + char *hrline; +@@ -1215,8 +1212,9 @@ read_hrecs (fname) + + /* Utility program for determining whether "find" is inside "string" */ + static int +-within (find, string) +- char *find, *string; ++within ( ++ char *find, ++ char *string) + { + int c, len; + +@@ -1242,8 +1240,7 @@ within (find, string) + * this record should be remembered for printing. + */ + static int +-select_hrec (hr) +- struct hrec *hr; ++select_hrec (struct hrec *hr) + { + char **cpp, *cp, *cp2; + struct file_list_str *fl; +@@ -1603,8 +1600,9 @@ report_hrecs () + } + + static int +-accept_hrec (lr, hr) +- struct hrec *hr, *lr; ++accept_hrec ( ++ struct hrec *lr, ++ struct hrec *hr) + { + int ty; + +diff --git a/src/ignore.c b/src/ignore.c +index eae9c16..13a07c4 100644 +--- a/src/ignore.c ++++ b/src/ignore.c +@@ -108,9 +108,9 @@ ign_setup () + * argument is set. + */ + void +-ign_add_file (file, hold) +- char *file; +- int hold; ++ign_add_file ( ++ char *file, ++ int hold) + { + FILE *fp; + char *line = NULL; +@@ -172,9 +172,9 @@ ign_add_file (file, hold) + + /* Parse a line of space-separated wildcards and add them to the list. */ + void +-ign_add (ign, hold) +- char *ign; +- int hold; ++ign_add ( ++ char *ign, ++ int hold) + { + if (!ign || !*ign) + return; +@@ -287,8 +287,7 @@ ign_add (ign, hold) + * else return false. + */ + int +-ign_name (name) +- char *name; ++ign_name (char *name) + { + char **cpp = ign_list; + +@@ -315,8 +314,7 @@ static int dir_ign_current = 0; + + /* Add a directory to list of dirs to ignore. */ + void +-ign_dir_add (name) +- char *name; ++ign_dir_add (char *name) + { + /* Make sure we've got the space for the entry. */ + if (dir_ign_current <= dir_ign_max) +@@ -334,8 +332,7 @@ ign_dir_add (name) + /* Return nonzero if NAME is part of the list of directories to ignore. */ + + int +-ignore_directory (name) +- const char *name; ++ignore_directory (const char *name) + { + int i; + +@@ -363,11 +360,11 @@ ignore_directory (name) + * directory with a CVS administration directory is known. + */ + void +-ignore_files (ilist, entries, update_dir, proc) +- List *ilist; +- List *entries; +- const char *update_dir; +- Ignore_proc proc; ++ignore_files ( ++ List *ilist, ++ List *entries, ++ const char *update_dir, ++ Ignore_proc proc) + { + int subdirs; + DIR *dirp; +diff --git a/src/import.c b/src/import.c +index e424df8..6050c5f 100644 +--- a/src/import.c ++++ b/src/import.c +@@ -63,9 +63,9 @@ static const char *const import_usage[] = + }; + + int +-import (argc, argv) +- int argc; +- char **argv; ++import ( ++ int argc, ++ char **argv) + { + char *message = NULL; + char *tmpfile; +@@ -431,11 +431,11 @@ import (argc, argv) + Returns 0 for success, or >0 on error (in which case a message + will have been printed). */ + static int +-import_descend (message, vtag, targc, targv) +- char *message; +- char *vtag; +- int targc; +- char *targv[]; ++import_descend ( ++ char *message, ++ char *vtag, ++ int targc, ++ char *targv[]) + { + DIR *dirp; + struct dirent *dp; +@@ -554,12 +554,12 @@ import_descend (message, vtag, targc, targv) + * Process the argument import file. + */ + static int +-process_import_file (message, vfile, vtag, targc, targv) +- char *message; +- char *vfile; +- char *vtag; +- int targc; +- char *targv[]; ++process_import_file ( ++ char *message, ++ char *vfile, ++ char *vtag, ++ int targc, ++ char *targv[]) + { + char *rcs; + int inattic = 0; +@@ -643,13 +643,13 @@ process_import_file (message, vfile, vtag, targc, targv) + * (possibly already existing) vendor branch. + */ + static int +-update_rcs_file (message, vfile, vtag, targc, targv, inattic) +- char *message; +- char *vfile; +- char *vtag; +- int targc; +- char *targv[]; +- int inattic; ++update_rcs_file ( ++ char *message, ++ char *vfile, ++ char *vtag, ++ int targc, ++ char *targv[], ++ int inattic) + { + Vers_TS *vers; + int letter; +@@ -736,11 +736,11 @@ update_rcs_file (message, vfile, vtag, targc, targv, inattic) + * Add the revision to the vendor branch + */ + static int +-add_rev (message, rcs, vfile, vers) +- char *message; +- RCSNode *rcs; +- char *vfile; +- char *vers; ++add_rev ( ++ char *message, ++ RCSNode *rcs, ++ char *vfile, ++ char *vers) + { + int locked, status, ierrno; + char *tocvsPath; +@@ -800,12 +800,12 @@ add_rev (message, rcs, vfile, vers) + * 1.1.1.2, ...). + */ + static int +-add_tags (rcs, vfile, vtag, targc, targv) +- RCSNode *rcs; +- char *vfile; +- char *vtag; +- int targc; +- char *targv[]; ++add_tags ( ++ RCSNode *rcs, ++ char *vfile, ++ char *vtag, ++ int targc, ++ char *targv[]) + { + int i, ierrno; + Vers_TS *vers; +@@ -965,8 +965,7 @@ static const struct compair comtable[] = + }; + + static char * +-get_comment (user) +- const char *user; ++get_comment (const char *user) + { + char *cp, *suffix; + char *suffix_path; +@@ -1018,43 +1017,41 @@ get_comment (user) + Return value is 0 for success, or nonzero for failure (in which + case an error message will have already been printed). */ + int +-add_rcs_file (message, rcs, user, add_vhead, key_opt, +- add_vbranch, vtag, targc, targv, +- desctext, desclen, add_logfp) ++add_rcs_file ( + /* Log message for the addition. Not used if add_vhead == NULL. */ +- const char *message; ++ const char *message, + /* Filename of the RCS file to create. */ +- const char *rcs; ++ const char *rcs, + /* Filename of the file to serve as the contents of the initial + revision. Even if add_vhead is NULL, we use this to determine + the modes to give the new RCS file. */ +- const char *user; ++ const char *user, + + /* Revision number of head that we are adding. Normally 1.1 but + could be another revision as long as ADD_VBRANCH is a branch + from it. If NULL, then just add an empty file without any + revisions (similar to the one created by "rcs -i"). */ +- const char *add_vhead; ++ const char *add_vhead, + + /* Keyword expansion mode, e.g., "b" for binary. NULL means the + default behavior. */ +- const char *key_opt; ++ const char *key_opt, + + /* Vendor branch to import to, or NULL if none. If non-NULL, then + vtag should also be non-NULL. */ +- const char *add_vbranch; +- const char *vtag; +- int targc; +- char *targv[]; ++ const char *add_vbranch, ++ const char *vtag, ++ int targc, ++ char *targv[], + + /* If non-NULL, description for the file. If NULL, the description + will be empty. */ +- const char *desctext; +- size_t desclen; ++ const char *desctext, ++ size_t desclen, + + /* Write errors to here as well as via error (), or NULL if we should + use only error (). */ +- FILE *add_logfp; ++ FILE *add_logfp) + { + FILE *fprcs, *fpuser; + struct stat sb; +@@ -1497,10 +1494,10 @@ read_error: + * to indicate the error. If not, return a nonnegative value. + */ + int +-expand_at_signs (buf, size, fp) +- const char *buf; +- off_t size; +- FILE *fp; ++expand_at_signs ( ++ const char *buf, ++ off_t size, ++ FILE *fp) + { + register const char *cp, *next; + +@@ -1526,9 +1523,9 @@ expand_at_signs (buf, size, fp) + * Write an update message to (potentially) the screen and the log file. + */ + static void +-add_log (ch, fname) +- int ch; +- char *fname; ++add_log ( ++ int ch, ++ char *fname) + { + if (!really_quiet) /* write to terminal */ + { +@@ -1567,12 +1564,12 @@ add_log (ch, fname) + * Note that we do not follow symbolic links here, which is a feature! + */ + static int +-import_descend_dir (message, dir, vtag, targc, targv) +- char *message; +- char *dir; +- char *vtag; +- int targc; +- char *targv[]; ++import_descend_dir ( ++ char *message, ++ char *dir, ++ char *vtag, ++ int targc, ++ char *targv[]) + { + struct saved_cwd cwd; + char *cp; +diff --git a/src/lock.c b/src/lock.c +index d00d0b0..6cde89e 100644 +--- a/src/lock.c ++++ b/src/lock.c +@@ -168,9 +168,9 @@ static char *lock_name PROTO ((const char *repository, const char *name)); + that only if the actual operation fails. But for now we'll keep + things simple). */ + static char * +-lock_name (repository, name) +- const char *repository; +- const char *name; ++lock_name ( ++ const char *repository, ++ const char *name) + { + char *retval; + const char *p; +@@ -362,9 +362,9 @@ remove_locks () + * walklist proc for removing a list of locks + */ + static int +-unlock_proc (p, closure) +- Node *p; +- void *closure; ++unlock_proc ( ++ Node *p, ++ void *closure) + { + lock_simple_remove (p->data); + return (0); +@@ -374,8 +374,7 @@ unlock_proc (p, closure) + + /* Remove the lock files. */ + static void +-lock_simple_remove (lock) +- struct lock *lock; ++lock_simple_remove (struct lock *lock) + { + char *tmp; + +@@ -412,8 +411,7 @@ lock_simple_remove (lock) + * Create a lock file for readers + */ + int +-Reader_Lock (xrepository) +- char *xrepository; ++Reader_Lock (char *xrepository) + { + int err = 0; + FILE *fp; +@@ -493,8 +491,7 @@ static int lock_error; + static int Writer_Lock PROTO ((List * list)); + + static int +-Writer_Lock (list) +- List *list; ++Writer_Lock (List *list) + { + char *wait_repos; + +@@ -560,9 +557,9 @@ Writer_Lock (list) + * walklist proc for setting write locks + */ + static int +-set_writelock_proc (p, closure) +- Node *p; +- void *closure; ++set_writelock_proc ( ++ Node *p, ++ void *closure) + { + /* if some lock was not OK, just skip this one */ + if (lock_error != L_OK) +@@ -581,8 +578,7 @@ set_writelock_proc (p, closure) + * lock held by someone else or L_ERROR if an error occurred + */ + static int +-write_lock (lock) +- struct lock *lock; ++write_lock (struct lock *lock) + { + int status; + FILE *fp; +@@ -658,8 +654,7 @@ write_lock (lock) + * sleep a while and try again. + */ + static int +-readers_exist (repository) +- char *repository; ++readers_exist (char *repository) + { + char *lockdir; + char *line; +@@ -742,8 +737,7 @@ readers_exist (repository) + * structure passed in. + */ + static void +-set_lockers_name (statp) +- struct stat *statp; ++set_lockers_name (struct stat *statp) + { + struct passwd *pw; + +@@ -774,9 +768,9 @@ set_lockers_name (statp) + * + */ + static int +-set_lock (lock, will_wait) +- struct lock *lock; +- int will_wait; ++set_lock ( ++ struct lock *lock, ++ int will_wait) + { + int waited; + long us; +@@ -915,8 +909,7 @@ done: + * + */ + static void +-clear_lock (lock) +- struct lock *lock; ++clear_lock (struct lock *lock) + { + SIG_beginCrSect (); + if (lock->lockdir) +@@ -935,8 +928,7 @@ clear_lock (lock) + * Print out a message that the lock is still held, then sleep a while. + */ + static void +-lock_wait (repos) +- char *repos; ++lock_wait (char *repos) + { + time_t now; + char *msg; +@@ -960,8 +952,7 @@ lock_wait (repos) + * Print out a message when we obtain a lock. + */ + static void +-lock_obtained (repos) +- char *repos; ++lock_obtained (char *repos) + { + time_t now; + char *msg; +@@ -991,12 +982,12 @@ static int lock_filesdoneproc PROTO ((void *callerdat, int err, + */ + /* ARGSUSED */ + static int +-lock_filesdoneproc (callerdat, err, repository, update_dir, entries) +- void *callerdat; +- int err; +- const char *repository; +- const char *update_dir; +- List *entries; ++lock_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + Node *p; + +@@ -1015,12 +1006,12 @@ lock_filesdoneproc (callerdat, err, repository, update_dir, entries) + } + + void +-lock_tree_for_write (argc, argv, local, which, aflag) +- int argc; +- char **argv; +- int local; +- int which; +- int aflag; ++lock_tree_for_write ( ++ int argc, ++ char **argv, ++ int local, ++ int which, ++ int aflag) + { + /* + * Run the recursion processor to find all the dirs to lock and lock all +@@ -1040,8 +1031,7 @@ lock_tree_for_write (argc, argv, local, which, aflag) + a lock has been set with lock_dir_for_write; the new lock will replace + the old one. If REPOSITORY is NULL, don't do anything. */ + void +-lock_dir_for_write (repository) +- char *repository; ++lock_dir_for_write (char *repository) + { + if (repository != NULL + && (locked_dir == NULL +@@ -1078,9 +1068,9 @@ lock_dir_for_write (repository) + */ + static int internal_lock PROTO ((struct lock *lock, const char *xrepository)); + static int +-internal_lock (lock, xrepository) +- struct lock *lock; +- const char *xrepository; ++internal_lock ( ++ struct lock *lock, ++ const char *xrepository) + { + /* remember what we're locking (for Lock_Cleanup) */ + assert (!lock->repository); +@@ -1107,8 +1097,7 @@ internal_lock (lock, xrepository) + */ + static void internal_clear_lock PROTO((struct lock *lock)); + static void +-internal_clear_lock (lock) +- struct lock *lock; ++internal_clear_lock (struct lock *lock) + { + SIG_beginCrSect (); + if (lock->repository) +@@ -1126,8 +1115,7 @@ internal_clear_lock (lock) + /* Lock the CVSROOT/history file for write. + */ + int +-history_lock (xrepository) +- const char *xrepository; ++history_lock (const char *xrepository) + { + return internal_lock (&global_history_lock, xrepository); + } +@@ -1147,8 +1135,7 @@ clear_history_lock () + /* Lock the CVSROOT/val-tags file for write. + */ + int +-val_tags_lock (xrepository) +- const char *xrepository; ++val_tags_lock (const char *xrepository) + { + return internal_lock (&global_val_tags_lock, xrepository); + } +diff --git a/src/log.c b/src/log.c +index 1730874..0ff46a0 100644 +--- a/src/log.c ++++ b/src/log.c +@@ -189,9 +189,9 @@ static const char *const log_usage[] = + static int send_one PROTO ((Node *, void *)); + + static int +-send_one (node, closure) +- Node *node; +- void *closure; ++send_one ( ++ Node *node, ++ void *closure) + { + char *option = (char *) closure; + +@@ -213,9 +213,9 @@ send_one (node, closure) + static void send_arg_list PROTO ((char *, List *)); + + static void +-send_arg_list (option, arg) +- char *option; +- List *arg; ++send_arg_list ( ++ char *option, ++ List *arg) + { + if (arg == NULL) + return; +@@ -225,9 +225,9 @@ send_arg_list (option, arg) + #endif + + int +-cvslog (argc, argv) +- int argc; +- char **argv; ++cvslog ( ++ int argc, ++ char **argv) + { + int c; + int err = 0; +@@ -477,16 +477,16 @@ cvslog (argc, argv) + + + static int +-rlog_proc (argc, argv, xwhere, mwhere, mfile, shorten, local, mname, msg) +- int argc; +- char **argv; +- char *xwhere; +- char *mwhere; +- char *mfile; +- int shorten; +- int local; +- char *mname; +- char *msg; ++rlog_proc ( ++ int argc, ++ char **argv, ++ char *xwhere, ++ char *mwhere, ++ char *mfile, ++ int shorten, ++ int local, ++ char *mname, ++ char *msg) + { + /* Begin section which is identical to patch_proc--should this + be abstracted out somehow? */ +@@ -585,8 +585,7 @@ rlog_proc (argc, argv, xwhere, mwhere, mfile, shorten, local, mname, msg) + * Parse a revision list specification. + */ + static struct option_revlist * +-log_parse_revlist (argstring) +- const char *argstring; ++log_parse_revlist (const char *argstring) + { + char *orig_copy, *copy; + struct option_revlist *ret, **pr; +@@ -660,9 +659,9 @@ log_parse_revlist (argstring) + * Parse a date specification. + */ + static void +-log_parse_date (log_data, argstring) +- struct log_data *log_data; +- const char *argstring; ++log_parse_date ( ++ struct log_data *log_data, ++ const char *argstring) + { + char *orig_copy, *copy; + +@@ -757,9 +756,9 @@ log_parse_date (log_data, argstring) + * Parse a comma separated list of items, and add each one to *PLIST. + */ + static void +-log_parse_list (plist, argstring) +- List **plist; +- const char *argstring; ++log_parse_list ( ++ List **plist, ++ const char *argstring) + { + while (1) + { +@@ -796,9 +795,9 @@ log_parse_list (plist, argstring) + static int printlock_proc PROTO ((Node *, void *)); + + static int +-printlock_proc (lock, foo) +- Node *lock; +- void *foo; ++printlock_proc ( ++ Node *lock, ++ void *foo) + { + cvs_output ("\n\t", 2); + cvs_output (lock->data, 0); +@@ -813,9 +812,9 @@ printlock_proc (lock, foo) + * Do an rlog on a file + */ + static int +-log_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++log_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + struct log_data *log_data = (struct log_data *) callerdat; + Node *p; +@@ -1055,11 +1054,11 @@ log_fileproc (callerdat, finfo) + * Expand any symbolic revisions. + */ + static struct revlist * +-log_expand_revlist (rcs, baserev, revlist, default_branch) +- RCSNode *rcs; +- char *baserev; +- struct option_revlist *revlist; +- int default_branch; ++log_expand_revlist ( ++ RCSNode *rcs, ++ char *baserev, ++ struct option_revlist *revlist, ++ int default_branch) + { + struct option_revlist *r; + struct revlist *ret, **pr; +@@ -1315,8 +1314,7 @@ log_expand_revlist (rcs, baserev, revlist, default_branch) + * Free a revlist created by log_expand_revlist. + */ + static void +-log_free_revlist (revlist) +- struct revlist *revlist; ++log_free_revlist (struct revlist *revlist) + { + struct revlist *r; + +@@ -1340,11 +1338,11 @@ log_free_revlist (revlist) + * options provided. + */ + static int +-log_version_requested (log_data, revlist, rcs, vnode) +- struct log_data *log_data; +- struct revlist *revlist; +- RCSNode *rcs; +- RCSVers *vnode; ++log_version_requested ( ++ struct log_data *log_data, ++ struct revlist *revlist, ++ RCSNode *rcs, ++ RCSVers *vnode) + { + /* Handle the list of states from the -s option. */ + if (log_data->statelist != NULL +@@ -1443,9 +1441,9 @@ log_version_requested (log_data, revlist, rcs, vnode) + */ + /*ARGSUSED*/ + static int +-log_symbol (p, closure) +- Node *p; +- void *closure; ++log_symbol ( ++ Node *p, ++ void *closure) + { + cvs_output ("\n\t", 2); + cvs_output (p->key, 0); +@@ -1461,9 +1459,9 @@ log_symbol (p, closure) + */ + /*ARGSUSED*/ + static int +-log_count (p, closure) +- Node *p; +- void *closure; ++log_count ( ++ Node *p, ++ void *closure) + { + return 1; + } +@@ -1475,9 +1473,9 @@ log_count (p, closure) + * until we find the specific selected revision. + */ + static int +-log_fix_singledate (p, closure) +- Node *p; +- void *closure; ++log_fix_singledate ( ++ Node *p, ++ void *closure) + { + struct log_data_and_rcs *data = (struct log_data_and_rcs *) closure; + Node *pv; +@@ -1535,9 +1533,9 @@ log_fix_singledate (p, closure) + * Count the number of revisions we are going to print. + */ + static int +-log_count_print (p, closure) +- Node *p; +- void *closure; ++log_count_print ( ++ Node *p, ++ void *closure) + { + struct log_data_and_rcs *data = (struct log_data_and_rcs *) closure; + Node *pv; +@@ -1558,11 +1556,11 @@ log_count_print (p, closure) + * order for each branch. + */ + static void +-log_tree (log_data, revlist, rcs, ver) +- struct log_data *log_data; +- struct revlist *revlist; +- RCSNode *rcs; +- const char *ver; ++log_tree ( ++ struct log_data *log_data, ++ struct revlist *revlist, ++ RCSNode *rcs, ++ const char *ver) + { + Node *p; + RCSVers *vnode; +@@ -1594,11 +1592,11 @@ log_tree (log_data, revlist, rcs, ver) + * Log the changes for a branch, in reverse order. + */ + static void +-log_abranch (log_data, revlist, rcs, ver) +- struct log_data *log_data; +- struct revlist *revlist; +- RCSNode *rcs; +- const char *ver; ++log_abranch ( ++ struct log_data *log_data, ++ struct revlist *revlist, ++ RCSNode *rcs, ++ const char *ver) + { + Node *p; + RCSVers *vnode; +@@ -1617,12 +1615,12 @@ log_abranch (log_data, revlist, rcs, ver) + * Print the log output for a single version. + */ + static void +-log_version (log_data, revlist, rcs, ver, trunk) +- struct log_data *log_data; +- struct revlist *revlist; +- RCSNode *rcs; +- RCSVers *ver; +- int trunk; ++log_version ( ++ struct log_data *log_data, ++ struct revlist *revlist, ++ RCSNode *rcs, ++ RCSVers *ver, ++ int trunk) + { + Node *p; + int year, mon, mday, hour, min, sec; +@@ -1725,9 +1723,9 @@ log_version (log_data, revlist, rcs, ver, trunk) + */ + /*ARGSUSED*/ + static int +-log_branch (p, closure) +- Node *p; +- void *closure; ++log_branch ( ++ Node *p, ++ void *closure) + { + cvs_output (" ", 2); + if ((numdots (p->key) & 1) == 0) +@@ -1751,12 +1749,12 @@ log_branch (p, closure) + */ + /* ARGSUSED */ + static Dtype +-log_dirproc (callerdat, dir, repository, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repository; +- const char *update_dir; +- List *entries; ++log_dirproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + if (!isdir (dir)) + return (R_SKIP_ALL); +@@ -1770,10 +1768,10 @@ log_dirproc (callerdat, dir, repository, update_dir, entries) + * Compare versions. This is taken from RCS compartial. + */ + static int +-version_compare (v1, v2, len) +- const char *v1; +- const char *v2; +- int len; ++version_compare ( ++ const char *v1, ++ const char *v2, ++ int len) + { + while (1) + { +diff --git a/src/login.c b/src/login.c +index 75dc53a..1b1fce9 100644 +--- a/src/login.c ++++ b/src/login.c +@@ -102,11 +102,11 @@ construct_cvspass_filename () + * called on the same linebuf + */ + static char * +-password_entry_parseline (cvsroot_canonical, warn, linenumber, linebuf) +- const char *cvsroot_canonical; +- const unsigned char warn; +- const int linenumber; +- char *linebuf; ++password_entry_parseline ( ++ const char *cvsroot_canonical, ++ const unsigned char warn, ++ const int linenumber, ++ char *linebuf) + { + char *password = NULL; + char *p; +@@ -280,10 +280,10 @@ typedef enum password_entry_operation_e { + } password_entry_operation_t; + + static char * +-password_entry_operation (operation, root, newpassword) +- password_entry_operation_t operation; +- cvsroot_t *root; +- char *newpassword; ++password_entry_operation ( ++ password_entry_operation_t operation, ++ cvsroot_t *root, ++ char *newpassword) + { + char *passfile; + FILE *fp; +@@ -530,9 +530,9 @@ static const char *const login_usage[] = + }; + + int +-login (argc, argv) +- int argc; +- char **argv; ++login ( ++ int argc, ++ char **argv) + { + char *typed_password; + char *cvsroot_canonical; +@@ -660,9 +660,9 @@ static const char *const logout_usage[] = + + /* Remove any entry for the CVSRoot repository found in .cvspass. */ + int +-logout (argc, argv) +- int argc; +- char **argv; ++logout ( ++ int argc, ++ char **argv) + { + char *cvsroot_canonical; + +diff --git a/src/logmsg.c b/src/logmsg.c +index 0d54283..2133bc6 100644 +--- a/src/logmsg.c ++++ b/src/logmsg.c +@@ -53,10 +53,10 @@ static char *prefix; + static int col; + static char *tag; + static void +-setup_tmpfile (xfp, xprefix, changes) +- FILE *xfp; +- char *xprefix; +- List *changes; ++setup_tmpfile ( ++ FILE *xfp, ++ char *xprefix, ++ List *changes) + { + /* set up statics */ + fp = xfp; +@@ -107,9 +107,9 @@ setup_tmpfile (xfp, xprefix, changes) + * Looks for nodes of a specified type and returns 1 if found + */ + static int +-find_type (p, closure) +- Node *p; +- void *closure; ++find_type ( ++ Node *p, ++ void *closure) + { + struct logfile_info *li = p->data; + +@@ -125,9 +125,9 @@ find_type (p, closure) + * match the one we're looking for + */ + static int +-fmt_proc (p, closure) +- Node *p; +- void *closure; ++fmt_proc ( ++ Node *p, ++ void *closure) + { + struct logfile_info *li; + +@@ -187,11 +187,11 @@ fmt_proc (p, closure) + * NULL when running in client mode. + */ + void +-do_editor (dir, messagep, repository, changes) +- const char *dir; +- char **messagep; +- const char *repository; +- List *changes; ++do_editor ( ++ const char *dir, ++ char **messagep, ++ const char *repository, ++ List *changes) + { + static int reuse_log_message = 0; + char *line; +@@ -412,9 +412,9 @@ do_editor (dir, messagep, repository, changes) + independant of the running of an editor for getting a message. + */ + void +-do_verify (messagep, repository) +- char **messagep; +- const char *repository; ++do_verify ( ++ char **messagep, ++ const char *repository) + { + FILE *fp; + char *fname; +@@ -561,9 +561,9 @@ do_verify (messagep, repository) + */ + /* ARGSUSED */ + static int +-rcsinfo_proc (repository, template) +- const char *repository; +- const char *template; ++rcsinfo_proc ( ++ const char *repository, ++ const char *template) + { + static char *last_template; + FILE *tfp; +@@ -609,11 +609,11 @@ static const char *message; + static List *changes; + + void +-Update_Logfile (repository, xmessage, xlogfp, xchanges) +- const char *repository; +- const char *xmessage; +- FILE *xlogfp; +- List *xchanges; ++Update_Logfile ( ++ const char *repository, ++ const char *xmessage, ++ FILE *xlogfp, ++ List *xchanges) + { + /* nothing to do if the list is empty */ + if (xchanges == NULL || xchanges->list->next == xchanges->list) +@@ -634,9 +634,9 @@ Update_Logfile (repository, xmessage, xlogfp, xchanges) + * callback proc to actually do the logfile write from Update_Logfile + */ + static int +-update_logfile_proc (repository, filter) +- const char *repository; +- const char *filter; ++update_logfile_proc ( ++ const char *repository, ++ const char *filter) + { + return logfile_write (repository, filter, message, logfp, changes); + } +@@ -647,9 +647,9 @@ update_logfile_proc (repository, filter) + * concatenate each filename/version onto str_list + */ + static int +-title_proc (p, closure) +- Node *p; +- void *closure; ++title_proc ( ++ Node *p, ++ void *closure) + { + char *c; + struct logfile_info *li = p->data; +@@ -741,12 +741,12 @@ title_proc (p, closure) + * filter program. + */ + static int +-logfile_write (repository, filter, message, logfp, changes) +- const char *repository; +- const char *filter; +- const char *message; +- FILE *logfp; +- List *changes; ++logfile_write ( ++ const char *repository, ++ const char *filter, ++ const char *message, ++ FILE *logfp, ++ List *changes) + { + FILE *pipefp; + char *prog; +@@ -967,9 +967,9 @@ logfile_write (repository, filter, message, logfp, changes) + */ + /* ARGSUSED */ + static int +-editinfo_proc(repository, editor) +- const char *repository; +- const char *editor; ++editinfo_proc( ++ const char *repository, ++ const char *editor) + { + /* nothing to do if the last match is the same as this one */ + if (editinfo_editor && strcmp (editinfo_editor, editor) == 0) +@@ -985,9 +985,9 @@ editinfo_proc(repository, editor) + * message verification script to the global variable verify_script + */ + static int +-verifymsg_proc (repository, script) +- const char *repository; +- const char *script; ++verifymsg_proc ( ++ const char *repository, ++ const char *script) + { + if (verifymsg_script && strcmp (verifymsg_script, script) == 0) + return (0); +diff --git a/src/main.c b/src/main.c +index e7f0439..94ddc42 100644 +--- a/src/main.c ++++ b/src/main.c +@@ -24,7 +24,7 @@ + #ifdef HAVE_WINSOCK_H + #include + #else +-extern int gethostname (); ++extern int gethostname (char *name, size_t len); + #endif + + const char *program_name; +@@ -103,7 +103,7 @@ static const struct cmd + char *nick1; + char *nick2; + +- int (*func) (); /* Function takes (argc, argv) arguments. */ ++ int (*func) (int argc, char **argv); + unsigned long attr; /* Attributes. */ + } cmds[] = + +@@ -273,9 +273,9 @@ static const char *const opt_usage[] = + + + static int +-set_root_directory (p, ignored) +- Node *p; +- void *ignored; ++set_root_directory ( ++ Node *p, ++ void *ignored) + { + if (current_parsed_root == NULL && p->data != NULL) + { +@@ -326,8 +326,7 @@ cmd_synonyms () + + + unsigned long int +-lookup_command_attribute (cmd_name) +- char *cmd_name; ++lookup_command_attribute (char *cmd_name) + { + const struct cmd *cm; + +@@ -343,8 +342,7 @@ lookup_command_attribute (cmd_name) + + + static RETSIGTYPE +-main_cleanup (sig) +- int sig; ++main_cleanup (int sig) + { + #ifndef DONT_USE_SIGNALS + const char *name; +@@ -402,9 +400,9 @@ main_cleanup (sig) + } + + int +-main (argc, argv) +- int argc; +- char **argv; ++main ( ++ int argc, ++ char **argv) + { + cvsroot_t *CVSroot_parsed = NULL; + int cvsroot_update_env = 1; +@@ -1043,8 +1041,7 @@ distribution kit for a complete list of contributors and copyrights.\n", + } + + char * +-Make_Date (rawdate) +- char *rawdate; ++Make_Date (char *rawdate) + { + time_t unixtime; + +@@ -1064,8 +1061,7 @@ Make_Date (rawdate) + Returns a newly malloc'd string. */ + + char * +-date_from_time_t (unixtime) +- time_t unixtime; ++date_from_time_t (time_t unixtime) + { + struct tm *ftm; + char date[MAXDATELEN]; +@@ -1095,9 +1091,9 @@ date_from_time_t (unixtime) + The SOURCE date is in our internal RCS format. DEST should point to + storage managed by the caller, at least MAXDATELEN characters. */ + void +-date_to_internet (dest, source) +- char *dest; +- const char *source; ++date_to_internet ( ++ char *dest, ++ const char *source) + { + struct tm date; + +@@ -1106,9 +1102,9 @@ date_to_internet (dest, source) + } + + void +-date_to_tm (dest, source) +- struct tm *dest; +- const char *source; ++date_to_tm ( ++ struct tm *dest, ++ const char *source) + { + if (sscanf (source, SDATEFORM, + &dest->tm_year, &dest->tm_mon, &dest->tm_mday, +@@ -1133,9 +1129,9 @@ date_to_tm (dest, source) + The SOURCE date is a pointer to a struct tm. DEST should point to + storage managed by the caller, at least MAXDATELEN characters. */ + void +-tm_to_internet (dest, source) +- char *dest; +- const struct tm *source; ++tm_to_internet ( ++ char *dest, ++ const struct tm *source) + { + /* Just to reiterate, these strings are from RFC822 and do not vary + according to locale. */ +@@ -1149,8 +1145,7 @@ tm_to_internet (dest, source) + } + + void +-usage (cpp) +- register const char *const *cpp; ++usage (register const char *const *cpp) + { + (void) fprintf (stderr, *cpp++, program_name, cvs_cmd_name); + for (; *cpp; cpp++) +diff --git a/src/mkmodules.c b/src/mkmodules.c +index 3be9509..d90610a 100644 +--- a/src/mkmodules.c ++++ b/src/mkmodules.c +@@ -400,8 +400,7 @@ static const struct admin_file filelist[] = { + + /* Rebuild the checked out administrative files in directory DIR. */ + int +-mkmodules (dir) +- char *dir; ++mkmodules (char *dir) + { + struct saved_cwd cwd; + char *temp; +@@ -580,9 +579,9 @@ make_tempfile () + not a very clean convention). On success, return 0. */ + + static int +-checkout_file (file, temp) +- char *file; +- char *temp; ++checkout_file ( ++ char *file, ++ char *temp) + { + char *rcs; + RCSNode *rcsnode; +@@ -825,9 +824,9 @@ rename_dbmfile (temp) + #endif /* !MY_NDBM */ + + static void +-rename_rcsfile (temp, real) +- char *temp; +- char *real; ++rename_rcsfile ( ++ char *temp, ++ char *real) + { + char *bak; + struct stat statbuf; +@@ -907,9 +906,9 @@ const char *const init_usage[] = { + }; + + int +-init (argc, argv) +- int argc; +- char **argv; ++init ( ++ int argc, ++ char **argv) + { + /* Name of CVSROOT directory. */ + char *adm; +diff --git a/src/modules.c b/src/modules.c +index 5cbc2ec..d2bef44 100644 +--- a/src/modules.c ++++ b/src/modules.c +@@ -90,8 +90,7 @@ open_module () + * Close the modules file, if the open succeeded, that is + */ + void +-close_module (db) +- DBM *db; ++close_module (DBM *db) + { + if (db != NULL) + dbm_close (db); +@@ -105,21 +104,19 @@ close_module (db) + * It runs the post checkout or post tag proc from the modules file + */ + static int +-my_module (db, mname, m_type, msg, callback_proc, where, shorten, +- local_specified, run_module_prog, build_dirs, extra_arg, +- stack) +- DBM *db; +- char *mname; +- enum mtype m_type; +- char *msg; +- CALLBACKPROC callback_proc; +- char *where; +- int shorten; +- int local_specified; +- int run_module_prog; +- int build_dirs; +- char *extra_arg; +- List *stack; ++my_module ( ++ DBM *db, ++ char *mname, ++ enum mtype m_type, ++ char *msg, ++ CALLBACKPROC callback_proc, ++ char *where, ++ int shorten, ++ int local_specified, ++ int run_module_prog, ++ int build_dirs, ++ char *extra_arg, ++ List *stack) + { + char *checkout_prog = NULL; + char *export_prog = NULL; +@@ -779,19 +776,18 @@ module `%s' is a request for a file in a module which is not a directory", + * accepts a stack argument to track alias recursion. + */ + int +-do_module (db, mname, m_type, msg, callback_proc, where, shorten, +- local_specified, run_module_prog, build_dirs, extra_arg) +- DBM *db; +- char *mname; +- enum mtype m_type; +- char *msg; +- CALLBACKPROC callback_proc; +- char *where; +- int shorten; +- int local_specified; +- int run_module_prog; +- int build_dirs; +- char *extra_arg; ++do_module ( ++ DBM *db, ++ char *mname, ++ enum mtype m_type, ++ char *msg, ++ CALLBACKPROC callback_proc, ++ char *where, ++ int shorten, ++ int local_specified, ++ int run_module_prog, ++ int build_dirs, ++ char *extra_arg) + { + return my_module (db, mname, m_type, msg, callback_proc, where, shorten, + local_specified, run_module_prog, build_dirs, extra_arg, +@@ -841,9 +837,9 @@ static char def_status[] = "NONE"; + have to look further. + */ + static int +-sort_order (l, r) +- const PTR l; +- const PTR r; ++sort_order ( ++ const PTR l, ++ const PTR r) + { + int i; + const struct sortrec *left = (const struct sortrec *) l; +@@ -859,11 +855,11 @@ sort_order (l, r) + } + + static void +-save_d (k, ks, d, ds) +- char *k; +- int ks; +- char *d; +- int ds; ++save_d ( ++ char *k, ++ int ks, ++ char *d, ++ int ds) + { + char *cp, *cp2; + struct sortrec *s_rec; +@@ -946,8 +942,7 @@ save_d (k, ks, d, ds) + non-zero, print out status information for each module. */ + + void +-cat_module (status) +- int status; ++cat_module (int status) + { + DBM *db; + datum key, val; +diff --git a/src/myndbm.c b/src/myndbm.c +index 7b0ecb2..15c7ba6 100644 +--- a/src/myndbm.c ++++ b/src/myndbm.c +@@ -34,10 +34,10 @@ static void mydbm_load_file PROTO ((FILE *, List *, char *)); + the error. Can also call error() itself. */ + /* ARGSUSED */ + DBM * +-mydbm_open (file, flags, mode) +- char *file; +- int flags; +- int mode; ++mydbm_open ( ++ char *file, ++ int flags, ++ int mode) + { + FILE *fp; + DBM *db; +@@ -65,9 +65,9 @@ mydbm_open (file, flags, mode) + static int write_item PROTO ((Node *, void *)); + + static int +-write_item (node, data) +- Node *node; +- void *data; ++write_item ( ++ Node *node, ++ void *data) + { + FILE *fp = (FILE *)data; + fputs (node->key, fp); +@@ -78,8 +78,7 @@ write_item (node, data) + } + + void +-mydbm_close (db) +- DBM *db; ++mydbm_close (DBM *db) + { + if (db->modified) + { +@@ -98,9 +97,9 @@ mydbm_close (db) + } + + datum +-mydbm_fetch (db, key) +- DBM *db; +- datum key; ++mydbm_fetch ( ++ DBM *db, ++ datum key) + { + Node *p; + char *s; +@@ -127,8 +126,7 @@ mydbm_fetch (db, key) + } + + datum +-mydbm_firstkey (db) +- DBM *db; ++mydbm_firstkey (DBM *db) + { + Node *head, *p; + datum key; +@@ -150,8 +148,7 @@ mydbm_firstkey (db) + } + + datum +-mydbm_nextkey (db) +- DBM *db; ++mydbm_nextkey (DBM *db) + { + Node *head, *p; + datum key; +@@ -177,11 +174,11 @@ mydbm_nextkey (db) + it gives a warning, rather than either DBM_INSERT or DBM_REPLACE + behavior. */ + int +-mydbm_store (db, key, value, flags) +- DBM *db; +- datum key; +- datum value; +- int flags; ++mydbm_store ( ++ DBM *db, ++ datum key, ++ datum value, ++ int flags) + { + Node *node; + +@@ -207,10 +204,10 @@ mydbm_store (db, key, value, flags) + } + + static void +-mydbm_load_file (fp, list, filename) +- FILE *fp; +- List *list; +- char *filename; /* Used in error messages. */ ++mydbm_load_file ( ++ FILE *fp, ++ List *list, ++ char *filename /* Used in error messages. */) + { + char *line = NULL; + size_t line_size; +diff --git a/src/no_diff.c b/src/no_diff.c +index 45847a1..283f537 100644 +--- a/src/no_diff.c ++++ b/src/no_diff.c +@@ -23,9 +23,9 @@ + #include + + int +-No_Difference (finfo, vers) +- struct file_info *finfo; +- Vers_TS *vers; ++No_Difference ( ++ struct file_info *finfo, ++ Vers_TS *vers) + { + Node *p; + int ret; +diff --git a/src/parseinfo.c b/src/parseinfo.c +index 17c9a69..65a494e 100644 +--- a/src/parseinfo.c ++++ b/src/parseinfo.c +@@ -27,11 +27,11 @@ extern char *logHistory; + * Return 0 for success, -1 if there was not an INFOFILE, and >0 for failure. + */ + int +-Parse_Info (infofile, repository, callproc, all) +- const char *infofile; +- const char *repository; +- CALLPROC callproc; +- int all; ++Parse_Info ( ++ const char *infofile, ++ const char *repository, ++ CALLPROC callproc, ++ int all) + { + int err = 0; + FILE *fp_info; +@@ -234,8 +234,7 @@ Parse_Info (infofile, repository, callproc, all) + Returns 0 for success, negative value for failure. Call + error(0, ...) on errors in addition to the return value. */ + int +-parse_config (cvsroot) +- char *cvsroot; ++parse_config (char *cvsroot) + { + char *infopath; + FILE *fp_info; +diff --git a/src/patch.c b/src/patch.c +index 2d63f46..a5a67eb 100644 +--- a/src/patch.c ++++ b/src/patch.c +@@ -21,7 +21,7 @@ + #include "cvs.h" + #include "getline.h" + +-static RETSIGTYPE patch_cleanup PROTO((void)); ++static RETSIGTYPE patch_cleanup PROTO((int sig)); + static Dtype patch_dirproc PROTO ((void *callerdat, const char *dir, + const char *repos, const char *update_dir, + List *entries)); +@@ -67,9 +67,9 @@ static const char *const patch_usage[] = + + + int +-patch (argc, argv) +- int argc; +- char **argv; ++patch ( ++ int argc, ++ char **argv) + { + register int i; + int local = 0; +@@ -262,7 +262,7 @@ patch (argc, argv) + (char *)NULL, 0, local, 0, 0, (char *)NULL); + close_module (db); + free (options); +- patch_cleanup (); ++ patch_cleanup (0); + return err; + } + +@@ -273,17 +273,16 @@ patch (argc, argv) + */ + /* ARGSUSED */ + static int +-patch_proc (argc, argv, xwhere, mwhere, mfile, shorten, local_specified, +- mname, msg) +- int argc; +- char **argv; +- char *xwhere; +- char *mwhere; +- char *mfile; +- int shorten; +- int local_specified; +- char *mname; +- char *msg; ++patch_proc ( ++ int argc, ++ char **argv, ++ char *xwhere, ++ char *mwhere, ++ char *mfile, ++ int shorten, ++ int local_specified, ++ char *mname, ++ char *msg) + { + char *myargv[2]; + int err = 0; +@@ -383,9 +382,9 @@ patch_proc (argc, argv, xwhere, mwhere, mfile, shorten, local_specified, + */ + /* ARGSUSED */ + static int +-patch_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++patch_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + struct utimbuf t; + char *vers_tag, *vers_head; +@@ -800,12 +799,12 @@ failed to read diff file header %s for %s: end of file", tmpfile3, rcs); + */ + /* ARGSUSED */ + static Dtype +-patch_dirproc (callerdat, dir, repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repos; +- const char *update_dir; +- List *entries; ++patch_dirproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + if (!quiet) + error (0, 0, "Diffing %s", update_dir); +@@ -816,7 +815,7 @@ patch_dirproc (callerdat, dir, repos, update_dir, entries) + * Clean up temporary files + */ + static RETSIGTYPE +-patch_cleanup () ++patch_cleanup (int sig) + { + /* Note that the checks for existence_error are because we are + called from a signal handler, without SIG_begincrsect, so +diff --git a/src/rcs.c b/src/rcs.c +index 9edb598..6041ead 100644 +--- a/src/rcs.c ++++ b/src/rcs.c +@@ -223,10 +223,10 @@ static int rcs_lockfd = -1; + * parent. + */ + static char * +-locate_rcs (repository, file, inattic) +- const char *repository; +- const char *file; +- int *inattic; ++locate_rcs ( ++ const char *repository, ++ const char *file, ++ int *inattic) + { + char *retval; + +@@ -281,9 +281,9 @@ locate_rcs (repository, file, inattic) + sure this allows the caller to do anything reasonable, but it is + the current behavior). */ + RCSNode * +-RCS_parse (file, repos) +- const char *file; +- const char *repos; ++RCS_parse ( ++ const char *file, ++ const char *repos) + { + RCSNode *rcs; + FILE *fp; +@@ -326,8 +326,7 @@ RCS_parse (file, repos) + * Parse a specific rcsfile. + */ + RCSNode * +-RCS_parsercsfile (rcsfile) +- const char *rcsfile; ++RCS_parsercsfile (const char *rcsfile) + { + FILE *fp; + RCSNode *rcs; +@@ -354,9 +353,9 @@ RCS_parsercsfile (rcsfile) + /* + */ + static RCSNode * +-RCS_parsercsfile_i (fp, rcsfile) +- FILE *fp; +- const char *rcsfile; ++RCS_parsercsfile_i ( ++ FILE *fp, ++ const char *rcsfile) + { + RCSNode *rdata; + struct rcsbuffer rcsbuf; +@@ -453,10 +452,10 @@ l_error: + If PFP is NULL, close the file when done. Otherwise, leave it open + and store the FILE * in *PFP. */ + void +-RCS_reparsercsfile (rdata, pfp, rcsbufp) +- RCSNode *rdata; +- FILE **pfp; +- struct rcsbuffer *rcsbufp; ++RCS_reparsercsfile ( ++ RCSNode *rdata, ++ FILE **pfp, ++ struct rcsbuffer *rcsbufp) + { + FILE *fp; + char *rcsfile; +@@ -666,9 +665,9 @@ RCS_reparsercsfile (rdata, pfp, rcsbufp) + atomic, or that kind of thing). If there is an error, print a message + and return 1. On success, return 0. */ + int +-RCS_setattic (rcs, toattic) +- RCSNode *rcs; +- int toattic; ++RCS_setattic ( ++ RCSNode *rcs, ++ int toattic) + { + char *newpath; + const char *p; +@@ -764,8 +763,7 @@ RCS_setattic (rcs, toattic) + */ + + void +-RCS_fully_parse (rcs) +- RCSNode *rcs; ++RCS_fully_parse (RCSNode *rcs) + { + FILE *fp; + struct rcsbuffer rcsbuf; +@@ -921,8 +919,7 @@ warning: duplicate key `%s' in version `%s' of RCS file `%s'", + * freercsnode - free up the info for an RCSNode + */ + void +-freercsnode (rnodep) +- RCSNode **rnodep; ++freercsnode (RCSNode **rnodep) + { + if (rnodep == NULL || *rnodep == NULL) + return; +@@ -950,8 +947,7 @@ freercsnode (rnodep) + * after a call to RCS_parse. + */ + static void +-free_rcsnode_contents (rnode) +- RCSNode *rnode; ++free_rcsnode_contents (RCSNode *rnode) + { + dellist (&rnode->versions); + if (rnode->symbols != (List *) NULL) +@@ -981,8 +977,7 @@ free_rcsnode_contents (rnode) + that structure is freed elsewhere in the program. */ + + static void +-free_rcsvers_contents (rnode) +- RCSVers *rnode; ++free_rcsvers_contents (RCSVers *rnode) + { + if (rnode->branches != (List *) NULL) + dellist (&rnode->branches); +@@ -1007,8 +1002,7 @@ free_rcsvers_contents (rnode) + * rcsvers_delproc - free up an RCSVers type node + */ + static void +-rcsvers_delproc (p) +- Node *p; ++rcsvers_delproc (Node *p) + { + free_rcsvers_contents (p->data); + } +@@ -1035,11 +1029,11 @@ static int rcsbuf_inuse; + initializes RCSBUF. */ + + static void +-rcsbuf_open (rcsbuf, fp, filename, pos) +- struct rcsbuffer *rcsbuf; +- FILE *fp; +- const char *filename; +- unsigned long pos; ++rcsbuf_open ( ++ struct rcsbuffer *rcsbuf, ++ FILE *fp, ++ const char *filename, ++ unsigned long pos) + { + #ifdef HAVE_MMAP + void *p; +@@ -1104,8 +1098,7 @@ rcsbuf_open (rcsbuf, fp, filename, pos) + /* Stop gathering keys from an RCS file. */ + + static void +-rcsbuf_close (rcsbuf) +- struct rcsbuffer *rcsbuf; ++rcsbuf_close (struct rcsbuffer *rcsbuf) + { + if (! rcsbuf_inuse) + error (1, 0, "rcsbuf_close: internal error"); +@@ -1138,10 +1131,10 @@ rcsbuf_close (rcsbuf) + statistics show that it was worth it. */ + + static int +-rcsbuf_getkey (rcsbuf, keyp, valp) +- struct rcsbuffer *rcsbuf; +- char **keyp; +- char **valp; ++rcsbuf_getkey ( ++ struct rcsbuffer *rcsbuf, ++ char **keyp, ++ char **valp) + { + register const char * const my_spacetab = spacetab; + register char *ptr, *ptrend; +@@ -1516,9 +1509,9 @@ rcsbuf_getkey (rcsbuf, keyp, valp) + gives a fatal error. */ + + static int +-rcsbuf_getrevnum (rcsbuf, revp) +- struct rcsbuffer *rcsbuf; +- char **revp; ++rcsbuf_getrevnum ( ++ struct rcsbuffer *rcsbuf, ++ char **revp) + { + char *ptr, *ptrend; + char c; +@@ -1591,11 +1584,11 @@ unexpected '\\x%x' reading revision number in RCS file %s", + PTR, or NULL on error. */ + + static char * +-rcsbuf_fill (rcsbuf, ptr, keyp, valp) +- struct rcsbuffer *rcsbuf; +- char *ptr; +- char **keyp; +- char **valp; ++rcsbuf_fill ( ++ struct rcsbuffer *rcsbuf, ++ char *ptr, ++ char **keyp, ++ char **valp) + { + int got; + +@@ -1639,8 +1632,7 @@ rcsbuf_fill (rcsbuf, ptr, keyp, valp) + value or not. */ + + static int +-rcsbuf_valcmp (rcsbuf) +- struct rcsbuffer *rcsbuf; ++rcsbuf_valcmp (struct rcsbuffer *rcsbuf) + { + return rcsbuf->at_string && rcsbuf->embedded_at < 0; + } +@@ -1650,11 +1642,11 @@ rcsbuf_valcmp (rcsbuf) + rcsbuf_valpolish, q.v. */ + + static char * +-rcsbuf_valcopy (rcsbuf, val, polish, lenp) +- struct rcsbuffer *rcsbuf; +- char *val; +- int polish; +- size_t *lenp; ++rcsbuf_valcopy ( ++ struct rcsbuffer *rcsbuf, ++ char *val, ++ int polish, ++ size_t *lenp) + { + size_t vlen; + int embedded_at; +@@ -1694,11 +1686,11 @@ rcsbuf_valcopy (rcsbuf, val, polish, lenp) + POLISH. If LENP is not NULL, set *LENP to the length of the value. */ + + static void +-rcsbuf_valpolish (rcsbuf, val, polish, lenp) +- struct rcsbuffer *rcsbuf; +- char *val; +- int polish; +- size_t *lenp; ++rcsbuf_valpolish ( ++ struct rcsbuffer *rcsbuf, ++ char *val, ++ int polish, ++ size_t *lenp) + { + if (val == NULL) + { +@@ -1722,11 +1714,11 @@ rcsbuf_valpolish (rcsbuf, val, polish, lenp) + rcsbuf_valpolish. */ + + static void +-rcsbuf_valpolish_internal (rcsbuf, to, from, lenp) +- struct rcsbuffer *rcsbuf; +- char *to; +- const char *from; +- size_t *lenp; ++rcsbuf_valpolish_internal ( ++ struct rcsbuffer *rcsbuf, ++ char *to, ++ const char *from, ++ size_t *lenp) + { + size_t len; + +@@ -1840,9 +1832,9 @@ rcsbuf_valpolish_internal (rcsbuf, to, from, lenp) + NULL when there are no more words. */ + + static char * +-rcsbuf_valword (rcsbuf, valp) +- struct rcsbuffer *rcsbuf; +- char **valp; ++rcsbuf_valword ( ++ struct rcsbuffer *rcsbuf, ++ char **valp) + { + register const char * const my_spacetab = spacetab; + register char *ptr, *pat; +@@ -1942,8 +1934,7 @@ rcsbuf_valword (rcsbuf, valp) + /* Return the current position of an rcsbuf. */ + + static unsigned long +-rcsbuf_ftell (rcsbuf) +- struct rcsbuffer *rcsbuf; ++rcsbuf_ftell (struct rcsbuffer *rcsbuf) + { + return rcsbuf->pos + (rcsbuf->ptr - rcsbuf_buffer); + } +@@ -1952,10 +1943,10 @@ rcsbuf_ftell (rcsbuf) + length. */ + + static void +-rcsbuf_get_buffered (rcsbuf, datap, lenp) +- struct rcsbuffer *rcsbuf; +- char **datap; +- size_t *lenp; ++rcsbuf_get_buffered ( ++ struct rcsbuffer *rcsbuf, ++ char **datap, ++ size_t *lenp) + { + *datap = rcsbuf->ptr; + *lenp = rcsbuf->ptrend - rcsbuf->ptr; +@@ -1974,9 +1965,9 @@ static struct rcsbuffer cached_rcsbuf; + RCSBUF->FP. */ + + static void +-rcsbuf_cache (rcs, rcsbuf) +- RCSNode *rcs; +- struct rcsbuffer *rcsbuf; ++rcsbuf_cache ( ++ RCSNode *rcs, ++ struct rcsbuffer *rcsbuf) + { + if (cached_rcs != NULL) + rcsbuf_cache_close (); +@@ -2005,11 +1996,11 @@ rcsbuf_cache_close () + be put at position POS. */ + + static void +-rcsbuf_cache_open (rcs, pos, pfp, prcsbuf) +- RCSNode *rcs; +- long pos; +- FILE **pfp; +- struct rcsbuffer *prcsbuf; ++rcsbuf_cache_open ( ++ RCSNode *rcs, ++ long pos, ++ FILE **pfp, ++ struct rcsbuffer *prcsbuf) + { + if (cached_rcs == rcs && !cached_rcsbuf.mmapped) + { +@@ -2070,9 +2061,9 @@ rcsbuf_cache_open (rcs, pos, pfp, prcsbuf) + * process the symbols list of the rcs file + */ + static void +-do_symbols (list, val) +- List *list; +- char *val; ++do_symbols ( ++ List *list, ++ char *val) + { + Node *p; + char *cp = val; +@@ -2114,9 +2105,9 @@ do_symbols (list, val) + * an entry like `user:rev' is keyed on REV rather than on USER. + */ + static void +-do_locks (list, val) +- List *list; +- char *val; ++do_locks ( ++ List *list, ++ char *val) + { + Node *p; + char *cp = val; +@@ -2156,9 +2147,9 @@ do_locks (list, val) + * process the branches list of a revision delta + */ + static void +-do_branches (list, val) +- List *list; +- char *val; ++do_branches ( ++ List *list, ++ char *val) + { + Node *p; + char *cp = val; +@@ -2197,12 +2188,12 @@ do_branches (list, val) + * The result is returned; null-string if error. + */ + char * +-RCS_getversion (rcs, tag, date, force_tag_match, simple_tag) +- RCSNode *rcs; +- const char *tag; +- const char *date; +- int force_tag_match; +- int *simple_tag; ++RCS_getversion ( ++ RCSNode *rcs, ++ const char *tag, ++ const char *date, ++ int force_tag_match, ++ int *simple_tag) + { + if (simple_tag != NULL) + *simple_tag = 0; +@@ -2255,9 +2246,9 @@ RCS_getversion (rcs, tag, date, force_tag_match, simple_tag) + * return NULL. + */ + char * +-RCS_tag2rev (rcs, tag) +- RCSNode *rcs; +- char *tag; ++RCS_tag2rev ( ++ RCSNode *rcs, ++ char *tag) + { + char *rev, *pa, *pb; + int i; +@@ -2352,11 +2343,11 @@ RCS_tag2rev (rcs, tag) + * Returns pointer to newly malloc'd string, or NULL. + */ + char * +-RCS_gettag (rcs, symtag, force_tag_match, simple_tag) +- RCSNode *rcs; +- const char *symtag; +- int force_tag_match; +- int *simple_tag; ++RCS_gettag ( ++ RCSNode *rcs, ++ const char *symtag, ++ int force_tag_match, ++ int *simple_tag) + { + char *tag; + +@@ -2513,9 +2504,9 @@ RCS_gettag (rcs, symtag, force_tag_match, simple_tag) + */ + static char *check_rev; + char * +-RCS_magicrev (rcs, rev) +- RCSNode *rcs; +- char *rev; ++RCS_magicrev ( ++ RCSNode *rcs, ++ char *rev) + { + int rev_num; + char *xrev, *test_branch; +@@ -2552,9 +2543,9 @@ RCS_magicrev (rcs, rev) + * Returns 0 if the symbol does not match, 1 if it does. + */ + static int +-checkmagic_proc (p, closure) +- Node *p; +- void *closure; ++checkmagic_proc ( ++ Node *p, ++ void *closure) + { + if (STREQ (check_rev, p->data)) + return (1); +@@ -2570,9 +2561,9 @@ checkmagic_proc (p, closure) + * case for handling a null rcsnode. + */ + int +-RCS_isbranch (rcs, rev) +- RCSNode *rcs; +- const char *rev; ++RCS_isbranch ( ++ RCSNode *rcs, ++ const char *rev) + { + /* numeric revisions are easy -- even number of dots is a branch */ + if (isdigit ((unsigned char) *rev)) +@@ -2592,9 +2583,9 @@ RCS_isbranch (rcs, rev) + * take into account any magic branches as well. + */ + int +-RCS_nodeisbranch (rcs, rev) +- RCSNode *rcs; +- const char *rev; ++RCS_nodeisbranch ( ++ RCSNode *rcs, ++ const char *rev) + { + int dots; + char *version; +@@ -2644,9 +2635,9 @@ RCS_nodeisbranch (rcs, rev) + * for the specified *symbolic* tag. Magic branches are handled correctly. + */ + char * +-RCS_whatbranch (rcs, rev) +- RCSNode *rcs; +- const char *rev; ++RCS_whatbranch ( ++ RCSNode *rcs, ++ const char *rev) + { + char *version; + int dots; +@@ -2695,10 +2686,10 @@ RCS_whatbranch (rcs, rev) + * Returns NULL or a newly malloc'd string. + */ + char * +-RCS_getbranch (rcs, tag, force_tag_match) +- RCSNode *rcs; +- const char *tag; +- int force_tag_match; ++RCS_getbranch ( ++ RCSNode *rcs, ++ const char *tag, ++ int force_tag_match) + { + Node *p, *head; + RCSVers *vn; +@@ -2816,9 +2807,9 @@ RCS_getbranch (rcs, tag, force_tag_match) + isn't found. */ + + char * +-RCS_branch_head (rcs, rev) +- RCSNode *rcs; +- char *rev; ++RCS_branch_head ( ++ RCSNode *rcs, ++ char *rev) + { + char *num; + char *br; +@@ -2857,9 +2848,9 @@ RCS_branch_head (rcs, rev) + Return NULL on error. */ + + static char * +-RCS_getbranchpoint (rcs, target) +- RCSNode *rcs; +- char *target; ++RCS_getbranchpoint ( ++ RCSNode *rcs, ++ char *target) + { + char *branch, *bp; + Node *vp; +@@ -2929,8 +2920,7 @@ RCS_getbranchpoint (rcs, target) + * Returns NULL or a newly malloc'd string. + */ + char * +-RCS_head (rcs) +- RCSNode *rcs; ++RCS_head (RCSNode *rcs) + { + /* make sure we have something to look at... */ + assert (rcs != NULL); +@@ -2950,10 +2940,10 @@ RCS_head (rcs) + * funky stuff and follow the vendor branch maybe + */ + char * +-RCS_getdate (rcs, date, force_tag_match) +- RCSNode *rcs; +- const char *date; +- int force_tag_match; ++RCS_getdate ( ++ RCSNode *rcs, ++ const char *date, ++ int force_tag_match) + { + char *cur_rev = NULL; + char *retval = NULL; +@@ -3056,10 +3046,10 @@ RCS_getdate (rcs, date, force_tag_match) + * date (return the rev or NULL) + */ + static char * +-RCS_getdatebranch (rcs, date, branch) +- RCSNode *rcs; +- const char *date; +- const char *branch; ++RCS_getdatebranch ( ++ RCSNode *rcs, ++ const char *date, ++ const char *branch) + { + char *cur_rev = NULL; + char *cp; +@@ -3143,8 +3133,7 @@ RCS_getdatebranch (rcs, date, branch) + * 2000, when years go from 2-digit to full format. + */ + int +-RCS_datecmp (date1, date2) +- const char *date1, *date2; ++RCS_datecmp (const char *date1, const char *date2) + { + int length_diff = strlen (date1) - strlen (date2); + +@@ -3165,11 +3154,11 @@ RCS_datecmp (date1, date2) + then it must point to MAXDATELEN characters, and we store the same + return value there in DATEFORM format. */ + time_t +-RCS_getrevtime (rcs, rev, date, fudge) +- RCSNode *rcs; +- const char *rev; +- char *date; +- int fudge; ++RCS_getrevtime ( ++ RCSNode *rcs, ++ const char *rev, ++ char *date, ++ int fudge) + { + char tdate[MAXDATELEN]; + struct tm xtm, *ftm; +@@ -3230,8 +3219,7 @@ RCS_getrevtime (rcs, rev, date, fudge) + } + + List * +-RCS_getlocks (rcs) +- RCSNode *rcs; ++RCS_getlocks (RCSNode *rcs) + { + assert(rcs != NULL); + +@@ -3249,8 +3237,7 @@ RCS_getlocks (rcs) + } + + List * +-RCS_symbols(rcs) +- RCSNode *rcs; ++RCS_symbols(RCSNode *rcs) + { + assert(rcs != NULL); + +@@ -3272,9 +3259,9 @@ RCS_symbols(rcs) + * Returns NULL or a newly malloc'd string. + */ + static char * +-translate_symtag (rcs, tag) +- RCSNode *rcs; +- const char *tag; ++translate_symtag ( ++ RCSNode *rcs, ++ const char *tag) + { + if (rcs->flags & PARTIAL) + RCS_reparsercsfile (rcs, (FILE **) NULL, (struct rcsbuffer *) NULL); +@@ -3348,8 +3335,7 @@ translate_symtag (rcs, tag) + * directly in calls to RCS V5, with the -k flag munged correctly. + */ + char * +-RCS_check_kflag (arg) +- const char *arg; ++RCS_check_kflag (const char *arg) + { + static const char *const keyword_usage[] = + { +@@ -3391,8 +3377,7 @@ RCS_check_kflag (arg) + * pretty close to what RCS checks, though I don't know for certain. + */ + void +-RCS_check_tag (tag) +- const char *tag; ++RCS_check_tag (const char *tag) + { + char *invalid = "$,.:;@/"; /* invalid RCS tag characters */ + const char *cp; +@@ -3428,8 +3413,7 @@ RCS_check_tag (tag) + * call error. + */ + int +-RCS_valid_rev (rev) +- char *rev; ++RCS_valid_rev (char *rev) + { + char last, c; + last = *rev++; +@@ -3456,9 +3440,9 @@ RCS_valid_rev (rev) + * Return true if RCS revision with TAG is a dead revision. + */ + int +-RCS_isdead (rcs, tag) +- RCSNode *rcs; +- const char *tag; ++RCS_isdead ( ++ RCSNode *rcs, ++ const char *tag) + { + Node *p; + RCSVers *version; +@@ -3482,8 +3466,7 @@ RCS_isdead (rcs, tag) + storage. Returns NULL if the RCS file does not specify a keyword + expansion mode; for all other errors, die with a fatal error. */ + char * +-RCS_getexpand (rcs) +- RCSNode *rcs; ++RCS_getexpand (RCSNode *rcs) + { + /* Since RCS_parsercsfile_i now reads expand, don't need to worry + about RCS_reparsercsfile. */ +@@ -3493,9 +3476,9 @@ RCS_getexpand (rcs) + + /* Set keyword expansion mode to EXPAND. For example "b" for binary. */ + void +-RCS_setexpand (rcs, expand) +- RCSNode *rcs; +- const char *expand; ++RCS_setexpand ( ++ RCSNode *rcs, ++ const char *expand) + { + /* Since RCS_parsercsfile_i now reads expand, don't need to worry + about RCS_reparsercsfile. */ +@@ -3547,8 +3530,7 @@ enum keyword + the RCS date2str function. */ + + static char * +-printable_date (rcs_date) +- const char *rcs_date; ++printable_date (const char *rcs_date) + { + int year, mon, mday, hour, min, sec; + char buf[100]; +@@ -3566,9 +3548,9 @@ printable_date (rcs_date) + RCS value. */ + + static char * +-escape_keyword_value (value, free_value) +- const char *value; +- int *free_value; ++escape_keyword_value ( ++ const char *value, ++ int *free_value) + { + char *ret, *t; + const char *s; +@@ -3645,17 +3627,17 @@ escape_keyword_value (value, free_value) + RETBUF is a newly allocated buffer. */ + + static void +-expand_keywords (rcs, ver, name, log, loglen, expand, buf, len, retbuf, retlen) +- RCSNode *rcs; +- RCSVers *ver; +- const char *name; +- const char *log; +- size_t loglen; +- enum kflag expand; +- char *buf; +- size_t len; +- char **retbuf; +- size_t *retlen; ++expand_keywords ( ++ RCSNode *rcs, ++ RCSVers *ver, ++ const char *name, ++ const char *log, ++ size_t loglen, ++ enum kflag expand, ++ char *buf, ++ size_t len, ++ char **retbuf, ++ size_t *retlen) + { + struct expand_buffer + { +@@ -4134,15 +4116,15 @@ expand_keywords (rcs, ver, name, log, loglen, expand, buf, len, retbuf, retlen) + comments in RCS_checkin for some issues about this. -twp */ + + int +-RCS_checkout (rcs, workfile, rev, nametag, options, sout, pfn, callerdat) +- RCSNode *rcs; +- const char *workfile; +- const char *rev; +- const char *nametag; +- const char *options; +- const char *sout; +- RCSCHECKOUTPROC pfn; +- void *callerdat; ++RCS_checkout ( ++ RCSNode *rcs, ++ const char *workfile, ++ const char *rev, ++ const char *nametag, ++ const char *options, ++ const char *sout, ++ RCSCHECKOUTPROC pfn, ++ void *callerdat) + { + int free_rev = 0; + enum kflag expand; +@@ -4733,8 +4715,7 @@ static RCSVers *RCS_findlock_or_tip PROTO ((RCSNode *rcs)); + described above), return the tip of the default branch. */ + + static RCSVers * +-RCS_findlock_or_tip (rcs) +- RCSNode *rcs; ++RCS_findlock_or_tip (RCSNode *rcs) + { + char *user = getcaller(); + Node *lock, *p; +@@ -4804,8 +4785,7 @@ RCS_findlock_or_tip (rcs) + to but not including the final `.'. */ + + static char * +-truncate_revnum (r) +- const char *r; ++truncate_revnum (const char *r) + { + size_t len; + char *new_r; +@@ -4824,8 +4804,7 @@ truncate_revnum (r) + the NUL byte and return a pointer to that NUL byte. */ + + static char * +-truncate_revnum_in_place (r) +- char *r; ++truncate_revnum_in_place (char *r) + { + char *dot = strrchr (r, '.'); + assert (dot); +@@ -4841,9 +4820,9 @@ truncate_revnum_in_place (r) + ignoring differences in any component after the rightmost `.'. */ + + static int +-compare_truncated_revnums (r, s) +- char *r; +- char *s; ++compare_truncated_revnums ( ++ char *r, ++ char *s) + { + char *r_dot = truncate_revnum_in_place (r); + char *s_dot = truncate_revnum_in_place (s); +@@ -4867,8 +4846,7 @@ compare_truncated_revnums (r, s) + static char *max_rev PROTO ((const RCSVers *)); + + static char * +-max_rev (branchnode) +- const RCSVers *branchnode; ++max_rev (const RCSVers *branchnode) + { + Node *head; + Node *bp; +@@ -4900,9 +4878,9 @@ max_rev (branchnode) + Return the number of the tip node on the new branch. */ + + static char * +-RCS_addbranch (rcs, branch) +- RCSNode *rcs; +- const char *branch; ++RCS_addbranch ( ++ RCSNode *rcs, ++ const char *branch) + { + char *branchpoint, *newrevnum; + Node *nodep, *bp; +@@ -5029,13 +5007,13 @@ RCS_addbranch (rcs, branch) + or zero for success. */ + + int +-RCS_checkin (rcs, workfile_in, message, rev, citime, flags) +- RCSNode *rcs; +- const char *workfile_in; +- const char *message; +- const char *rev; +- time_t citime; +- int flags; ++RCS_checkin ( ++ RCSNode *rcs, ++ const char *workfile_in, ++ const char *message, ++ const char *rev, ++ time_t citime, ++ int flags) + { + RCSVers *delta, *commitpt; + Deltatext *dtext; +@@ -5678,13 +5656,13 @@ struct cmp_file_data + expansion options. Return 0 if the contents of the revision are + the same as the contents of the file, 1 if they are different. */ + int +-RCS_cmp_file (rcs, rev1, rev1_cache, rev2, options, filename) +- RCSNode *rcs; +- const char *rev1; +- char **rev1_cache; +- const char *rev2; +- const char *options; +- const char *filename; ++RCS_cmp_file ( ++ RCSNode *rcs, ++ const char *rev1, ++ char **rev1_cache, ++ const char *rev2, ++ const char *options, ++ const char *filename) + { + int binary; + +@@ -5795,10 +5773,10 @@ RCS_cmp_file (rcs, rev1, rev1_cache, rev2, options, filename) + #define CMP_BUF_SIZE (8 * 1024) + + static void +-cmp_file_buffer (callerdat, buffer, len) +- void *callerdat; +- const char *buffer; +- size_t len; ++cmp_file_buffer ( ++ void *callerdat, ++ const char *buffer, ++ size_t len) + { + struct cmp_file_data *data = (struct cmp_file_data *)callerdat; + char *filebuf; +@@ -5847,10 +5825,10 @@ cmp_file_buffer (callerdat, buffer, len) + error (and an error message has been printed), or zero for success. */ + + int +-RCS_settag (rcs, tag, rev) +- RCSNode *rcs; +- const char *tag; +- const char *rev; ++RCS_settag ( ++ RCSNode *rcs, ++ const char *tag, ++ const char *rev) + { + List *symbols; + Node *node; +@@ -5908,9 +5886,9 @@ RCS_settag (rcs, tag, rev) + either case, the tag will no longer be in RCS->SYMBOLS.) */ + + int +-RCS_deltag (rcs, tag) +- RCSNode *rcs; +- const char *tag; ++RCS_deltag ( ++ RCSNode *rcs, ++ const char *tag) + { + List *symbols; + Node *node; +@@ -5933,9 +5911,9 @@ RCS_deltag (rcs, tag) + /* Set the default branch of RCS to REV. */ + + int +-RCS_setbranch (rcs, rev) +- RCSNode *rcs; +- const char *rev; ++RCS_setbranch ( ++ RCSNode *rcs, ++ const char *rev) + { + if (rcs->flags & PARTIAL) + RCS_reparsercsfile (rcs, (FILE **) NULL, (struct rcsbuffer *) NULL); +@@ -5967,10 +5945,10 @@ RCS_setbranch (rcs, rev) + about. */ + + int +-RCS_lock (rcs, rev, lock_quiet) +- RCSNode *rcs; +- const char *rev; +- int lock_quiet; ++RCS_lock ( ++ RCSNode *rcs, ++ const char *rev, ++ int lock_quiet) + { + List *locks; + Node *p; +@@ -6061,10 +6039,10 @@ RCS_lock (rcs, rev, lock_quiet) + queries the user about whether or not to break the lock. */ + + int +-RCS_unlock (rcs, rev, unlock_quiet) +- RCSNode *rcs; +- char *rev; +- int unlock_quiet; ++RCS_unlock ( ++ RCSNode *rcs, ++ char *rev, ++ int unlock_quiet) + { + Node *lock; + List *locks; +@@ -6172,9 +6150,9 @@ RCS_unlock (rcs, rev, unlock_quiet) + FIXME-twp: check syntax of USER to make sure it's a valid id. */ + + void +-RCS_addaccess (rcs, user) +- RCSNode *rcs; +- char *user; ++RCS_addaccess ( ++ RCSNode *rcs, ++ char *user) + { + char *access, *a; + +@@ -6205,9 +6183,9 @@ RCS_addaccess (rcs, user) + /* Remove USER from the access list of RCS. */ + + void +-RCS_delaccess (rcs, user) +- RCSNode *rcs; +- char *user; ++RCS_delaccess ( ++ RCSNode *rcs, ++ char *user) + { + char *p, *s; + int ulen; +@@ -6246,8 +6224,7 @@ RCS_delaccess (rcs, user) + } + + char * +-RCS_getaccess (rcs) +- RCSNode *rcs; ++RCS_getaccess (RCSNode *rcs) + { + if (rcs->flags & PARTIAL) + RCS_reparsercsfile (rcs, (FILE **) NULL, (struct rcsbuffer *) NULL); +@@ -6260,9 +6237,9 @@ static int findtag PROTO ((Node *, void *)); + /* Return a nonzero value if the revision specified by ARG is found. */ + + static int +-findtag (node, arg) +- Node *node; +- void *arg; ++findtag ( ++ Node *node, ++ void *arg) + { + char *rev = (char *)arg; + +@@ -6277,9 +6254,9 @@ static int findmagictag PROTO ((Node *, void *)); + /* Return a nonzero value if a magic tag rooted at ARG is found. */ + + static int +-findmagictag (node, arg) +- Node *node; +- void *arg; ++findmagictag ( ++ Node *node, ++ void *arg) + { + char *rev = (char *)arg; + size_t len = strlen (rev); +@@ -6311,11 +6288,11 @@ findmagictag (node, arg) + point in ::tag2 and :tag2 is the same and likewise for end points. */ + + int +-RCS_delete_revs (rcs, tag1, tag2, inclusive) +- RCSNode *rcs; +- char *tag1; +- char *tag2; +- int inclusive; ++RCS_delete_revs ( ++ RCSNode *rcs, ++ char *tag1, ++ char *tag2, ++ int inclusive) + { + char *next; + Node *nodep; +@@ -6825,9 +6802,9 @@ RCS_delete_revs (rcs, tag1, tag2, inclusive) + * TRUE if there exists a symbolic tag "tag" in file. + */ + int +-RCS_exist_tag (rcs, tag) +- RCSNode *rcs; +- char *tag; ++RCS_exist_tag ( ++ RCSNode *rcs, ++ char *tag) + { + + assert (rcs != NULL); +@@ -6846,9 +6823,9 @@ RCS_exist_tag (rcs, tag) + * RCS_delete_revs, above. + */ + int +-RCS_exist_rev (rcs, rev) +- RCSNode *rcs; +- char *rev; ++RCS_exist_rev ( ++ RCSNode *rcs, ++ char *rev) + { + + assert (rcs != NULL); +@@ -6901,8 +6878,7 @@ static void linevector_init PROTO ((struct linevector *)); + + /* Initialize *VEC to be a linevector with no lines. */ + static void +-linevector_init (vec) +- struct linevector *vec; ++linevector_init (struct linevector *vec) + { + vec->lines_alloced = 0; + vec->nlines = 0; +@@ -6924,12 +6900,12 @@ static int linevector_add PROTO ((struct linevector *vec, const char *text, + the linevector (and freed by linevector_free). So the caller doesn't + need to keep TEXT around after the call to this function. */ + static int +-linevector_add (vec, text, len, vers, pos) +- struct linevector *vec; +- const char *text; +- size_t len; +- RCSVers *vers; +- unsigned int pos; ++linevector_add ( ++ struct linevector *vec, ++ const char *text, ++ size_t len, ++ RCSVers *vers, ++ unsigned int pos) + { + const char *textend; + unsigned int i; +@@ -7013,9 +6989,9 @@ static void linevector_copy PROTO ((struct linevector *, struct linevector *)); + + /* Copy FROM to TO, copying the vectors but not the lines pointed to. */ + static void +-linevector_copy (to, from) +- struct linevector *to; +- struct linevector *from; ++linevector_copy ( ++ struct linevector *to, ++ struct linevector *from) + { + unsigned int ln; + +@@ -7044,8 +7020,7 @@ static void linevector_free PROTO ((struct linevector *)); + + /* Free storage associated with linevector. */ + static void +-linevector_free (vec) +- struct linevector *vec; ++linevector_free (struct linevector *vec) + { + unsigned int ln; + +@@ -7068,8 +7043,7 @@ static char *month_printname PROTO ((char *)); + example in rfc822 mail messages) which should be widely understood. + Returns a pointer into static readonly storage. */ + static char * +-month_printname (month) +- char *month; ++month_printname (char *month) + { + static const char *const months[] = + {"Jan", "Feb", "Mar", "Apr", "May", "Jun", +@@ -7106,13 +7080,13 @@ apply_rcs_changes PROTO ((struct linevector *, const char *, size_t, + * program to exit. + */ + static int +-apply_rcs_changes (orig_lines, diffbuf, difflen, name, addvers, delvers) +- struct linevector *orig_lines; +- const char *diffbuf; +- size_t difflen; +- const char *name; +- RCSVers *addvers; +- RCSVers *delvers; ++apply_rcs_changes ( ++ struct linevector *orig_lines, ++ const char *diffbuf, ++ size_t difflen, ++ const char *name, ++ RCSVers *addvers, ++ RCSVers *delvers) + { + const char *p; + const char *q; +@@ -7367,14 +7341,14 @@ apply_rcs_changes (orig_lines, diffbuf, difflen, name, addvers, delvers) + Return 1 for success. On failure, call error and return 0. */ + + int +-rcs_change_text (name, textbuf, textlen, diffbuf, difflen, retbuf, retlen) +- const char *name; +- char *textbuf; +- size_t textlen; +- const char *diffbuf; +- size_t difflen; +- char **retbuf; +- size_t *retlen; ++rcs_change_text ( ++ const char *name, ++ char *textbuf, ++ size_t textlen, ++ const char *diffbuf, ++ size_t difflen, ++ char **retbuf, ++ size_t *retlen) + { + struct linevector lines; + int ret; +@@ -7444,16 +7418,16 @@ rcs_change_text (name, textbuf, textlen, diffbuf, difflen, retbuf, retlen) + On error, give a fatal error. */ + + void +-RCS_deltas (rcs, fp, rcsbuf, version, op, text, len, log, loglen) +- RCSNode *rcs; +- FILE *fp; +- struct rcsbuffer *rcsbuf; +- const char *version; +- enum rcs_delta_op op; +- char **text; +- size_t *len; +- char **log; +- size_t *loglen; ++RCS_deltas ( ++ RCSNode *rcs, ++ FILE *fp, ++ struct rcsbuffer *rcsbuf, ++ const char *version, ++ enum rcs_delta_op op, ++ char **text, ++ size_t *len, ++ char **log, ++ size_t *loglen) + { + struct rcsbuffer rcsbuf_local; + char *branchversion; +@@ -7788,11 +7762,11 @@ RCS_deltas (rcs, fp, rcsbuf, version, op, text, len, log, loglen) + terminated the read in *KEYP and *VALP. */ + + static RCSVers * +-getdelta (rcsbuf, rcsfile, keyp, valp) +- struct rcsbuffer *rcsbuf; +- char *rcsfile; +- char **keyp; +- char **valp; ++getdelta ( ++ struct rcsbuffer *rcsbuf, ++ char *rcsfile, ++ char **keyp, ++ char **valp) + { + RCSVers *vnode; + char *key, *value, *cp; +@@ -7992,8 +7966,7 @@ unable to parse %s; `state' not in the expected place", rcsfile); + } + + static void +-freedeltatext (d) +- Deltatext *d; ++freedeltatext (Deltatext *d) + { + if (d->version != NULL) + free (d->version); +@@ -8007,10 +7980,10 @@ freedeltatext (d) + } + + static Deltatext * +-RCS_getdeltatext (rcs, fp, rcsbuf) +- RCSNode *rcs; +- FILE *fp; +- struct rcsbuffer *rcsbuf; ++RCS_getdeltatext ( ++ RCSNode *rcs, ++ FILE *fp, ++ struct rcsbuffer *rcsbuf) + { + char *num; + char *key, *value; +@@ -8085,9 +8058,9 @@ RCS_getdeltatext (rcs, fp, rcsbuf) + not get corrupted. */ + + static int +-putsymbol_proc (symnode, fparg) +- Node *symnode; +- void *fparg; ++putsymbol_proc ( ++ Node *symnode, ++ void *fparg) + { + FILE *fp = (FILE *) fparg; + +@@ -8109,17 +8082,17 @@ static int putlock_proc PROTO ((Node *, void *)); + /* putlock_proc is like putsymbol_proc, but key and data are reversed. */ + + static int +-putlock_proc (symnode, fp) +- Node *symnode; +- void *fp; ++putlock_proc ( ++ Node *symnode, ++ void *fp) + { + return fprintf ((FILE *) fp, "\n\t%s:%s", (char *)symnode->data, symnode->key); + } + + static int +-putrcsfield_proc (node, vfp) +- Node *node; +- void *vfp; ++putrcsfield_proc ( ++ Node *node, ++ void *vfp) + { + FILE *fp = (FILE *) vfp; + +@@ -8170,9 +8143,9 @@ putrcsfield_proc (node, vfp) + @-escape it. */ + + static int +-puthardlink_proc (node, vfp) +- Node *node; +- void *vfp; ++puthardlink_proc ( ++ Node *node, ++ void *vfp) + { + FILE *fp = (FILE *) vfp; + char *basename = strrchr (node->key, '/'); +@@ -8195,9 +8168,9 @@ puthardlink_proc (node, vfp) + /* Output the admin node for RCS into stream FP. */ + + static void +-RCS_putadmin (rcs, fp) +- RCSNode *rcs; +- FILE *fp; ++RCS_putadmin ( ++ RCSNode *rcs, ++ FILE *fp) + { + fprintf (fp, "%s\t%s;\n", RCSHEAD, rcs->head ? rcs->head : ""); + if (rcs->branch) +@@ -8250,9 +8223,9 @@ RCS_putadmin (rcs, fp) + } + + static void +-putdelta (vers, fp) +- RCSVers *vers; +- FILE *fp; ++putdelta ( ++ RCSVers *vers, ++ FILE *fp) + { + Node *bp, *start; + +@@ -8289,10 +8262,10 @@ putdelta (vers, fp) + } + + static void +-RCS_putdtree (rcs, rev, fp) +- RCSNode *rcs; +- char *rev; +- FILE *fp; ++RCS_putdtree ( ++ RCSNode *rcs, ++ char *rev, ++ FILE *fp) + { + RCSVers *versp; + Node *p, *branch; +@@ -8359,9 +8332,9 @@ RCS_putdtree (rcs, rev, fp) + } + + static void +-RCS_putdesc (rcs, fp) +- RCSNode *rcs; +- FILE *fp; ++RCS_putdesc ( ++ RCSNode *rcs, ++ FILE *fp) + { + fprintf (fp, "\n\n%s\n@", RCSDESC); + if (rcs->desc != NULL) +@@ -8378,9 +8351,9 @@ RCS_putdesc (rcs, fp) + } + + static void +-putdeltatext (fp, d) +- FILE *fp; +- Deltatext *d; ++putdeltatext ( ++ FILE *fp, ++ Deltatext *d) + { + fprintf (fp, "\n\n%s\nlog\n@", d->version); + if (d->log != NULL) +@@ -8411,13 +8384,13 @@ putdeltatext (fp, d) + increasing order.) */ + + static void +-RCS_copydeltas (rcs, fin, rcsbufin, fout, newdtext, insertpt) +- RCSNode *rcs; +- FILE *fin; +- struct rcsbuffer *rcsbufin; +- FILE *fout; +- Deltatext *newdtext; +- char *insertpt; ++RCS_copydeltas ( ++ RCSNode *rcs, ++ FILE *fin, ++ struct rcsbuffer *rcsbufin, ++ FILE *fout, ++ Deltatext *newdtext, ++ char *insertpt) + { + int actions; + RCSVers *dadmin; +@@ -8572,9 +8545,9 @@ RCS_copydeltas (rcs, fin, rcsbufin, fout, newdtext, insertpt) + is required. */ + + static int +-count_delta_actions (np, ignore) +- Node *np; +- void *ignore; ++count_delta_actions ( ++ Node *np, ++ void *ignore) + { + RCSVers *dadmin = np->data; + +@@ -8594,7 +8567,7 @@ count_delta_actions (np, ignore) + * Clean up temporary files + */ + RETSIGTYPE +-rcs_cleanup () ++rcs_cleanup (int sig) + { + /* Note that the checks for existence_error are because we are + called from a signal handler, so we don't know whether the +@@ -8658,8 +8631,7 @@ rcs_cleanup () + return a non-NULL value. */ + + static FILE * +-rcs_internal_lockfile (rcsfile) +- char *rcsfile; ++rcs_internal_lockfile (char *rcsfile) + { + struct stat rstat; + FILE *fp; +@@ -8742,9 +8714,9 @@ rcs_internal_lockfile (rcsfile) + } + + static void +-rcs_internal_unlockfile (fp, rcsfile) +- FILE *fp; +- char *rcsfile; ++rcs_internal_unlockfile ( ++ FILE *fp, ++ char *rcsfile) + { + assert (rcs_lockfile != NULL); + assert (rcs_lockfd >= 0); +@@ -8800,8 +8772,7 @@ rcs_internal_unlockfile (fp, rcsfile) + } + + static char * +-rcs_lockfilename (rcsfile) +- const char *rcsfile; ++rcs_lockfilename (const char *rcsfile) + { + char *lockfile, *lockp; + const char *rcsbase, *rcsp, *rcsend; +@@ -8828,10 +8799,10 @@ rcs_lockfilename (rcsfile) + desired (via RCS_delete_revs, RCS_settag, &c), then call RCS_rewrite. */ + + void +-RCS_rewrite (rcs, newdtext, insertpt) +- RCSNode *rcs; +- Deltatext *newdtext; +- char *insertpt; ++RCS_rewrite ( ++ RCSNode *rcs, ++ Deltatext *newdtext, ++ char *insertpt) + { + FILE *fin, *fout; + struct rcsbuffer rcsbufin; +@@ -8884,8 +8855,7 @@ RCS_rewrite (rcs, newdtext, insertpt) + /* Abandon changes to an RCS file. */ + + void +-RCS_abandon (rcs) +- RCSNode *rcs; ++RCS_abandon (RCSNode *rcs) + { + free_rcsnode_contents (rcs); + rcs->symbols_data = NULL; +@@ -8913,10 +8883,10 @@ RCS_abandon (rcs) + * /dev/null to be parsed by patch properly. + */ + char * +-make_file_label (path, rev, rcs) +- const char *path; +- const char *rev; +- RCSNode *rcs; ++make_file_label ( ++ const char *path, ++ const char *rev, ++ RCSNode *rcs) + { + char datebuf[MAXDATELEN + 1]; + char *label; +diff --git a/src/rcs.h b/src/rcs.h +index 2126029..46c98a0 100644 +--- a/src/rcs.h ++++ b/src/rcs.h +@@ -242,7 +242,7 @@ int RCS_delete_revs PROTO ((RCSNode *, char *, char *, int)); + void RCS_addaccess PROTO ((RCSNode *, char *)); + void RCS_delaccess PROTO ((RCSNode *, char *)); + char *RCS_getaccess PROTO ((RCSNode *)); +-RETSIGTYPE rcs_cleanup PROTO ((void)); ++RETSIGTYPE rcs_cleanup PROTO ((int sig)); + void RCS_rewrite PROTO ((RCSNode *, Deltatext *, char *)); + void RCS_abandon PROTO ((RCSNode *)); + int rcs_change_text PROTO ((const char *, char *, size_t, const char *, +diff --git a/src/rcscmds.c b/src/rcscmds.c +index 8617216..87674e1 100644 +--- a/src/rcscmds.c ++++ b/src/rcscmds.c +@@ -92,8 +92,7 @@ static void call_diff_error PROTO((const char *, const char *, const char *)); + + + static void +-call_diff_add_arg (s) +- const char *s; ++call_diff_add_arg (const char *s) + { + run_add_arg_p (&call_diff_argc, &call_diff_argc_allocated, &call_diff_argv, + s); +@@ -103,10 +102,10 @@ call_diff_add_arg (s) + + /* VARARGS */ + static void +-call_diff_setup (prog, argc, argv) +- const char *prog; +- int argc; +- char * const *argv; ++call_diff_setup ( ++ const char *prog, ++ int argc, ++ char * const *argv) + { + int i; + +@@ -125,9 +124,9 @@ call_diff_setup (prog, argc, argv) + file. This is used when we are producing output to stdout. */ + + static void +-call_diff_write_output (text, len) +- const char *text; +- size_t len; ++call_diff_write_output ( ++ const char *text, ++ size_t len) + { + if (len > 0) + cvs_output (text, len); +@@ -145,8 +144,7 @@ call_diff_flush_output () + /* Call back function for the diff library to write to stdout. */ + + static void +-call_diff_write_stdout (text) +- const char *text; ++call_diff_write_stdout (const char *text) + { + cvs_output (text, 0); + } +@@ -154,10 +152,10 @@ call_diff_write_stdout (text) + /* Call back function for the diff library to write to stderr. */ + + static void +-call_diff_error (format, a1, a2) +- const char *format; +- const char *a1; +- const char *a2; ++call_diff_error ( ++ const char *format, ++ const char *a1, ++ const char *a2) + { + /* FIXME: Should we somehow indicate that this error is coming from + the diff library? */ +@@ -189,8 +187,7 @@ static struct diff_callbacks call_diff_file_callbacks = + + + static int +-call_diff (out) +- const char *out; ++call_diff (const char *out) + { + call_diff_add_arg (NULL); + +@@ -205,8 +202,7 @@ call_diff (out) + + + static int +-call_diff3 (out) +- char *out; ++call_diff3 (char *out) + { + if (out == RUN_TTY) + return diff3_run (call_diff_argc, call_diff_argv, NULL, +@@ -221,13 +217,13 @@ call_diff3 (out) + /* Merge revisions REV1 and REV2. */ + + int +-RCS_merge(rcs, path, workfile, options, rev1, rev2) +- RCSNode *rcs; +- const char *path; +- const char *workfile; +- const char *options; +- const char *rev1; +- const char *rev2; ++RCS_merge( ++ RCSNode *rcs, ++ const char *path, ++ const char *workfile, ++ const char *options, ++ const char *rev1, ++ const char *rev2) + { + char *xrev1, *xrev2; + char *tmp1, *tmp2; +@@ -366,18 +362,17 @@ RCS_merge(rcs, path, workfile, options, rev1, rev2) + about this--any such features are undocumented in the context of + CVS, and I'm not sure how important to users. */ + int +-RCS_exec_rcsdiff (rcsfile, diff_argc, diff_argv, options, rev1, rev1_cache, +- rev2, label1, label2, workfile) +- RCSNode *rcsfile; +- int diff_argc; +- char * const *diff_argv; +- const char *options; +- const char *rev1; +- const char *rev1_cache; +- const char *rev2; +- const char *label1; +- const char *label2; +- const char *workfile; ++RCS_exec_rcsdiff ( ++ RCSNode *rcsfile, ++ int diff_argc, ++ char * const *diff_argv, ++ const char *options, ++ const char *rev1, ++ const char *rev1_cache, ++ const char *rev2, ++ const char *label1, ++ const char *label2, ++ const char *workfile) + { + char *tmpfile1 = NULL; + char *tmpfile2 = NULL; +@@ -531,14 +526,14 @@ RCS file: ", 0); + message on stderr. */ + + int +-diff_exec (file1, file2, label1, label2, dargc, dargv, out) +- const char *file1; +- const char *file2; +- const char *label1; +- const char *label2; +- int dargc; +- char * const *dargv; +- const char *out; ++diff_exec ( ++ const char *file1, ++ const char *file2, ++ const char *label1, ++ const char *label2, ++ int dargc, ++ char * const *dargv, ++ const char *out) + { + #ifdef PRESERVE_PERMISSIONS_SUPPORT + /* If either file1 or file2 are special files, pretend they are +@@ -593,12 +588,12 @@ diff_exec (file1, file2, label1, label2, dargc, dargv, out) + that I have seen. */ + + static void +-RCS_output_diff_options (diff_argc, diff_argv, rev1, rev2, workfile) +- int diff_argc; +- char * const *diff_argv; +- const char *rev1; +- const char *rev2; +- const char *workfile; ++RCS_output_diff_options ( ++ int diff_argc, ++ char * const *diff_argv, ++ const char *rev1, ++ const char *rev2, ++ const char *workfile) + { + int i; + +diff --git a/src/recurse.c b/src/recurse.c +index fb865a9..1452805 100644 +--- a/src/recurse.c ++++ b/src/recurse.c +@@ -73,18 +73,16 @@ struct frame_and_entries { + files on which we operate. In the special case of no arguments, we + default to ".". */ + int +-start_recursion (fileproc, filesdoneproc, direntproc, dirleaveproc, callerdat, +- argc, argv, local, which, aflag, locktype, +- update_preload, dosrcs, repository_in) +- FILEPROC fileproc; +- FILESDONEPROC filesdoneproc; +- DIRENTPROC direntproc; +- DIRLEAVEPROC dirleaveproc; +- void *callerdat; ++start_recursion ( ++ FILEPROC fileproc, ++ FILESDONEPROC filesdoneproc, ++ DIRENTPROC direntproc, ++ DIRLEAVEPROC dirleaveproc, ++ void *callerdat, + +- int argc; +- char **argv; +- int local; ++ int argc, ++ char **argv, ++ int local, + + /* This specifies the kind of recursion. There are several cases: + +@@ -107,12 +105,12 @@ start_recursion (fileproc, filesdoneproc, direntproc, dirleaveproc, callerdat, + does not exist in the working directory, the direntproc must + either tell us to skip it (R_SKIP_ALL), or must create it (I + think those are the only two cases). */ +- int which; ++ int which, + +- int aflag; +- int locktype; +- char *update_preload; +- int dosrcs; ++ int aflag, ++ int locktype, ++ char *update_preload, ++ int dosrcs, + /* Keep track of the repository string. This is only for the remote mode, + * specifically, r* commands (rtag, rdiff, co, ...) where xgetwd() was + * used to locate the repository. Things would break when xgetwd() was +@@ -121,7 +119,7 @@ start_recursion (fileproc, filesdoneproc, direntproc, dirleaveproc, callerdat, + * than the user specified in error messages and in other cases some of + * CVS's security assertions would fail. + */ +- char *repository_in; ++ char *repository_in) + { + int i, err = 0; + #ifdef CLIENT_SUPPORT +@@ -537,8 +535,7 @@ start_recursion (fileproc, filesdoneproc, direntproc, dirleaveproc, callerdat, + * called directly, or may be called by start_recursion + */ + static int +-do_recursion (frame) +- struct recursion_frame *frame; ++do_recursion (struct recursion_frame *frame) + { + int err = 0; + int dodoneproc = 1; +@@ -836,9 +833,9 @@ do_recursion (frame) + * Process each of the files in the list with the callback proc + */ + static int +-do_file_proc (p, closure) +- Node *p; +- void *closure; ++do_file_proc ( ++ Node *p, ++ void *closure) + { + struct frame_and_file *frfile = (struct frame_and_file *)closure; + struct file_info *finfo = frfile->finfo; +@@ -898,9 +895,9 @@ do_file_proc (p, closure) + * Process each of the directories in the list (recursing as we go) + */ + static int +-do_dir_proc (p, closure) +- Node *p; +- void *closure; ++do_dir_proc ( ++ Node *p, ++ void *closure) + { + struct frame_and_entries *frent = (struct frame_and_entries *) closure; + struct recursion_frame *frame = frent->frame; +@@ -1196,9 +1193,9 @@ but CVS uses %s for its own purposes; skipping %s directory", + * Add a node to a list allocating the list if necessary. + */ + static void +-addlist (listp, key) +- List **listp; +- char *key; ++addlist ( ++ List **listp, ++ char *key) + { + Node *p; + +@@ -1212,10 +1209,10 @@ addlist (listp, key) + } + + static void +-addfile (listp, dir, file) +- List **listp; +- char *dir; +- char *file; ++addfile ( ++ List **listp, ++ char *dir, ++ char *file) + { + Node *n; + List *fl; +@@ -1238,9 +1235,9 @@ addfile (listp, dir, file) + } + + static int +-unroll_files_proc (p, closure) +- Node *p; +- void *closure; ++unroll_files_proc ( ++ Node *p, ++ void *closure) + { + Node *n; + struct recursion_frame *frame = (struct recursion_frame *) closure; +diff --git a/src/release.c b/src/release.c +index 27a16c0..c53df19 100644 +--- a/src/release.c ++++ b/src/release.c +@@ -36,9 +36,9 @@ static int release_server PROTO ((int argc, char **argv)); + + /* This is the server side of cvs release. */ + static int +-release_server (argc, argv) +- int argc; +- char **argv; ++release_server ( ++ int argc, ++ char **argv) + { + int i; + +@@ -75,9 +75,9 @@ release_server (argc, argv) + and unnecessary. */ + + int +-release (argc, argv) +- int argc; +- char **argv; ++release ( ++ int argc, ++ char **argv) + { + FILE *fp; + int i, c; +diff --git a/src/remove.c b/src/remove.c +index a09cfd4..a5df3ed 100644 +--- a/src/remove.c ++++ b/src/remove.c +@@ -47,9 +47,9 @@ static const char *const remove_usage[] = + }; + + int +-cvsremove (argc, argv) +- int argc; +- char **argv; ++cvsremove ( ++ int argc, ++ char **argv) + { + int c, err; + +@@ -146,9 +146,9 @@ cvsremove (argc, argv) + + /*ARGSUSED*/ + static int +-remove_force_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++remove_force_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + if (CVS_UNLINK (finfo->file) < 0 && ! existence_error (errno)) + error (0, errno, "unable to remove %s", finfo->fullname); +@@ -162,9 +162,9 @@ remove_force_fileproc (callerdat, finfo) + */ + /* ARGSUSED */ + static int +-remove_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++remove_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + Vers_TS *vers; + +@@ -281,12 +281,12 @@ cannot remove file `%s' which has a sticky date of `%s'", + */ + /* ARGSUSED */ + static Dtype +-remove_dirproc (callerdat, dir, repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repos; +- const char *update_dir; +- List *entries; ++remove_dirproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + if (!quiet) + error (0, 0, "Removing %s", update_dir); +diff --git a/src/repos.c b/src/repos.c +index b444abb..f1d5b18 100644 +--- a/src/repos.c ++++ b/src/repos.c +@@ -25,9 +25,9 @@ + invoked. */ + + char * +-Name_Repository (dir, update_dir) +- const char *dir; +- const char *update_dir; ++Name_Repository ( ++ const char *dir, ++ const char *update_dir) + { + FILE *fpin; + const char *xupdate_dir; +@@ -148,8 +148,7 @@ Name_Repository (dir, update_dir) + * possibly fully qualified repository + */ + const char * +-Short_Repository (repository) +- const char *repository; ++Short_Repository (const char *repository) + { + if (repository == NULL) + return NULL; +@@ -193,8 +192,7 @@ Short_Repository (repository) + */ + + void +-Sanitize_Repository_Name (repository) +- char *repository; ++Sanitize_Repository_Name (char *repository) + { + size_t len; + +diff --git a/src/root.c b/src/root.c +index f377ebf..7b6a0cf 100644 +--- a/src/root.c ++++ b/src/root.c +@@ -29,9 +29,9 @@ const char method_names[][16] = { + #ifndef DEBUG + + cvsroot_t * +-Name_Root (dir, update_dir) +- const char *dir; +- const char *update_dir; ++Name_Root ( ++ const char *dir, ++ const char *update_dir) + { + FILE *fpin; + cvsroot_t *ret; +@@ -140,9 +140,9 @@ Name_Root (dir, update_dir) + * future work. + */ + void +-Create_Root (dir, rootdir) +- const char *dir; +- const char *rootdir; ++Create_Root ( ++ const char *dir, ++ const char *rootdir) + { + FILE *fout; + char *tmp; +@@ -189,8 +189,7 @@ root_allow_used () + } + + void +-root_allow_add (arg) +- char *arg; ++root_allow_add (char *arg) + { + char *p; + +@@ -237,8 +236,7 @@ root_allow_free () + } + + int +-root_allow_ok (arg) +- char *arg; ++root_allow_ok (char *arg) + { + int i; + +@@ -314,8 +312,7 @@ new_cvsroot_t () + + /* Dispose of a cvsroot_t and its component parts */ + void +-free_cvsroot_t (root) +- cvsroot_t *root; ++free_cvsroot_t (cvsroot_t *root) + { + if (root->original != NULL) + free (root->original); +@@ -364,8 +361,7 @@ free_cvsroot_t (root) + * free_cvsroot_t() + */ + cvsroot_t * +-parse_cvsroot (root_in) +- const char *root_in; ++parse_cvsroot (const char *root_in) + { + cvsroot_t *newroot; /* the new root to be returned */ + char *cvsroot_save; /* what we allocated so we can dispose +@@ -767,8 +763,7 @@ error_exit: + * caller to be responsible for our return value + */ + char * +-normalize_cvsroot (root) +- const cvsroot_t *root; ++normalize_cvsroot (const cvsroot_t *root) + { + char *cvsroot_canonical; + char *p, *hostname, *username; +@@ -811,8 +806,7 @@ normalize_cvsroot (root) + /* allocate and return a cvsroot_t structure set up as if we're using the local + * repository DIR. */ + cvsroot_t * +-local_cvsroot (dir) +- const char *dir; ++local_cvsroot (const char *dir) + { + cvsroot_t *newroot = new_cvsroot_t(); + +@@ -852,16 +846,15 @@ error_exit PROTO ((void)) + } + + int +-isabsolute (dir) +- const char *dir; ++isabsolute (const char *dir) + { + return (dir && (*dir == '/')); + } + + void +-main (argc, argv) +- int argc; +- char *argv[]; ++main ( ++ int argc, ++ char *argv[]) + { + program_name = argv[0]; + +diff --git a/src/run.c b/src/run.c +index 372b58b..446da2e 100644 +--- a/src/run.c ++++ b/src/run.c +@@ -20,7 +20,7 @@ extern int execvp PROTO((char *file, char **argv)); + + static void run_add_arg PROTO((const char *s)); + +-extern char *strtok (); ++extern char *strtok (char * str, const char * delim); + + /* + * To exec a program under CVS, first call run_setup() to setup initial +@@ -52,8 +52,7 @@ run_arg_free_p (int argc, char **argv) + + /* VARARGS */ + void +-run_setup (prog) +- const char *prog; ++run_setup (const char *prog) + { + char *cp; + char *run_prog; +@@ -71,8 +70,7 @@ run_setup (prog) + } + + void +-run_arg (s) +- const char *s; ++run_arg (const char *s) + { + run_add_arg (s); + } +@@ -80,11 +78,11 @@ run_arg (s) + + + void +-run_add_arg_p (iargc, iarg_allocated, iargv, s) +- int *iargc; +- size_t *iarg_allocated; +- char ***iargv; +- const char *s; ++run_add_arg_p ( ++ int *iargc, ++ size_t *iarg_allocated, ++ char ***iargv, ++ const char *s) + { + /* allocate more argv entries if we've run out */ + if (*iargc >= *iarg_allocated) +@@ -102,8 +100,7 @@ run_add_arg_p (iargc, iarg_allocated, iargv, s) + + + static void +-run_add_arg (s) +- const char *s; ++run_add_arg (const char *s) + { + run_add_arg_p (&run_argc, &run_argc_allocated, &run_argv, s); + } +@@ -111,11 +108,11 @@ run_add_arg (s) + + + int +-run_exec (stin, stout, sterr, flags) +- const char *stin; +- const char *stout; +- const char *sterr; +- int flags; ++run_exec ( ++ const char *stin, ++ const char *stout, ++ const char *sterr, ++ int flags) + { + int shin, shout, sherr; + int mode_out, mode_err; +@@ -436,8 +433,7 @@ wait_for_process: + + + void +-run_print (fp) +- FILE *fp; ++run_print (FILE *fp) + { + int i; + void (*outfn) PROTO ((const char *, size_t)); +@@ -471,9 +467,9 @@ run_print (fp) + case complicates this even aside from popen behavior). */ + + FILE * +-run_popen (cmd, mode) +- const char *cmd; +- const char *mode; ++run_popen ( ++ const char *cmd, ++ const char *mode) + { + if (trace) + (void) fprintf (stderr, "%s-> run_popen(%s,%s)\n", +@@ -580,11 +576,11 @@ work_around_openssh_glitch (void) + + + int +-piped_child (command, tofdp, fromfdp, fix_stderr) +- const char **command; +- int *tofdp; +- int *fromfdp; +- int fix_stderr; ++piped_child ( ++ const char **command, ++ int *tofdp, ++ int *fromfdp, ++ int fix_stderr) + { + int pid; + int to_child_pipe[2]; +@@ -635,8 +631,7 @@ piped_child (command, tofdp, fromfdp, fix_stderr) + + + void +-close_on_exec (fd) +- int fd; ++close_on_exec (int fd) + { + #ifdef F_SETFD + if (fcntl (fd, F_SETFD, 1) == -1) +diff --git a/src/scramble.c b/src/scramble.c +index 487cbf4..8109e06 100644 +--- a/src/scramble.c ++++ b/src/scramble.c +@@ -84,8 +84,7 @@ shifts[] = { + + /* Return a xmalloc'd, scrambled version of STR. */ + char * +-scramble (str) +- char *str; ++scramble (char *str) + { + int i; + char *s; +@@ -107,8 +106,7 @@ scramble (str) + + /* Decode the string in place. */ + char * +-descramble (str) +- char *str; ++descramble (char *str) + { + char *s; + int i; +diff --git a/src/server.c b/src/server.c +index 939e2a4..a63901a 100644 +--- a/src/server.c ++++ b/src/server.c +@@ -182,10 +182,10 @@ static int fd_buffer_shutdown PROTO((struct buffer *)); + occurs. */ + + static struct buffer * +-fd_buffer_initialize (fd, input, memory) +- int fd; +- int input; +- void (*memory) PROTO((struct buffer *)); ++fd_buffer_initialize ( ++ int fd, ++ int input, ++ void (*memory) PROTO((struct buffer *))) + { + struct fd_buffer *n; + +@@ -204,12 +204,12 @@ fd_buffer_initialize (fd, input, memory) + /* The buffer input function for a buffer built on a file descriptor. */ + + static int +-fd_buffer_input (closure, data, need, size, got) +- void *closure; +- char *data; +- int need; +- int size; +- int *got; ++fd_buffer_input ( ++ void *closure, ++ char *data, ++ int need, ++ int size, ++ int *got) + { + struct fd_buffer *fd = (struct fd_buffer *) closure; + int nbytes; +@@ -253,11 +253,11 @@ fd_buffer_input (closure, data, need, size, got) + /* The buffer output function for a buffer built on a file descriptor. */ + + static int +-fd_buffer_output (closure, data, have, wrote) +- void *closure; +- const char *data; +- int have; +- int *wrote; ++fd_buffer_output ( ++ void *closure, ++ const char *data, ++ int have, ++ int *wrote) + { + struct fd_buffer *fd = (struct fd_buffer *) closure; + +@@ -299,8 +299,7 @@ fd_buffer_output (closure, data, have, wrote) + + /*ARGSUSED*/ + static int +-fd_buffer_flush (closure) +- void *closure; ++fd_buffer_flush (void *closure) + { + /* Nothing to do. File descriptors are always flushed. */ + return 0; +@@ -309,9 +308,9 @@ fd_buffer_flush (closure) + /* The buffer block function for a buffer built on a file descriptor. */ + + static int +-fd_buffer_block (closure, block) +- void *closure; +- int block; ++fd_buffer_block ( ++ void *closure, ++ int block) + { + struct fd_buffer *fd = (struct fd_buffer *) closure; + int flags; +@@ -336,8 +335,7 @@ fd_buffer_block (closure, block) + /* The buffer shutdown function for a buffer built on a file descriptor. */ + + static int +-fd_buffer_shutdown (buf) +- struct buffer *buf; ++fd_buffer_shutdown (struct buffer *buf) + { + free (buf->closure); + buf->closure = NULL; +@@ -350,9 +348,9 @@ fd_buffer_shutdown (buf) + static int create_adm_p PROTO((char *, char *)); + + static int +-create_adm_p (base_dir, dir) +- char *base_dir; +- char *dir; ++create_adm_p ( ++ char *base_dir, ++ char *dir) + { + char *dir_where_cvsadm_lives, *dir_to_register, *p, *tmp; + int retval, done; +@@ -535,8 +533,7 @@ create_adm_p (base_dir, dir) + static int mkdir_p PROTO((char *)); + + static int +-mkdir_p (dir) +- char *dir; ++mkdir_p (char *dir) + { + char *p; + char *q = xmalloc (strlen (dir) + 1); +@@ -593,8 +590,7 @@ mkdir_p (dir) + * Must be called only in contexts where it is OK to send output. + */ + static void +-print_error (status) +- int status; ++print_error (int status) + { + char *msg; + char tmpstr[80]; +@@ -658,8 +654,7 @@ static int alloc_pending PROTO ((size_t size)); + /* Allocate SIZE bytes for pending_error_text and return nonzero + if we could do it. */ + static int +-alloc_pending (size) +- size_t size; ++alloc_pending (size_t size) + { + if (error_pending ()) + /* Probably alloc_pending callers will have already checked for +@@ -680,8 +675,7 @@ static void serve_is_modified PROTO ((char *)); + static int supported_response PROTO ((char *)); + + static int +-supported_response (name) +- char *name; ++supported_response (char *name) + { + struct response *rs; + +@@ -694,8 +688,7 @@ supported_response (name) + } + + static void +-serve_valid_responses (arg) +- char *arg; ++serve_valid_responses (char *arg) + { + char *p = arg; + char *q; +@@ -740,8 +733,7 @@ serve_valid_responses (arg) + } + + static void +-serve_root (arg) +- char *arg; ++serve_root (char *arg) + { + char *env; + char *path; +@@ -843,8 +835,7 @@ static int max_dotdot_limit = 0; + /* Is this pathname OK to recurse into when we are running as the server? + If not, call error() with a fatal error. */ + void +-server_pathname_check (path) +- char *path; ++server_pathname_check (char *path) + { + /* An absolute pathname is almost surely a path on the *client* machine, + and is unlikely to do us any good here. It also is probably capable +@@ -878,8 +869,7 @@ static int outside_root PROTO ((char *)); + current_parsed_root->directory? If yes, return 0. If no, set pending_error + and return 1. */ + static int +-outside_root (repos) +- char *repos; ++outside_root (char *repos) + { + size_t repos_len = strlen (repos); + size_t root_len = strlen (current_parsed_root->directory); +@@ -923,8 +913,7 @@ static int outside_dir PROTO ((char *)); + it contain '/')? If no, return 0. If yes, set pending_error + and return 1. */ + static int +-outside_dir (file) +- char *file; ++outside_dir (char *file) + { + if (strchr (file, '/') != NULL) + { +@@ -944,8 +933,7 @@ E protocol error: directory '%s' not within current directory", + * directory via "..". + */ + static void +-serve_max_dotdot (arg) +- char *arg; ++serve_max_dotdot (char *arg) + { + int lim = atoi (arg); + int i; +@@ -971,9 +959,9 @@ serve_max_dotdot (arg) + static char *dir_name; + + static void +-dirswitch (dir, repos) +- char *dir; +- char *repos; ++dirswitch ( ++ char *dir, ++ char *repos) + { + int status; + FILE *f; +@@ -1165,8 +1153,7 @@ dirswitch (dir, repos) + } + + static void +-serve_repository (arg) +- char *arg; ++serve_repository (char *arg) + { + if (alloc_pending (80)) + strcpy (pending_error_text, +@@ -1175,8 +1162,7 @@ serve_repository (arg) + } + + static void +-serve_directory (arg) +- char *arg; ++serve_directory (char *arg) + { + int status; + char *repos; +@@ -1214,8 +1200,7 @@ serve_directory (arg) + } + + static void +-serve_static_directory (arg) +- char *arg; ++serve_static_directory (char *arg) + { + FILE *f; + +@@ -1242,8 +1227,7 @@ serve_static_directory (arg) + } + + static void +-serve_sticky (arg) +- char *arg; ++serve_sticky (char *arg) + { + FILE *f; + +@@ -1288,9 +1272,9 @@ serve_sticky (arg) + * enough. Or something. + */ + static void +-receive_partial_file (size, file) +- int size; +- int file; ++receive_partial_file ( ++ int size, ++ int file) + { + while (size > 0) + { +@@ -1359,10 +1343,10 @@ receive_partial_file (size, file) + + /* Receive SIZE bytes, write to filename FILE. */ + static void +-receive_file (size, file, gzipped) +- int size; +- char *file; +- int gzipped; ++receive_file ( ++ int size, ++ char *file, ++ int gzipped) + { + int fd; + char *arg = file; +@@ -1485,8 +1469,7 @@ static time_t checkin_time; + static void serve_modified PROTO ((char *)); + + static void +-serve_modified (arg) +- char *arg; ++serve_modified (char *arg) + { + int size, status; + char *size_text; +@@ -1638,8 +1621,7 @@ serve_modified (arg) + + + static void +-serve_enable_unchanged (arg) +- char *arg; ++serve_enable_unchanged (char *arg) + { + } + +@@ -1653,8 +1635,7 @@ static struct an_entry *entries; + static void serve_unchanged PROTO ((char *)); + + static void +-serve_unchanged (arg) +- char *arg; ++serve_unchanged (char *arg) + { + struct an_entry *p; + char *name; +@@ -1723,8 +1704,7 @@ serve_unchanged (arg) + } + + static void +-serve_is_modified (arg) +- char *arg; ++serve_is_modified (char *arg) + { + struct an_entry *p; + char *name; +@@ -1840,8 +1820,7 @@ serve_is_modified (arg) + static void serve_entry PROTO ((char *)); + + static void +-serve_entry (arg) +- char *arg; ++serve_entry (char *arg) + { + struct an_entry *p; + char *cp; +@@ -1890,8 +1869,7 @@ serve_entry (arg) + static void serve_kopt PROTO ((char *)); + + static void +-serve_kopt (arg) +- char *arg; ++serve_kopt (char *arg) + { + if (error_pending ()) + return; +@@ -1929,8 +1907,7 @@ serve_kopt (arg) + static void serve_checkin_time PROTO ((char *)); + + static void +-serve_checkin_time (arg) +- char *arg; ++serve_checkin_time (char *arg) + { + if (error_pending ()) + return; +@@ -2036,8 +2013,7 @@ static struct notify_note *last_node; + static void serve_notify PROTO ((char *)); + + static void +-serve_notify (arg) +- char *arg; ++serve_notify (char *arg) + { + struct notify_note *new = NULL; + char *data = NULL; +@@ -2229,8 +2205,7 @@ static char **argument_vector; + static int argument_vector_size; + + static void +-serve_argument (arg) +- char *arg; ++serve_argument (char *arg) + { + char *p; + +@@ -2267,8 +2242,7 @@ serve_argument (arg) + } + + static void +-serve_argumentx (arg) +- char *arg; ++serve_argumentx (char *arg) + { + char *p; + +@@ -2295,8 +2269,7 @@ serve_argumentx (arg) + } + + static void +-serve_global_option (arg) +- char *arg; ++serve_global_option (char *arg) + { + if (arg[0] != '-' || arg[1] == '\0' || arg[2] != '\0') + { +@@ -2334,8 +2307,7 @@ serve_global_option (arg) + } + + static void +-serve_set (arg) +- char *arg; ++serve_set (char *arg) + { + /* FIXME: This sends errors immediately (I think); they should be + put into pending_error. */ +@@ -2347,8 +2319,7 @@ serve_set (arg) + #ifdef HAVE_KERBEROS + + static void +-serve_kerberos_encrypt (arg) +- char *arg; ++serve_kerberos_encrypt (char *arg) + { + /* All future communication with the client will be encrypted. */ + +@@ -2365,8 +2336,7 @@ serve_kerberos_encrypt (arg) + #ifdef HAVE_GSSAPI + + static void +-serve_gssapi_encrypt (arg) +- char *arg; ++serve_gssapi_encrypt (char *arg) + { + if (cvs_gssapi_wrapping) + { +@@ -2401,8 +2371,7 @@ serve_gssapi_encrypt (arg) + #ifdef HAVE_GSSAPI + + static void +-serve_gssapi_authenticate (arg) +- char *arg; ++serve_gssapi_authenticate (char *arg) + { + if (cvs_gssapi_wrapping) + { +@@ -2442,8 +2411,7 @@ serve_gssapi_authenticate (arg) + static void serve_questionable PROTO((char *)); + + static void +-serve_questionable (arg) +- char *arg; ++serve_questionable (char *arg) + { + static int initted; + +@@ -2492,8 +2460,7 @@ static struct buffer *saved_output; + static struct buffer *saved_outerr; + + static void +-protocol_memory_error (buf) +- struct buffer *buf; ++protocol_memory_error (struct buffer *buf) + { + error (1, ENOMEM, "Virtual memory exhausted"); + } +@@ -2505,8 +2472,7 @@ protocol_memory_error (buf) + static pid_t command_pid; + + static void +-outbuf_memory_error (buf) +- struct buffer *buf; ++outbuf_memory_error (struct buffer *buf) + { + static const char msg[] = "E Fatal server error\n\ + error ENOMEM Virtual memory exhausted.\n"; +@@ -2528,8 +2494,7 @@ error ENOMEM Virtual memory exhausted.\n"; + } + + static void +-input_memory_error (buf) +- struct buffer *buf; ++input_memory_error (struct buffer *buf) + { + outbuf_memory_error (buf); + } +@@ -2541,8 +2506,7 @@ input_memory_error (buf) + * Else just return 0 to indicate that command is illegal. + */ + static int +-check_command_legal_p (cmd_name) +- char *cmd_name; ++check_command_legal_p (char *cmd_name) + { + /* Right now, only pserver notices illegal commands -- namely, + * write attempts by a read-only user. Therefore, if CVS_Username +@@ -2727,8 +2691,7 @@ static int flowcontrol_pipe[2]; + * code. + */ + int +-set_nonblock_fd (fd) +- int fd; ++set_nonblock_fd (int fd) + { + int flags; + +@@ -2746,8 +2709,7 @@ set_nonblock_fd (fd) + * Set buffer FD to blocking I/O. Returns 0 for success or errno code. + */ + int +-set_block_fd (fd) +- int fd; ++set_block_fd (int fd) + { + int flags; + +@@ -2762,9 +2724,9 @@ set_block_fd (fd) + + + static void +-do_cvs_command (cmd_name, command) +- char *cmd_name; +- int (*command) PROTO((int argc, char **argv)); ++do_cvs_command ( ++ char *cmd_name, ++ int (*command) PROTO((int argc, char **argv))) + { + /* + * The following file descriptors are set to -1 if that file is not +@@ -2991,7 +2953,7 @@ error \n"); + */ + #endif + +- rcs_cleanup (); ++ rcs_cleanup (0); + Lock_Cleanup (); + /* Don't call server_cleanup - the parent will handle that. */ + #ifdef SYSTEM_CLEANUP +@@ -3562,9 +3524,9 @@ char *server_dir = NULL; + static void output_dir PROTO((const char *, const char *)); + + static void +-output_dir (update_dir, repository) +- const char *update_dir; +- const char *repository; ++output_dir ( ++ const char *update_dir, ++ const char *repository) + { + if (server_dir != NULL) + { +@@ -3603,14 +3565,14 @@ static int kill_scratched_file; + + + void +-server_register (name, version, timestamp, options, tag, date, conflict) +- const char *name; +- const char *version; +- const char *timestamp; +- const char *options; +- const char *tag; +- const char *date; +- const char *conflict; ++server_register ( ++ const char *name, ++ const char *version, ++ const char *timestamp, ++ const char *options, ++ const char *tag, ++ const char *date, ++ const char *conflict) + { + int len; + +@@ -3679,8 +3641,7 @@ server_register (name, version, timestamp, options, tag, date, conflict) + + + void +-server_scratch (fname) +- const char *fname; ++server_scratch (const char *fname) + { + /* + * I have reports of Scratch_Entry and Register both happening, in +@@ -3735,17 +3696,16 @@ new_entries_line () + + + static void +-serve_ci (arg) +- char *arg; ++serve_ci (char *arg) + { + do_cvs_command ("commit", commit); + } + + static void +-checked_in_response (file, update_dir, repository) +- char *file; +- char *update_dir; +- char *repository; ++checked_in_response ( ++ const char *file, ++ const char *update_dir, ++ const char *repository) + { + if (supported_response ("Mode")) + { +@@ -3777,10 +3737,10 @@ checked_in_response (file, update_dir, repository) + } + + void +-server_checked_in (file, update_dir, repository) +- const char *file; +- const char *update_dir; +- const char *repository; ++server_checked_in ( ++ const char *file, ++ const char *update_dir, ++ const char *repository) + { + assert (file); + assert (update_dir); +@@ -3809,11 +3769,11 @@ server_checked_in (file, update_dir, repository) + } + + void +-server_update_entries (file, update_dir, repository, updated) +- const char *file; +- const char *update_dir; +- const char *repository; +- enum server_updated_arg4 updated; ++server_update_entries ( ++ const char *file, ++ const char *update_dir, ++ const char *repository, ++ enum server_updated_arg4 updated) + { + if (noexec) + return; +@@ -3834,99 +3794,85 @@ server_update_entries (file, update_dir, repository, updated) + } + + static void +-serve_update (arg) +- char *arg; ++serve_update (char *arg) + { + do_cvs_command ("update", update); + } + + static void +-serve_diff (arg) +- char *arg; ++serve_diff (char *arg) + { + do_cvs_command ("diff", diff); + } + + static void +-serve_log (arg) +- char *arg; ++serve_log (char *arg) + { + do_cvs_command ("log", cvslog); + } + + static void +-serve_rlog (arg) +- char *arg; ++serve_rlog (char *arg) + { + do_cvs_command ("rlog", cvslog); + } + + static void +-serve_add (arg) +- char *arg; ++serve_add (char *arg) + { + do_cvs_command ("add", add); + } + + static void +-serve_remove (arg) +- char *arg; ++serve_remove (char *arg) + { + do_cvs_command ("remove", cvsremove); + } + + static void +-serve_status (arg) +- char *arg; ++serve_status (char *arg) + { + do_cvs_command ("status", cvsstatus); + } + + static void +-serve_rdiff (arg) +- char *arg; ++serve_rdiff (char *arg) + { + do_cvs_command ("rdiff", patch); + } + + static void +-serve_tag (arg) +- char *arg; ++serve_tag (char *arg) + { + do_cvs_command ("tag", cvstag); + } + + static void +-serve_rtag (arg) +- char *arg; ++serve_rtag (char *arg) + { + do_cvs_command ("rtag", cvstag); + } + + static void +-serve_import (arg) +- char *arg; ++serve_import (char *arg) + { + do_cvs_command ("import", import); + } + + static void +-serve_admin (arg) +- char *arg; ++serve_admin (char *arg) + { + do_cvs_command ("admin", admin); + } + + static void +-serve_history (arg) +- char *arg; ++serve_history (char *arg) + { + do_cvs_command ("history", history); + } + + static void +-serve_release (arg) +- char *arg; ++serve_release (char *arg) + { + do_cvs_command ("release", release); + } +@@ -3934,8 +3880,7 @@ serve_release (arg) + static void serve_watch_on PROTO ((char *)); + + static void +-serve_watch_on (arg) +- char *arg; ++serve_watch_on (char *arg) + { + do_cvs_command ("watch", watch_on); + } +@@ -3943,8 +3888,7 @@ serve_watch_on (arg) + static void serve_watch_off PROTO ((char *)); + + static void +-serve_watch_off (arg) +- char *arg; ++serve_watch_off (char *arg) + { + do_cvs_command ("watch", watch_off); + } +@@ -3952,8 +3896,7 @@ serve_watch_off (arg) + static void serve_watch_add PROTO ((char *)); + + static void +-serve_watch_add (arg) +- char *arg; ++serve_watch_add (char *arg) + { + do_cvs_command ("watch", watch_add); + } +@@ -3961,8 +3904,7 @@ serve_watch_add (arg) + static void serve_watch_remove PROTO ((char *)); + + static void +-serve_watch_remove (arg) +- char *arg; ++serve_watch_remove (char *arg) + { + do_cvs_command ("watch", watch_remove); + } +@@ -3970,8 +3912,7 @@ serve_watch_remove (arg) + static void serve_watchers PROTO ((char *)); + + static void +-serve_watchers (arg) +- char *arg; ++serve_watchers (char *arg) + { + do_cvs_command ("watchers", watchers); + } +@@ -3979,8 +3920,7 @@ serve_watchers (arg) + static void serve_editors PROTO ((char *)); + + static void +-serve_editors (arg) +- char *arg; ++serve_editors (char *arg) + { + do_cvs_command ("editors", editors); + } +@@ -3988,8 +3928,7 @@ serve_editors (arg) + static void serve_noop PROTO ((char *)); + + static void +-serve_noop (arg) +- char *arg; ++serve_noop (char *arg) + { + + server_write_entries (); +@@ -4004,8 +3943,7 @@ serve_noop (arg) + static void serve_version PROTO ((char *)); + + static void +-serve_version (arg) +- char *arg; ++serve_version (char *arg) + { + do_cvs_command ("version", version); + } +@@ -4013,8 +3951,7 @@ serve_version (arg) + static void serve_init PROTO ((char *)); + + static void +-serve_init (arg) +- char *arg; ++serve_init (char *arg) + { + if (alloc_pending (80 + strlen (arg))) + sprintf (pending_error_text, "E init may not be run remotely"); +@@ -4026,8 +3963,7 @@ serve_init (arg) + static void serve_annotate PROTO ((char *)); + + static void +-serve_annotate (arg) +- char *arg; ++serve_annotate (char *arg) + { + do_cvs_command ("annotate", annotate); + } +@@ -4035,15 +3971,13 @@ serve_annotate (arg) + static void serve_rannotate PROTO ((char *)); + + static void +-serve_rannotate (arg) +- char *arg; ++serve_rannotate (char *arg) + { + do_cvs_command ("rannotate", annotate); + } + + static void +-serve_co (arg) +- char *arg; ++serve_co (char *arg) + { + char *tempdir; + int status; +@@ -4099,8 +4033,7 @@ serve_co (arg) + } + + static void +-serve_export (arg) +- char *arg; ++serve_export (char *arg) + { + /* Tell checkout() to behave like export not checkout. */ + cvs_cmd_name = "export"; +@@ -4110,11 +4043,11 @@ serve_export (arg) + + + void +-server_copy_file (file, update_dir, repository, newfile) +- const char *file; +- const char *update_dir; +- const char *repository; +- const char *newfile; ++server_copy_file ( ++ const char *file, ++ const char *update_dir, ++ const char *repository, ++ const char *newfile) + { + /* At least for now, our practice is to have the server enforce + noexec for the repository and the client enforce it for the +@@ -4135,9 +4068,9 @@ server_copy_file (file, update_dir, repository, newfile) + /* See server.h for description. */ + + void +-server_modtime (finfo, vers_ts) +- struct file_info *finfo; +- Vers_TS *vers_ts; ++server_modtime ( ++ struct file_info *finfo, ++ Vers_TS *vers_ts) + { + char date[MAXDATELEN]; + char outdate[MAXDATELEN]; +@@ -4487,9 +4420,9 @@ server_use_rcs_diff () + + + void +-server_set_entstat (update_dir, repository) +- const char *update_dir; +- const char *repository; ++server_set_entstat ( ++ const char *update_dir, ++ const char *repository) + { + static int set_static_supported = -1; + if (set_static_supported == -1) +@@ -4505,9 +4438,9 @@ server_set_entstat (update_dir, repository) + + + void +-server_clear_entstat (update_dir, repository) +- const char *update_dir; +- const char *repository; ++server_clear_entstat ( ++ const char *update_dir, ++ const char *repository) + { + static int clear_static_supported = -1; + if (clear_static_supported == -1) +@@ -4526,12 +4459,12 @@ server_clear_entstat (update_dir, repository) + + + void +-server_set_sticky (update_dir, repository, tag, date, nonbranch) +- const char *update_dir; +- const char *repository; +- const char *tag; +- const char *date; +- int nonbranch; ++server_set_sticky ( ++ const char *update_dir, ++ const char *repository, ++ const char *tag, ++ const char *date, ++ int nonbranch) + { + static int set_sticky_supported = -1; + +@@ -4587,9 +4520,9 @@ static int + template_proc PROTO((const char *repository, const char *template)); + + static int +-template_proc (repository, template) +- const char *repository; +- const char *template; ++template_proc ( ++ const char *repository, ++ const char *template) + { + FILE *fp; + char buf[1024]; +@@ -4638,9 +4571,9 @@ template_proc (repository, template) + + + void +-server_template (update_dir, repository) +- const char *update_dir; +- const char *repository; ++server_template ( ++ const char *update_dir, ++ const char *repository) + { + struct template_proc_data data; + data.update_dir = update_dir; +@@ -4652,8 +4585,7 @@ server_template (update_dir, repository) + + + static void +-serve_gzip_contents (arg) +- char *arg; ++serve_gzip_contents (char *arg) + { + int level; + level = atoi (arg); +@@ -4663,8 +4595,7 @@ serve_gzip_contents (arg) + } + + static void +-serve_gzip_stream (arg) +- char *arg; ++serve_gzip_stream (char *arg) + { + int level; + level = atoi (arg); +@@ -4681,8 +4612,7 @@ serve_gzip_stream (arg) + + /* Tell the client about RCS options set in CVSROOT/cvswrappers. */ + static void +-serve_wrapper_sendme_rcs_options (arg) +- char *arg; ++serve_wrapper_sendme_rcs_options (char *arg) + { + /* Actually, this is kind of sdrawkcab-ssa: the client wants + * verbatim lines from a cvswrappers file, but the server has +@@ -4712,8 +4642,7 @@ serve_wrapper_sendme_rcs_options (arg) + + + static void +-serve_ignore (arg) +- char *arg; ++serve_ignore (char *arg) + { + /* + * Just ignore this command. This is used to support the +@@ -4723,17 +4652,16 @@ serve_ignore (arg) + } + + static int +-expand_proc (argc, argv, where, mwhere, mfile, shorten, +- local_specified, omodule, msg) +- int argc; +- char **argv; +- char *where; +- char *mwhere; +- char *mfile; +- int shorten; +- int local_specified; +- char *omodule; +- char *msg; ++expand_proc ( ++ int argc, ++ char **argv, ++ char *where, ++ char *mwhere, ++ char *mfile, ++ int shorten, ++ int local_specified, ++ char *omodule, ++ char *msg) + { + int i; + char *dir = argv[0]; +@@ -4796,8 +4724,7 @@ expand_proc (argc, argv, where, mwhere, mfile, shorten, + } + + static void +-serve_expand_modules (arg) +- char *arg; ++serve_expand_modules (char *arg) + { + int i; + int err; +@@ -4937,8 +4864,7 @@ struct request requests[] = + #ifdef SERVER_SUPPORT + + static void +-serve_valid_requests (arg) +- char *arg; ++serve_valid_requests (char *arg) + { + struct request *rq; + if (print_pending_error ()) +@@ -4965,8 +4891,7 @@ serve_valid_requests (arg) + * 0 if not called as a result of a signal. + */ + static int command_pid_is_dead; +-static void wait_sig (sig) +- int sig; ++static void wait_sig (int sig) + { + int status; + pid_t r = wait (&status); +@@ -4976,8 +4901,7 @@ static void wait_sig (sig) + #endif /* SUNOS_KLUDGE */ + + void +-server_cleanup (sig) +- int sig; ++server_cleanup (int sig) + { + /* Do "rm -rf" on the temp directory. */ + int status; +@@ -5133,9 +5057,9 @@ server_cleanup (sig) + } + + int +-server (argc, argv) +- int argc; +- char **argv; ++server ( ++ int argc, ++ char **argv) + { + char *error_prog_name; /* Used in error messages */ + +@@ -5378,9 +5302,9 @@ error ENOMEM Virtual memory exhausted.\n"); + static void switch_to_user PROTO((const char *, const char *)); + + static void +-switch_to_user (cvs_username, username) +- const char *cvs_username; /* Only used for error messages. */ +- const char *username; ++switch_to_user ( ++ const char *cvs_username, /* Only used for error messages. */ ++ const char *username) + { + struct passwd *pw; + +@@ -5532,8 +5456,11 @@ extern char *crypt PROTO((const char *, const char *)); + * kff todo: FIXME: last sentence is not true, it applies to caller. + */ + static int +-check_repository_password (username, password, repository, host_user_ptr) +- char *username, *password, *repository, **host_user_ptr; ++check_repository_password ( ++ const char *username, ++ const char *password, ++ const char *repository, ++ char **host_user_ptr) + { + int retval = 0; + FILE *fp; +@@ -5587,7 +5514,7 @@ check_repository_password (username, password, repository, host_user_ptr) + /* If found_it, then linebuf contains the information we need. */ + if (found_it) + { +- char *found_password, *host_user_tmp; ++ const char *found_password, *host_user_tmp; + char *non_cvsuser_portion; + + /* We need to make sure lines such as +@@ -5714,8 +5641,10 @@ int silent_conv(int num_msg, const struct pam_message **msgm, + + /* Return a hosting username if password matches, else NULL. */ + static char * +-check_password (username, password, repository) +- char *username, *password, *repository; ++check_password ( ++ const char *username, ++ const char *password, ++ const char *repository) + { + int rc; + char *host_user = NULL; +@@ -5826,7 +5755,7 @@ error %s getnameinfo failed\n", strerror (errno)); + } + + conv.conv = silent_conv; +- conv.appdata_ptr = password; ++ conv.appdata_ptr = (void *)password; /* silent_conv() only reads from here */ + + #define PAM_SERVICE_NAME "cvs" + retval = pam_start(PAM_SERVICE_NAME, username, &conv, &pamh); +@@ -6233,7 +6162,7 @@ gserver_authenticate_connection () + + if (gss_import_name (&stat_min, &tok_in, GSS_C_NT_HOSTBASED_SERVICE, + &server_name) != GSS_S_COMPLETE) +- error (1, 0, "could not import GSSAPI service name %s", tok_in.value); ++ error (1, 0, "could not import GSSAPI service name %s", (char *)tok_in.value); + + /* Acquire the server credential to verify the client's + authentication. */ +@@ -6361,11 +6290,11 @@ static int cvs_gssapi_wrap_output PROTO((void *, const char *, char *, int, + GSSAPI wrapping routines. */ + + struct buffer * +-cvs_gssapi_wrap_buffer_initialize (buf, input, gcontext, memory) +- struct buffer *buf; +- int input; +- gss_ctx_id_t gcontext; +- void (*memory) PROTO((struct buffer *)); ++cvs_gssapi_wrap_buffer_initialize ( ++ struct buffer *buf, ++ int input, ++ gss_ctx_id_t gcontext, ++ void (*memory) PROTO((struct buffer *))) + { + struct cvs_gssapi_wrap_data *gd; + +@@ -6383,11 +6312,11 @@ cvs_gssapi_wrap_buffer_initialize (buf, input, gcontext, memory) + /* Unwrap data using GSSAPI. */ + + static int +-cvs_gssapi_wrap_input (fnclosure, input, output, size) +- void *fnclosure; +- const char *input; +- char *output; +- int size; ++cvs_gssapi_wrap_input ( ++ void *fnclosure, ++ const char *input, ++ char *output, ++ int size) + { + struct cvs_gssapi_wrap_data *gd = + (struct cvs_gssapi_wrap_data *) fnclosure; +@@ -6420,12 +6349,12 @@ cvs_gssapi_wrap_input (fnclosure, input, output, size) + /* Wrap data using GSSAPI. */ + + static int +-cvs_gssapi_wrap_output (fnclosure, input, output, size, translated) +- void *fnclosure; +- const char *input; +- char *output; +- int size; +- int *translated; ++cvs_gssapi_wrap_output ( ++ void *fnclosure, ++ const char *input, ++ char *output, ++ int size, ++ int *translated) + { + struct cvs_gssapi_wrap_data *gd = + (struct cvs_gssapi_wrap_data *) fnclosure; +@@ -6490,12 +6419,12 @@ static int krb_encrypt_output PROTO((void *, const char *, char *, int, + with Kerberos encryption translation routines. */ + + struct buffer * +-krb_encrypt_buffer_initialize (buf, input, sched, block, memory) +- struct buffer *buf; +- int input; +- Key_schedule sched; +- C_Block block; +- void (*memory) PROTO((struct buffer *)); ++krb_encrypt_buffer_initialize ( ++ struct buffer *buf, ++ int input, ++ Key_schedule sched, ++ C_Block block, ++ void (*memory) PROTO((struct buffer *))) + { + struct krb_encrypt_data *kd; + +@@ -6513,11 +6442,11 @@ krb_encrypt_buffer_initialize (buf, input, sched, block, memory) + /* Decrypt Kerberos data. */ + + static int +-krb_encrypt_input (fnclosure, input, output, size) +- void *fnclosure; +- const char *input; +- char *output; +- int size; ++krb_encrypt_input ( ++ void *fnclosure, ++ const char *input, ++ char *output, ++ int size) + { + struct krb_encrypt_data *kd = (struct krb_encrypt_data *) fnclosure; + int tcount; +@@ -6542,12 +6471,12 @@ krb_encrypt_input (fnclosure, input, output, size) + /* Encrypt Kerberos data. */ + + static int +-krb_encrypt_output (fnclosure, input, output, size, translated) +- void *fnclosure; +- const char *input; +- char *output; +- int size; +- int *translated; ++krb_encrypt_output ( ++ void *fnclosure, ++ const char *input, ++ char *output, ++ int size, ++ int *translated) + { + struct krb_encrypt_data *kd = (struct krb_encrypt_data *) fnclosure; + int aligned; +@@ -6585,9 +6514,9 @@ krb_encrypt_output (fnclosure, input, output, size, translated) + the first '\0' byte. */ + + void +-cvs_output (str, len) +- const char *str; +- size_t len; ++cvs_output ( ++ const char *str, ++ size_t len) + { + if (len == 0) + len = strlen (str); +@@ -6630,9 +6559,9 @@ cvs_output (str, len) + output zero bytes. */ + + void +-cvs_output_binary (str, len) +- char *str; +- size_t len; ++cvs_output_binary ( ++ char *str, ++ size_t len) + { + #ifdef SERVER_SUPPORT + if (error_use_protocol || server_active) +@@ -6714,9 +6643,9 @@ this client does not support writing binary files to stdout"); + + /* Like CVS_OUTPUT but output is for stderr not stdout. */ + void +-cvs_outerr (str, len) +- const char *str; +- size_t len; ++cvs_outerr ( ++ const char *str, ++ size_t len) + { + if (len == 0) + len = strlen (str); +@@ -6829,9 +6758,9 @@ cvs_flushout () + Note that there is no way to output either \0 or \n as part of TEXT. */ + + void +-cvs_output_tagged (tag, text) +- const char *tag; +- const char *text; ++cvs_output_tagged ( ++ const char *tag, ++ const char *text) + { + if (text != NULL && strchr (text, '\n') != NULL) + /* Uh oh. The protocol has no way to cope with this. For now +diff --git a/src/stack.c b/src/stack.c +index 22a1088..7dbc4b0 100644 +--- a/src/stack.c ++++ b/src/stack.c +@@ -16,10 +16,10 @@ + + + static void +-do_push (stack, elem, isstring) +- List *stack; +- void *elem; +- int isstring; ++do_push ( ++ List *stack, ++ void *elem, ++ int isstring) + { + Node *p = getnode(); + +@@ -34,9 +34,9 @@ do_push (stack, elem, isstring) + + + void +-push (stack, elem) +- List *stack; +- void *elem; ++push ( ++ List *stack, ++ void *elem) + { + do_push (stack, elem, 0); + } +@@ -44,9 +44,9 @@ push (stack, elem) + + + void +-push_string (stack, elem) +- List *stack; +- char *elem; ++push_string ( ++ List *stack, ++ char *elem) + { + do_push (stack, elem, 1); + } +@@ -54,9 +54,9 @@ push_string (stack, elem) + + + static void * +-do_pop (stack, isstring) +- List *stack; +- int isstring; ++do_pop ( ++ List *stack, ++ int isstring) + { + void *elem; + +@@ -80,8 +80,7 @@ do_pop (stack, isstring) + + + void * +-pop (stack) +- List *stack; ++pop (List *stack) + { + return do_pop (stack, 0); + } +@@ -89,8 +88,8 @@ pop (stack) + + + char * +-pop_string (stack) +- List *stack; ++pop_string ( ++ List *stack) + { + return do_pop (stack, 1); + } +@@ -98,10 +97,10 @@ pop_string (stack) + + + static void +-do_unshift (stack, elem, isstring) +- List *stack; +- void *elem; +- int isstring; ++do_unshift ( ++ List *stack, ++ void *elem, ++ int isstring) + { + Node *p = getnode(); + +@@ -116,9 +115,9 @@ do_unshift (stack, elem, isstring) + + + void +-unshift (stack, elem) +- List *stack; +- void *elem; ++unshift ( ++ List *stack, ++ void *elem) + { + do_unshift (stack, elem, 0); + } +@@ -126,9 +125,9 @@ unshift (stack, elem) + + + void +-unshift_string (stack, elem) +- List *stack; +- char *elem; ++unshift_string ( ++ List *stack, ++ char *elem) + { + do_unshift (stack, elem, 1); + } +@@ -136,9 +135,9 @@ unshift_string (stack, elem) + + + static void * +-do_shift (stack, isstring) +- List *stack; +- int isstring; ++do_shift ( ++ List *stack, ++ int isstring) + { + void *elem; + +@@ -161,8 +160,7 @@ do_shift (stack, isstring) + + + void * +-shift (stack) +- List *stack; ++shift (List *stack) + { + return do_shift (stack, 0); + } +@@ -170,8 +168,7 @@ shift (stack) + + + char * +-shift_string (stack) +- List *stack; ++shift_string (List *stack) + { + return do_shift (stack, 1); + } +@@ -179,8 +176,7 @@ shift_string (stack) + + + int +-isempty (stack) +- List *stack; ++isempty (List *stack) + { + if (stack->list == stack->list->next) + return 1; +diff --git a/src/status.c b/src/status.c +index 7a828ae..5043935 100644 +--- a/src/status.c ++++ b/src/status.c +@@ -36,9 +36,9 @@ static const char *const status_usage[] = + }; + + int +-cvsstatus (argc, argv) +- int argc; +- char **argv; ++cvsstatus ( ++ int argc, ++ char **argv) + { + int c; + int err = 0; +@@ -123,9 +123,9 @@ cvsstatus (argc, argv) + */ + /* ARGSUSED */ + static int +-status_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++status_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + Ctype status; + char *sstat; +@@ -316,12 +316,12 @@ status_fileproc (callerdat, finfo) + */ + /* ARGSUSED */ + static Dtype +-status_dirproc (callerdat, dir, repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repos; +- const char *update_dir; +- List *entries; ++status_dirproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + if (!quiet) + error (0, 0, "Examining %s", update_dir); +@@ -332,9 +332,9 @@ status_dirproc (callerdat, dir, repos, update_dir, entries) + * Print out a tag and its type + */ + static int +-tag_list_proc (p, closure) +- Node *p; +- void *closure; ++tag_list_proc ( ++ Node *p, ++ void *closure) + { + char *branch = NULL; + char *buf; +diff --git a/src/subr.c b/src/subr.c +index 94907ce..2a7fa6a 100644 +--- a/src/subr.c ++++ b/src/subr.c +@@ -32,8 +32,7 @@ extern char *getlogin (); + * malloc some data and die if it fails + */ + void * +-xmalloc (bytes) +- size_t bytes; ++xmalloc (size_t bytes) + { + char *cp; + +@@ -58,9 +57,9 @@ xmalloc (bytes) + * can *force* it.] + */ + void * +-xrealloc (ptr, bytes) +- void *ptr; +- size_t bytes; ++xrealloc ( ++ void *ptr, ++ size_t bytes) + { + char *cp; + +@@ -98,10 +97,10 @@ xrealloc (ptr, bytes) + NEWSIZE bytes of space. Gives a fatal error if out of memory; + if it returns it was successful. */ + void +-expand_string (strptr, n, newsize) +- char **strptr; +- size_t *n; +- size_t newsize; ++expand_string ( ++ char **strptr, ++ size_t *n, ++ size_t newsize) + { + if (*n < newsize) + { +@@ -125,10 +124,10 @@ expand_string (strptr, n, newsize) + /* *STR is a pointer to a malloc'd string. *LENP is its allocated + length. Add SRC to the end of it, reallocating if necessary. */ + void +-xrealloc_and_strcat (str, lenp, src) +- char **str; +- size_t *lenp; +- const char *src; ++xrealloc_and_strcat ( ++ char **str, ++ size_t *lenp, ++ const char *src) + { + + expand_string (str, lenp, strlen (*str) + strlen (src) + 1); +@@ -139,8 +138,7 @@ xrealloc_and_strcat (str, lenp, src) + * Duplicate a string, calling xmalloc to allocate some dynamic space + */ + char * +-xstrdup (str) +- const char *str; ++xstrdup (const char *str) + { + char *s; + +@@ -160,8 +158,7 @@ xstrdup (str) + * True if any newlines were removed, false otherwise. + */ + int +-strip_trailing_newlines (str) +- char *str; ++strip_trailing_newlines (char *str) + { + size_t index, origlen; + index = origlen = strlen (str); +@@ -181,8 +178,7 @@ strip_trailing_newlines (str) + * "foo/../../bar" -> 1 + */ + int +-pathname_levels (p) +- const char *p; ++pathname_levels (const char *p) + { + int level; + int max_level; +@@ -219,9 +215,9 @@ pathname_levels (p) + are malloc'd and so is *ARGV itself. Such a vector is allocated by + line2argv or expand_wild, for example. */ + void +-free_names (pargc, argv) +- int *pargc; +- char **argv; ++free_names ( ++ int *pargc, ++ char **argv) + { + register int i; + +@@ -239,11 +235,11 @@ free_names (pargc, argv) + (*ARGV)[0], (*ARGV)[1], ... Use free_names() to return the memory + allocated here back to the free pool. */ + void +-line2argv (pargc, argv, line, sepchars) +- int *pargc; +- char ***argv; +- char *line; +- char *sepchars; ++line2argv ( ++ int *pargc, ++ char ***argv, ++ char *line, ++ char *sepchars) + { + char *cp; + /* Could make a case for size_t or some other unsigned type, but +@@ -272,8 +268,7 @@ line2argv (pargc, argv, line, sepchars) + * Returns the number of dots ('.') found in an RCS revision number + */ + int +-numdots (s) +- const char *s; ++numdots (const char *s) + { + int dots = 0; + +@@ -290,9 +285,9 @@ numdots (s) + two revision numbers must have the same number of fields, or else + compare_revnums will return an inaccurate result. */ + int +-compare_revnums (rev1, rev2) +- const char *rev1; +- const char *rev2; ++compare_revnums ( ++ const char *rev1, ++ const char *rev2) + { + const char *sp, *tp; + char *snext, *tnext; +@@ -316,8 +311,7 @@ compare_revnums (rev1, rev2) + but it avoid problems with integer overflow should the revision numbers + get really big. */ + char * +-increment_revnum (rev) +- const char *rev; ++increment_revnum (const char *rev) + { + char *newrev, *p; + size_t len = strlen (rev); +@@ -406,9 +400,9 @@ getcaller () + #ifndef __GNUC__ + /* ARGSUSED */ + time_t +-get_date (date, now) +- char *date; +- struct timeb *now; ++get_date ( ++ char *date, ++ struct timeb *now) + { + time_t foo = 0; + +@@ -439,9 +433,9 @@ get_date (date, now) + * function should work fine, as revision X.1 must exist, due to RCS rules. + */ + char * +-previous_rev (rcs, rev) +- RCSNode *rcs; +- const char *rev; ++previous_rev ( ++ RCSNode *rcs, ++ const char *rev) + { + char *p; + char *tmp = xstrdup (rev); +@@ -487,9 +481,9 @@ previous_rev (rcs, rev) + exist. */ + + char * +-gca (rev1, rev2) +- const char *rev1; +- const char *rev2; ++gca ( ++ const char *rev1, ++ const char *rev2) + { + int dots; + char *gca, *g; +@@ -575,10 +569,10 @@ gca (rev1, rev2) + should also be called from diff -r, update -r, get -r, and log -r. */ + + void +-check_numeric (rev, argc, argv) +- const char *rev; +- int argc; +- char **argv; ++check_numeric ( ++ const char *rev, ++ int argc, ++ char **argv) + { + if (rev == NULL || !isdigit ((unsigned char) *rev)) + return; +@@ -606,8 +600,7 @@ check_numeric (rev, argc, argv) + * nonsense about non-empty log fields can be dropped. + */ + char * +-make_message_rcslegal (message) +- const char *message; ++make_message_rcslegal (const char *message) + { + char *dst, *dp; + const char *mp; +@@ -651,8 +644,7 @@ make_message_rcslegal (message) + which contain those patterns not as conflict markers), but for now it + is what we do. */ + int +-file_has_markers (finfo) +- const struct file_info *finfo; ++file_has_markers (const struct file_info *finfo) + { + FILE *fp; + char *line = NULL; +@@ -693,13 +685,13 @@ out: + is FULLNAME. MODE is "r" for text or "rb" for binary. */ + + void +-get_file (name, fullname, mode, buf, bufsize, len) +- const char *name; +- const char *fullname; +- const char *mode; +- char **buf; +- size_t *bufsize; +- size_t *len; ++get_file ( ++ const char *name, ++ const char *fullname, ++ const char *mode, ++ char **buf, ++ size_t *bufsize, ++ size_t *len) + { + struct stat s; + size_t nread; +@@ -785,8 +777,7 @@ get_file (name, fullname, mode, buf, bufsize, len) + FILENAME with the destination (a real file). */ + + void +-resolve_symlink (filename) +- char **filename; ++resolve_symlink (char **filename) + { + if (filename == NULL || *filename == NULL) + return; +@@ -830,9 +821,9 @@ resolve_symlink (filename) + * Returns the new name, which caller may free() if desired. + */ + char * +-backup_file (filename, suffix) +- const char *filename; +- const char *suffix; ++backup_file ( ++ const char *filename, ++ const char *suffix) + { + char *backup_name; + +@@ -864,9 +855,9 @@ backup_file (filename, suffix) + */ + + char * +-shell_escape(buf, str) +- char *buf; +- const char *str; ++shell_escape( ++ char *buf, ++ const char *str) + { + static const char meta[] = "$`\\\""; + const char *p; +@@ -895,8 +886,7 @@ shell_escape(buf, str) + * We can only travel forwards in time, not backwards. :) + */ + void +-sleep_past (desttime) +- time_t desttime; ++sleep_past (time_t desttime) + { + time_t t; + long s; +@@ -958,8 +948,7 @@ sleep_past (desttime) + /* Return non-zero iff FILENAME is absolute. + Trivial under Unix, but more complicated under other systems. */ + int +-isabsolute (filename) +- const char *filename; ++isabsolute (const char *filename) + { + return ISABSOLUTE (filename); + } +diff --git a/src/tag.c b/src/tag.c +index 6525eb2..82672d2 100644 +--- a/src/tag.c ++++ b/src/tag.c +@@ -107,9 +107,9 @@ static const char *const tag_usage[] = + }; + + int +-cvstag (argc, argv) +- int argc; +- char **argv; ++cvstag ( ++ int argc, ++ char **argv) + { + int local = 0; /* recursive by default */ + int c; +@@ -284,17 +284,16 @@ cvstag (argc, argv) + */ + /* ARGSUSED */ + static int +-rtag_proc (argc, argv, xwhere, mwhere, mfile, shorten, local_specified, +- mname, msg) +- int argc; +- char **argv; +- char *xwhere; +- char *mwhere; +- char *mfile; +- int shorten; +- int local_specified; +- char *mname; +- char *msg; ++rtag_proc ( ++ int argc, ++ char **argv, ++ char *xwhere, ++ char *mwhere, ++ char *mfile, ++ int shorten, ++ int local_specified, ++ char *mname, ++ char *msg) + { + /* Begin section which is identical to patch_proc--should this + be abstracted out somehow? */ +@@ -413,9 +412,9 @@ rtag_proc (argc, argv, xwhere, mwhere, mfile, shorten, local_specified, + /* All we do here is add it to our list */ + + static int +-check_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++check_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + const char *xdir; + Node *p; +@@ -538,12 +537,12 @@ check_fileproc (callerdat, finfo) + } + + static int +-check_filesdoneproc (callerdat, err, repos, update_dir, entries) +- void *callerdat; +- int err; +- const char *repos; +- const char *update_dir; +- List *entries; ++check_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + int n; + Node *p; +@@ -570,9 +569,9 @@ check_filesdoneproc (callerdat, err, repos, update_dir, entries) + } + + static int +-pretag_proc (repository, filter) +- const char *repository; +- const char *filter; ++pretag_proc ( ++ const char *repository, ++ const char *filter) + { + if (filter[0] == '/') + { +@@ -604,8 +603,7 @@ pretag_proc (repository, filter) + } + + static void +-masterlist_delproc(p) +- Node *p; ++masterlist_delproc(Node *p) + { + struct master_lists *ml = p->data; + +@@ -615,8 +613,7 @@ masterlist_delproc(p) + } + + static void +-tag_delproc(p) +- Node *p; ++tag_delproc(Node *p) + { + if (p->data != NULL) + { +@@ -627,9 +624,9 @@ tag_delproc(p) + } + + static int +-pretag_list_proc(p, closure) +- Node *p; +- void *closure; ++pretag_list_proc( ++ Node *p, ++ void *closure) + { + if (p->data != NULL) + { +@@ -646,9 +643,9 @@ pretag_list_proc(p, closure) + */ + /* ARGSUSED */ + static int +-rtag_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++rtag_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + RCSNode *rcsfile; + char *version, *rev; +@@ -807,8 +804,7 @@ rtag_fileproc (callerdat, finfo) + * "rcs" to remove the tag... trust me. + */ + static int +-rtag_delete (rcsfile) +- RCSNode *rcsfile; ++rtag_delete (RCSNode *rcsfile) + { + char *version; + int retcode, isbranch; +@@ -861,9 +857,9 @@ rtag_delete (rcsfile) + */ + /* ARGSUSED */ + static int +-tag_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++tag_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + char *version, *oversion; + char *nversion = NULL; +@@ -1074,12 +1070,12 @@ tag_fileproc (callerdat, finfo) + */ + /* ARGSUSED */ + static Dtype +-tag_dirproc (callerdat, dir, repos, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repos; +- const char *update_dir; +- List *entries; ++tag_dirproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repos, ++ const char *update_dir, ++ List *entries) + { + + if (ignore_directory (update_dir)) +@@ -1111,9 +1107,9 @@ struct val_args { + static int val_fileproc PROTO ((void *callerdat, struct file_info *finfo)); + + static int +-val_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++val_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + RCSNode *rcsdata; + struct val_args *args = (struct val_args *)callerdat; +@@ -1174,9 +1170,9 @@ val_fileproc (callerdat, finfo) + */ + static int is_in_val_tags PROTO((DBM **idb, const char *name)); + static int +-is_in_val_tags (idb, name) +- DBM **idb; +- const char *name; ++is_in_val_tags ( ++ DBM **idb, ++ const char *name) + { + DBM *db = NULL; + char *valtags_filename; +@@ -1263,8 +1259,7 @@ is_in_val_tags (idb, name) + */ + static void add_to_val_tags PROTO((const char *name)); + static void +-add_to_val_tags (name) +- const char *name; ++add_to_val_tags (const char *name) + { + DBM *db; + datum mytag; +@@ -1304,12 +1299,12 @@ static Dtype val_direntproc PROTO ((void *, const char *, const char *, + const char *, List *)); + + static Dtype +-val_direntproc (callerdat, dir, repository, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repository; +- const char *update_dir; +- List *entries; ++val_direntproc ( ++ void *callerdat, ++ const char *dir, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + /* This is not quite right--it doesn't get right the case of "cvs + update -d -r foobar" where foobar is a tag which exists only in +@@ -1333,13 +1328,13 @@ val_direntproc (callerdat, dir, repository, update_dir, entries) + tag is found in CVSROOTADM_VALTAGS, but there is not (yet) any + local directory. */ + void +-tag_check_valid (name, argc, argv, local, aflag, repository) +- char *name; +- int argc; +- char **argv; +- int local; +- int aflag; +- char *repository; ++tag_check_valid ( ++ char *name, ++ int argc, ++ char **argv, ++ int local, ++ int aflag, ++ char *repository) + { + struct val_args the_val_args; + struct saved_cwd cwd; +@@ -1425,13 +1420,13 @@ Numeric tag %s contains characters other than digits and '.'", name); + */ + + void +-tag_check_valid_join (join_tag, argc, argv, local, aflag, repository) +- char *join_tag; +- int argc; +- char **argv; +- int local; +- int aflag; +- char *repository; ++tag_check_valid_join ( ++ char *join_tag, ++ int argc, ++ char **argv, ++ int local, ++ int aflag, ++ char *repository) + { + char *c, *s; + +diff --git a/src/update.c b/src/update.c +index da8ff6c..d4c3269 100644 +--- a/src/update.c ++++ b/src/update.c +@@ -137,9 +137,9 @@ static const char *const update_usage[] = + * update is the argv,argc based front end for arg parsing + */ + int +-update (argc, argv) +- int argc; +- char **argv; ++update ( ++ int argc, ++ char **argv) + { + int c, err; + int local = 0; /* recursive by default */ +@@ -434,26 +434,24 @@ update (argc, argv) + * Command line interface to update (used by checkout) + */ + int +-do_update (argc, argv, xoptions, xtag, xdate, xforce, local, xbuild, xaflag, +- xprune, xpipeout, which, xjoin_rev1, xjoin_rev2, preload_update_dir, +- xdotemplate, repository) +- int argc; +- char **argv; +- char *xoptions; +- char *xtag; +- char *xdate; +- int xforce; +- int local; +- int xbuild; +- int xaflag; +- int xprune; +- int xpipeout; +- int which; +- char *xjoin_rev1; +- char *xjoin_rev2; +- char *preload_update_dir; +- int xdotemplate; +- char *repository; ++do_update ( ++ int argc, ++ char **argv, ++ char *xoptions, ++ char *xtag, ++ char *xdate, ++ int xforce, ++ int local, ++ int xbuild, ++ int xaflag, ++ int xprune, ++ int xpipeout, ++ int which, ++ char *xjoin_rev1, ++ char *xjoin_rev2, ++ char *preload_update_dir, ++ int xdotemplate, ++ char *repository) + { + int err = 0; + char *cp; +@@ -535,9 +533,9 @@ do_update (argc, argv, xoptions, xtag, xdate, xforce, local, xbuild, xaflag, + */ + + static int +-get_linkinfo_proc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++get_linkinfo_proc ( ++ void *callerdat, ++ struct file_info *finfo) + { + char *fullpath; + Node *linkp; +@@ -585,9 +583,9 @@ get_linkinfo_proc (callerdat, finfo) + * appropriate magic for checkout + */ + static int +-update_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++update_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + int retval; + Ctype status; +@@ -784,9 +782,9 @@ update_fileproc (callerdat, finfo) + static void update_ignproc PROTO ((const char *, const char *)); + + static void +-update_ignproc (file, dir) +- const char *file; +- const char *dir; ++update_ignproc ( ++ const char *file, ++ const char *dir) + { + struct file_info finfo; + char *tmp; +@@ -813,12 +811,12 @@ update_ignproc (file, dir) + + /* ARGSUSED */ + static int +-update_filesdone_proc (callerdat, err, repository, update_dir, entries) +- void *callerdat; +- int err; +- const char *repository; +- const char *update_dir; +- List *entries; ++update_filesdone_proc ( ++ void *callerdat, ++ int err, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + if (rewrite_tag) + { +@@ -863,12 +861,12 @@ update_filesdone_proc (callerdat, err, repository, update_dir, entries) + * recursion code should skip this directory. + */ + static Dtype +-update_dirent_proc (callerdat, dir, repository, update_dir, entries) +- void *callerdat; +- const char *dir; +- const char *repository; +- const char *update_dir; +- List *entries; ++update_dirent_proc ( ++ void *callerdat, ++ const char *dir, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + if (ignore_directory (update_dir)) + { +@@ -1016,12 +1014,12 @@ update_dirent_proc (callerdat, dir, repository, update_dir, entries) + */ + /* ARGSUSED */ + static int +-update_dirleave_proc (callerdat, dir, err, update_dir, entries) +- void *callerdat; +- const char *dir; +- int err; +- const char *update_dir; +- List *entries; ++update_dirleave_proc ( ++ void *callerdat, ++ const char *dir, ++ int err, ++ const char *update_dir, ++ List *entries) + { + /* Delete the ignore list if it hasn't already been done. */ + if (ignlist) +@@ -1073,9 +1071,9 @@ static int isremoved PROTO ((Node *, void *)); + + /* Returns 1 if the file indicated by node has been removed. */ + static int +-isremoved (node, closure) +- Node *node; +- void *closure; ++isremoved ( ++ Node *node, ++ void *closure) + { + Entnode *entdata = node->data; + +@@ -1090,9 +1088,9 @@ isremoved (node, closure) + existence of the CVS directory entry. Zero otherwise. If MIGHT_NOT_EXIST + and the directory doesn't exist, then just return 0. */ + int +-isemptydir (dir, might_not_exist) +- const char *dir; +- int might_not_exist; ++isemptydir ( ++ const char *dir, ++ int might_not_exist) + { + DIR *dirp; + struct dirent *dp; +@@ -1168,9 +1166,9 @@ isemptydir (dir, might_not_exist) + * scratch the Entries file entry associated with a file + */ + static int +-scratch_file (finfo, vers) +- struct file_info *finfo; +- Vers_TS *vers; ++scratch_file ( ++ struct file_info *finfo, ++ Vers_TS *vers) + { + history_write ('W', finfo->update_dir, "", finfo->file, finfo->repository); + Scratch_Entry (finfo->entries, finfo->file); +@@ -1214,12 +1212,12 @@ scratch_file (finfo, vers) + * Check out a file. + */ + static int +-checkout_file (finfo, vers_ts, adding, merging, update_server) +- struct file_info *finfo; +- Vers_TS *vers_ts; +- int adding; +- int merging; +- int update_server; ++checkout_file ( ++ struct file_info *finfo, ++ Vers_TS *vers_ts, ++ int adding, ++ int merging, ++ int update_server) + { + char *backup; + int set_time, retval = 0; +@@ -1510,10 +1508,10 @@ VERS: ", 0); + into a buffer. */ + + static void +-checkout_to_buffer (callerdat, data, len) +- void *callerdat; +- const char *data; +- size_t len; ++checkout_to_buffer ( ++ void *callerdat, ++ const char *data, ++ size_t len) + { + struct buffer *buf = (struct buffer *) callerdat; + +@@ -1546,12 +1544,12 @@ struct patch_file_data + * itself. + */ + static int +-patch_file (finfo, vers_ts, docheckout, file_info, checksum) +- struct file_info *finfo; +- Vers_TS *vers_ts; +- int *docheckout; +- struct stat *file_info; +- unsigned char *checksum; ++patch_file ( ++ struct file_info *finfo, ++ Vers_TS *vers_ts, ++ int *docheckout, ++ struct stat *file_info, ++ unsigned char *checksum) + { + char *backup; + char *file1; +@@ -1848,10 +1846,10 @@ patch_file (finfo, vers_ts, docheckout, file_info, checksum) + patch_file via RCS_checkout. */ + + static void +-patch_file_write (callerdat, buffer, len) +- void *callerdat; +- const char *buffer; +- size_t len; ++patch_file_write ( ++ void *callerdat, ++ const char *buffer, ++ size_t len) + { + struct patch_file_data *data = (struct patch_file_data *) callerdat; + +@@ -1871,9 +1869,9 @@ patch_file_write (callerdat, buffer, len) + * of a single letter and the name. + */ + void +-write_letter (finfo, letter) +- struct file_info *finfo; +- int letter; ++write_letter ( ++ struct file_info *finfo, ++ int letter) + { + if (!really_quiet) + { +@@ -1918,11 +1916,11 @@ static void + RegisterMerge PROTO((struct file_info *finfo, Vers_TS *vers, + const char *backup, int has_conflicts)); + static void +-RegisterMerge (finfo, vers, backup, has_conflicts) +- struct file_info *finfo; +- Vers_TS *vers; +- const char *backup; +- int has_conflicts; ++RegisterMerge ( ++ struct file_info *finfo, ++ Vers_TS *vers, ++ const char *backup, ++ int has_conflicts) + { + /* This file is the result of a merge, which means that it has + been modified. We use a special timestamp string which will +@@ -1958,9 +1956,9 @@ RegisterMerge (finfo, vers, backup, has_conflicts) + * Do all the magic associated with a file which needs to be merged + */ + static int +-merge_file (finfo, vers) +- struct file_info *finfo; +- Vers_TS *vers; ++merge_file ( ++ struct file_info *finfo, ++ Vers_TS *vers) + { + char *backup; + int status; +@@ -2129,9 +2127,9 @@ merge_file (finfo, vers) + * 1. Is not called in client mode. + */ + static void +-join_file (finfo, vers) +- struct file_info *finfo; +- Vers_TS *vers; ++join_file ( ++ struct file_info *finfo, ++ Vers_TS *vers) + { + char *backup; + char *t_options; +@@ -2733,10 +2731,10 @@ out: + */ + + int +-special_file_mismatch (finfo, rev1, rev2) +- struct file_info *finfo; +- char *rev1; +- char *rev2; ++special_file_mismatch ( ++ struct file_info *finfo, ++ char *rev1, ++ char *rev2) + { + #ifdef PRESERVE_PERMISSIONS_SUPPORT + struct stat sb; +diff --git a/src/vers_ts.c b/src/vers_ts.c +index e4734f3..588edd0 100644 +--- a/src/vers_ts.c ++++ b/src/vers_ts.c +@@ -23,17 +23,17 @@ static void time_stamp_server PROTO((const char *, Vers_TS *, Entnode *)); + DATE are from the command line. */ + + Vers_TS * +-Version_TS (finfo, options, tag, date, force_tag_match, set_time) +- struct file_info *finfo; ++Version_TS ( ++ struct file_info *finfo, + + /* Keyword expansion options, I think generally from the command + line. Can be either NULL or "" to indicate none are specified + here. */ +- char *options; +- char *tag; +- char *date; +- int force_tag_match; +- int set_time; ++ char *options, ++ char *tag, ++ char *date, ++ int force_tag_match, ++ int set_time) + { + Node *p; + RCSNode *rcsdata; +@@ -276,10 +276,10 @@ Version_TS (finfo, options, tag, date, force_tag_match, set_time) + #define mark_unchanged(V) ((V)->ts_user = xstrdup ((V)->ts_rcs)) + + static void +-time_stamp_server (file, vers_ts, entdata) +- const char *file; +- Vers_TS *vers_ts; +- Entnode *entdata; ++time_stamp_server ( ++ const char *file, ++ Vers_TS *vers_ts, ++ Entnode *entdata) + { + struct stat sb; + char *cp; +@@ -353,8 +353,7 @@ time_stamp_server (file, vers_ts, entdata) + * allocates + */ + char * +-time_stamp (file) +- const char *file; ++time_stamp (const char *file) + { + struct stat sb; + char *cp; +@@ -409,8 +408,7 @@ time_stamp (file) + * free up a Vers_TS struct + */ + void +-freevers_ts (versp) +- Vers_TS **versp; ++freevers_ts (Vers_TS **versp) + { + if ((*versp)->srcfile) + freercsnode (&((*versp)->srcfile)); +diff --git a/src/version.c b/src/version.c +index 09f99f4..dc0fbc7 100644 +--- a/src/version.c ++++ b/src/version.c +@@ -48,9 +48,9 @@ static const char *const version_usage[] = + * command). + */ + int +-version (argc, argv) +- int argc; +- char **argv; ++version ( ++ int argc, ++ char **argv) + { + int err = 0; + +diff --git a/src/watch.c b/src/watch.c +index 0ef987c..163538b 100644 +--- a/src/watch.c ++++ b/src/watch.c +@@ -31,9 +31,9 @@ const char *const watch_usage[] = + static struct addremove_args the_args; + + void +-watch_modify_watchers (file, what) +- const char *file; +- struct addremove_args *what; ++watch_modify_watchers ( ++ const char *file, ++ struct addremove_args *what) + { + char *curattr = fileattr_get0 (file, "_watchers"); + char *p; +@@ -217,9 +217,9 @@ static int addremove_fileproc PROTO ((void *callerdat, + struct file_info *finfo)); + + static int +-addremove_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++addremove_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + watch_modify_watchers (finfo->file, &the_args); + return 0; +@@ -231,12 +231,12 @@ static int addremove_filesdoneproc PROTO ((void *, int, const char *, + const char *, List *)); + + static int +-addremove_filesdoneproc (callerdat, err, repository, update_dir, entries) +- void *callerdat; +- int err; +- const char *repository; +- const char *update_dir; +- List *entries; ++addremove_filesdoneproc ( ++ void *callerdat, ++ int err, ++ const char *repository, ++ const char *update_dir, ++ List *entries) + { + if (the_args.setting_default) + watch_modify_watchers (NULL, &the_args); +@@ -246,9 +246,9 @@ addremove_filesdoneproc (callerdat, err, repository, update_dir, entries) + static int watch_addremove PROTO ((int argc, char **argv)); + + static int +-watch_addremove (argc, argv) +- int argc; +- char **argv; ++watch_addremove ( ++ int argc, ++ char **argv) + { + int c; + int local = 0; +@@ -351,27 +351,27 @@ watch_addremove (argc, argv) + } + + int +-watch_add (argc, argv) +- int argc; +- char **argv; ++watch_add ( ++ int argc, ++ char **argv) + { + the_args.adding = 1; + return watch_addremove (argc, argv); + } + + int +-watch_remove (argc, argv) +- int argc; +- char **argv; ++watch_remove ( ++ int argc, ++ char **argv) + { + the_args.adding = 0; + return watch_addremove (argc, argv); + } + + int +-watch (argc, argv) +- int argc; +- char **argv; ++watch ( ++ int argc, ++ char **argv) + { + if (argc <= 1) + usage (watch_usage); +@@ -417,9 +417,9 @@ static int watchers_fileproc PROTO ((void *callerdat, + struct file_info *finfo)); + + static int +-watchers_fileproc (callerdat, finfo) +- void *callerdat; +- struct file_info *finfo; ++watchers_fileproc ( ++ void *callerdat, ++ struct file_info *finfo) + { + char *them; + char *p; +@@ -469,9 +469,9 @@ watchers_fileproc (callerdat, finfo) + } + + int +-watchers (argc, argv) +- int argc; +- char **argv; ++watchers ( ++ int argc, ++ char **argv) + { + int local = 0; + int c; +diff --git a/src/wrapper.c b/src/wrapper.c +index 35adf14..b18d944 100644 +--- a/src/wrapper.c ++++ b/src/wrapper.c +@@ -196,9 +196,9 @@ wrap_send () + * + * If first_call_p is nonzero, then start afresh. */ + void +-wrap_unparse_rcs_options (line, first_call_p) +- char **line; +- int first_call_p; ++wrap_unparse_rcs_options ( ++ char **line, ++ int first_call_p) + { + /* FIXME-reentrancy: we should design a reentrant interface, like + a callback which gets handed each wrapper (a multithreaded +@@ -264,9 +264,9 @@ wrap_clean_fmt_str(char *fmt, int max_s) + * argument is set. + */ + void +-wrap_add_file (file, temp) +- const char *file; +- int temp; ++wrap_add_file ( ++ const char *file, ++ int temp) + { + FILE *fp; + char *line = NULL; +@@ -312,16 +312,14 @@ wrap_kill_temp() + } + + void +-wrap_free_entry(e) +- WrapperEntry *e; ++wrap_free_entry(WrapperEntry *e) + { + wrap_free_entry_internal(e); + free(e); + } + + void +-wrap_free_entry_internal(e) +- WrapperEntry *e; ++wrap_free_entry_internal(WrapperEntry *e) + { + free (e->wildCard); + if (e->tocvsFilter) +@@ -352,9 +350,9 @@ wrap_restore_saved() + } + + void +-wrap_add (line, isTemp) +- char *line; +- int isTemp; ++wrap_add ( ++ char *line, ++ int isTemp) + { + char *temp; + char ctemp; +@@ -468,9 +466,9 @@ wrap_add (line, isTemp) + } + + void +-wrap_add_entry(e, temp) +- WrapperEntry *e; +- int temp; ++wrap_add_entry( ++ WrapperEntry *e, ++ int temp) + { + int x; + if(wrap_count+wrap_tempcount>=wrap_size){ +@@ -492,9 +490,9 @@ wrap_add_entry(e, temp) + + /* Return 1 if the given filename is a wrapper filename */ + int +-wrap_name_has (name,has) +- const char *name; +- WrapMergeHas has; ++wrap_name_has ( ++ const char *name, ++ WrapMergeHas has) + { + int x,count=wrap_count+wrap_tempcount; + char *temp; +@@ -525,8 +523,7 @@ wrap_name_has (name,has) + static WrapperEntry *wrap_matching_entry PROTO ((const char *)); + + static WrapperEntry * +-wrap_matching_entry (name) +- const char *name; ++wrap_matching_entry (const char *name) + { + int x,count=wrap_count+wrap_tempcount; + +@@ -540,9 +537,9 @@ wrap_matching_entry (name) + ASFLAG, then include "-k" at the beginning (e.g. "-kb"), otherwise + just give the option itself (e.g. "b"). */ + char * +-wrap_rcsoption (filename, asflag) +- const char *filename; +- int asflag; ++wrap_rcsoption ( ++ const char *filename, ++ int asflag) + { + WrapperEntry *e = wrap_matching_entry (filename); + char *buf; +@@ -564,8 +561,7 @@ wrap_rcsoption (filename, asflag) + } + + char * +-wrap_tocvs_process_file(fileName) +- const char *fileName; ++wrap_tocvs_process_file(const char *fileName) + { + WrapperEntry *e=wrap_matching_entry(fileName); + static char *buf = NULL; +@@ -592,8 +588,7 @@ wrap_tocvs_process_file(fileName) + } + + int +-wrap_merge_is_copy (fileName) +- const char *fileName; ++wrap_merge_is_copy (const char *fileName) + { + WrapperEntry *e=wrap_matching_entry(fileName); + if(e==NULL || e->mergeMethod==WRAP_MERGE) +@@ -603,8 +598,7 @@ wrap_merge_is_copy (fileName) + } + + void +-wrap_fromcvs_process_file(fileName) +- const char *fileName; ++wrap_fromcvs_process_file(const char *fileName) + { + char *args; + WrapperEntry *e=wrap_matching_entry(fileName); +diff --git a/src/zlib.c b/src/zlib.c +index 46ed0e6..6acc91b 100644 +--- a/src/zlib.c ++++ b/src/zlib.c +@@ -57,11 +57,11 @@ static int compress_buffer_shutdown_output PROTO((struct buffer *)); + /* Report an error from one of the zlib functions. */ + + static void +-compress_error (status, zstatus, zstr, msg) +- int status; +- int zstatus; +- z_stream *zstr; +- const char *msg; ++compress_error ( ++ int status, ++ int zstatus, ++ z_stream *zstr, ++ const char *msg) + { + int hold_errno; + const char *zmsg; +@@ -84,11 +84,11 @@ compress_error (status, zstatus, zstr, msg) + /* Create a compression buffer. */ + + struct buffer * +-compress_buffer_initialize (buf, input, level, memory) +- struct buffer *buf; +- int input; +- int level; +- void (*memory) PROTO((struct buffer *)); ++compress_buffer_initialize ( ++ struct buffer *buf, ++ int input, ++ int level, ++ void (*memory) PROTO((struct buffer *))) + { + struct compress_buffer *n; + int zstatus; +@@ -129,12 +129,12 @@ compress_buffer_initialize (buf, input, level, memory) + /* Input data from a compression buffer. */ + + static int +-compress_buffer_input (closure, data, need, size, got) +- void *closure; +- char *data; +- int need; +- int size; +- int *got; ++compress_buffer_input ( ++ void *closure, ++ char *data, ++ int need, ++ int size, ++ int *got) + { + struct compress_buffer *cb = (struct compress_buffer *) closure; + struct buffer_data *bd; +@@ -248,11 +248,11 @@ compress_buffer_input (closure, data, need, size, got) + /* Output data to a compression buffer. */ + + static int +-compress_buffer_output (closure, data, have, wrote) +- void *closure; +- const char *data; +- int have; +- int *wrote; ++compress_buffer_output ( ++ void *closure, ++ const char *data, ++ int have, ++ int *wrote) + { + struct compress_buffer *cb = (struct compress_buffer *) closure; + +@@ -290,8 +290,7 @@ compress_buffer_output (closure, data, have, wrote) + /* Flush a compression buffer. */ + + static int +-compress_buffer_flush (closure) +- void *closure; ++compress_buffer_flush (void *closure) + { + struct compress_buffer *cb = (struct compress_buffer *) closure; + +@@ -340,9 +339,9 @@ compress_buffer_flush (closure) + /* The block routine for a compression buffer. */ + + static int +-compress_buffer_block (closure, block) +- void *closure; +- int block; ++compress_buffer_block ( ++ void *closure, ++ int block) + { + struct compress_buffer *cb = (struct compress_buffer *) closure; + +@@ -355,8 +354,7 @@ compress_buffer_block (closure, block) + /* Shut down an input buffer. */ + + static int +-compress_buffer_shutdown_input (buf) +- struct buffer *buf; ++compress_buffer_shutdown_input (struct buffer *buf) + { + struct compress_buffer *cb = (struct compress_buffer *) buf->closure; + int zstatus; +@@ -379,8 +377,7 @@ compress_buffer_shutdown_input (buf) + /* Shut down an output buffer. */ + + static int +-compress_buffer_shutdown_output (buf) +- struct buffer *buf; ++compress_buffer_shutdown_output (struct buffer *buf) + { + struct compress_buffer *cb = (struct compress_buffer *) buf->closure; + int zstatus, status; +@@ -444,11 +441,11 @@ compress_buffer_shutdown_output (buf) + it is an error we can't recover from. */ + + int +-gunzip_and_write (fd, fullname, buf, size) +- int fd; +- char *fullname; +- unsigned char *buf; +- size_t size; ++gunzip_and_write ( ++ int fd, ++ char *fullname, ++ unsigned char *buf, ++ size_t size) + { + size_t pos; + z_stream zstr; +@@ -608,13 +605,13 @@ gunzip_and_write (fd, fullname, buf, size) + recover from it). LEVEL is the compression level (1-9). */ + + int +-read_and_gzip (fd, fullname, buf, size, len, level) +- int fd; +- const char *fullname; +- unsigned char **buf; +- size_t *size; +- size_t *len; +- int level; ++read_and_gzip ( ++ int fd, ++ const char *fullname, ++ unsigned char **buf, ++ size_t *size, ++ size_t *len, ++ int level) + { + z_stream zstr; + int zstatus; +-- +2.48.1 + diff --git a/cvs-1.11.23-c99.patch b/cvs-1.11.23-c99.patch new file mode 100644 index 0000000..623a27d --- /dev/null +++ b/cvs-1.11.23-c99.patch @@ -0,0 +1,40 @@ +Downstream-only patch. CVS hasn't had a release since 2008. + +diff --git a/lib/getdate.c b/lib/getdate.c +index 5180358c85f8a050..18a6ce0416aa188b 100644 +--- a/lib/getdate.c ++++ b/lib/getdate.c +@@ -1019,7 +1019,7 @@ main(ac, av) + + (void)printf("Enter date, or blank line to exit.\n\t> "); + (void)fflush(stdout); +- while (gets(buff) && buff[0]) { ++ while (fgets(buff, sizeof(buff) - 1, stdin) && buff[0]) { + d = get_date(buff, (struct timeb *)NULL); + if (d == -1) + (void)printf("Bad format - couldn't convert.\n"); +diff --git a/lib/getdate.y b/lib/getdate.y +index 0e128d74ef609818..007318cd0aef2623 100644 +--- a/lib/getdate.y ++++ b/lib/getdate.y +@@ -1015,7 +1015,7 @@ main(ac, av) + + (void)printf("Enter date, or blank line to exit.\n\t> "); + (void)fflush(stdout); +- while (gets(buff) && buff[0]) { ++ while (fgets(buff, sizeof(buff) - 1, stdin) && buff[0]) { + d = get_date(buff, (struct timeb *)NULL); + if (d == -1) + (void)printf("Bad format - couldn't convert.\n"); +diff --git a/src/cvs.h b/src/cvs.h +index a7f4b2f6bd6c67fb..cd6ffc9bbd7859aa 100644 +--- a/src/cvs.h ++++ b/src/cvs.h +@@ -486,6 +486,7 @@ extern int parse_config PROTO ((char *)); + + typedef RETSIGTYPE (*SIGCLEANUPPROC) PROTO(()); + int SIG_register PROTO((int sig, SIGCLEANUPPROC sigcleanup)); ++int SIG_deregister PROTO((int sig, SIGCLEANUPPROC sigcleanup)); + int isdir PROTO((const char *file)); + int isfile PROTO((const char *file)); + int islink PROTO((const char *file)); diff --git a/cvs-1.11.23-tests-Call-nonobsolete-grep-F.patch b/cvs-1.11.23-tests-Call-nonobsolete-grep-F.patch new file mode 100644 index 0000000..2d67439 --- /dev/null +++ b/cvs-1.11.23-tests-Call-nonobsolete-grep-F.patch @@ -0,0 +1,45 @@ +From b2885fda8c6c74d8bb03a978ac29072fcfb13cb8 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Petr=20P=C3=ADsa=C5=99?= +Date: Fri, 21 Apr 2023 11:58:42 +0200 +Subject: [PATCH] tests: Call nonobsolete grep -F +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +basic2-27 fails with grep-3.9 because grep warns when called as fgrep: + +PASS: basic2-26c +** expected: + +** got: +fgrep: warning: fgrep is obsolescent; using grep -F +fgrep: warning: fgrep is obsolescent; using grep -F +FAIL: basic2-27 + +Signed-off-by: Petr Písař +--- + src/sanity.sh | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/sanity.sh b/src/sanity.sh +index dbcae19..83eb956 100755 +--- a/src/sanity.sh ++++ b/src/sanity.sh +@@ -1255,12 +1255,12 @@ directory_cmp () + DIR_2=$2 + + cd $DIR_1 +- find . -print | fgrep -v /CVS | sort > $TESTDIR/dc$$d1 ++ find . -print | grep -F -v /CVS | sort > $TESTDIR/dc$$d1 + + # go back where we were to avoid symlink hell... + cd $OLDPWD + cd $DIR_2 +- find . -print | fgrep -v /CVS | sort > $TESTDIR/dc$$d2 ++ find . -print | grep -F -v /CVS | sort > $TESTDIR/dc$$d2 + + if diff $TESTDIR/dc$$d1 $TESTDIR/dc$$d2 >/dev/null 2>&1 + then +-- +2.40.0 + diff --git a/cvs.spec b/cvs.spec index 404bfb4..38b1db9 100644 --- a/cvs.spec +++ b/cvs.spec @@ -1,6 +1,6 @@ Name: cvs Version: 1.11.23 -Release: 53 +Release: 54 Summary: Version control system License: BSD and GPL+ and GPLv2+ and LGPLv2+ and zlib and Public Domain URL: http://cvs.nongnu.org/ @@ -44,6 +44,14 @@ Patch31: cvs-1.11.23-Pass-compilation-with-Wformat-security.patch Patch32: cvs-1.11.23-Fix-CVE-2017-12836.patch Patch33: cvs-1.11.23-Close-a-configuration-file-on-a-syntax-error.patch Patch34: cvs-1.11.23-Use-diff-label.patch +# Enable cvs to build in C99 mode, bug #2187741 +Patch35: cvs-1.11.23-c99.patch +# Adjust tests to grep-3.9, proposed to the upstream, +# +Patch36: cvs-1.11.23-tests-Call-nonobsolete-grep-F.patch +# Adapt to changes in GCC 15, bug #2340021, proposed to the upstream, +# +Patch37: cvs-1.11.23-Adapt-to-changes-in-GCC-15.patch BuildRequires: autoconf automake coreutils glibc-common gzip krb5-devel vim-minimal BuildRequires: libtool make pam-devel perl-generators systemd texinfo zlib-devel xinetd @@ -136,5 +144,8 @@ make check %exclude %{_infodir}/dir %changelog +* Mon Aug 04 2025 wangkai <13474090681@163.com> - 1.11.23-54 +- Add patches from fedora, improve C compatibility and fix build failures caused by higher gcc versions + * Tue Feb 11 2020 duyeyu - 1.11.23-53 - Package init -- Gitee