int safe_read ();
-static char *xrealloc ();
-static char *xmalloc ();
-static void cleanup ();
-static void close_output_file ();
-static void create_output_file ();
-static void save_line_to_file ();
-static void usage ();
+static char *xrealloc (char *p, unsigned int n);
+static char *xmalloc (unsigned int n);
+static void cleanup (void);
+static void close_output_file (void);
+static void create_output_file (void);
+static void save_line_to_file (struct cstring *line);
+static void usage (int status);
#ifndef TRUE
#define FALSE 0
/* Allocate N bytes of memory dynamically, with error checking. */
static char *
-xmalloc (n)
- unsigned int n;
+xmalloc (unsigned int n)
{
char *p;
If N is 0, run free and return NULL. */
static char *
-xrealloc (p, n)
- char *p;
- unsigned int n;
+xrealloc (char *p, unsigned int n)
{
if (p == NULL)
return xmalloc (n);
start of the new buffer. */
static void
-save_to_hold_area (start, num)
- char *start;
- unsigned int num;
+save_to_hold_area (char *start, unsigned int num)
{
hold_area = start;
hold_count = num;
Return the number of chars read. */
static int
-read_input (dest, max_n_bytes)
- char *dest;
- unsigned int max_n_bytes;
+read_input (char *dest, unsigned int max_n_bytes)
{
int bytes_read;
/* Initialize existing line record P. */
static void
-clear_line_control (p)
- struct line *p;
+clear_line_control (struct line *p)
{
p->used = 0;
p->insert_index = 0;
/* Initialize all line records in B. */
static void
-clear_all_line_control (b)
- struct buffer_record *b;
+clear_all_line_control (struct buffer_record *b)
{
struct line *l;
/* Return a new, initialized line record. */
static struct line *
-new_line_control ()
+new_line_control (void)
{
struct line *p;
of length LINE_LEN in the large buffer, in the lines buffer of B. */
static void
-keep_new_line (b, line_start, line_len)
- struct buffer_record *b;
- char *line_start;
- int line_len;
+keep_new_line (struct buffer_record *b, char *line_start, int line_len)
{
struct line *l;
the next buffer is filled. */
static unsigned int
-record_line_starts (b)
- struct buffer_record *b;
+record_line_starts (struct buffer_record *b)
{
char *line_start; /* Start of current line. */
char *line_end; /* End of each line found. */
an extra byte for safety. */
static struct buffer_record *
-create_new_buffer (size)
- unsigned int size;
+create_new_buffer (unsigned int size)
{
struct buffer_record *new_buffer;
least that size is currently free, use it, otherwise create a new one. */
static struct buffer_record *
-get_new_buffer (min_size)
- unsigned int min_size;
+get_new_buffer (unsigned int min_size)
{
struct buffer_record *p, *q;
struct buffer_record *new_buffer; /* Buffer to return. */
/* Add buffer BUF to the list of free buffers. */
static void
-free_buffer (buf)
- struct buffer_record *buf;
+free_buffer (struct buffer_record *buf)
{
buf->next = free_list;
free_list = buf;
some data yet to be processed. */
static void
-save_buffer (buf)
- struct buffer_record *buf;
+save_buffer (struct buffer_record *buf)
{
struct buffer_record *p;
(in which case end-of-file must have been encountered). */
static boolean
-load_buffer ()
+load_buffer (void)
{
struct buffer_record *b;
unsigned int bytes_wanted = START_SIZE; /* Minimum buffer size. */
/* Return the line number of the first line that has not yet been retrieved. */
static unsigned int
-get_first_line_in_buffer ()
+get_first_line_in_buffer (void)
{
if (head == NULL && !load_buffer ())
error (1, errno, _("input disappeared"));
Return NULL if there is no more input. */
static struct cstring *
-remove_line ()
+remove_line (void)
{
struct cstring *line; /* Return value. */
struct line *l; /* For convenience. */
Return a pointer to the line, or NULL if it is not found in the file. */
static struct cstring *
-find_line (linenum)
- unsigned int linenum;
+find_line (unsigned int linenum)
{
struct buffer_record *b;
/* Return TRUE if at least one more line is available for input. */
static boolean
-no_more_lines ()
+no_more_lines (void)
{
return (find_line (current_line + 1) == NULL) ? TRUE : FALSE;
}
/* Set the name of the input file to NAME and open it. */
static void
-set_input_file (name)
- char *name;
+set_input_file (char *name)
{
if (!strcmp (name, "-"))
input_desc = 0;
ARGNUM is the index in ARGV of the current pattern. */
static void
-write_to_file (last_line, ignore, argnum)
- unsigned int last_line;
- boolean ignore;
- int argnum;
+write_to_file (unsigned int last_line, boolean ignore, int argnum)
{
struct cstring *line;
unsigned int first_line; /* First available input line. */
/* Output any lines left after all regexps have been processed. */
static void
-dump_rest_of_file ()
+dump_rest_of_file (void)
{
struct cstring *line;
on iteration REPETITION if nonzero. */
static void
-handle_line_error (p, repetition)
- struct control *p;
- int repetition;
+handle_line_error (struct control *p, int repetition)
{
fprintf (stderr, _("%s: `%d': line number out of range"),
program_name, p->lines_required);
REPETITION is the repetition number. */
static void
-process_line_count (p, repetition)
- struct control *p;
- int repetition;
+process_line_count (struct control *p, int repetition)
{
unsigned int linenum;
unsigned int last_line_to_save = p->lines_required * (repetition + 1);
}
static void
-regexp_error (p, repetition, ignore)
- struct control *p;
- int repetition;
- boolean ignore;
+regexp_error (struct control *p, int repetition, boolean ignore)
{
fprintf (stderr, _("%s: `%s': match not found"),
program_name, global_argv[p->argnum]);
REPETITION is this repeat-count; 0 means the first time. */
static void
-process_regexp (p, repetition)
- struct control *p;
- int repetition;
+process_regexp (struct control *p, int repetition)
{
struct cstring *line; /* From input file. */
unsigned int line_len; /* To make "$" in regexps work. */
/* Split the input file according to the control records we have built. */
static void
-split_file ()
+split_file (void)
{
unsigned int i, j;
/* Return the name of output file number NUM. */
static char *
-make_filename (num)
- unsigned int num;
+make_filename (unsigned int num)
{
strcpy (filename_space, prefix);
if (suffix)
/* Create the next output file. */
static void
-create_output_file ()
+create_output_file (void)
{
output_filename = make_filename (files_created);
output_stream = fopen (output_filename, "w");
/* Delete all the files we have created. */
static void
-delete_all_files ()
+delete_all_files (void)
{
unsigned int i;
char *name;
of characters in this file. */
static void
-close_output_file ()
+close_output_file (void)
{
if (output_stream)
{
Called when an error detected. */
static void
-cleanup ()
+cleanup (void)
{
if (output_stream)
close_output_file ();
increment the character count for the current file. */
static void
-save_line_to_file (line)
- struct cstring *line;
+save_line_to_file (struct cstring *line)
{
fwrite (line->str, sizeof (char), line->len, output_stream);
bytes_written += line->len;
/* Return a new, initialized control record. */
static struct control *
-new_control_record ()
+new_control_record (void)
{
static unsigned control_allocated = 0; /* Total space allocated. */
struct control *p;
/* FIXME: use xstrtoul in place of this function. */
static boolean
-string_to_number (result, num)
- int *result;
- char *num;
+string_to_number (int *result, char *num)
{
char ch;
int val = 0;
NUM is the numeric part of STR. */
static void
-check_for_offset (p, str, num)
- struct control *p;
- char *str;
- char *num;
+check_for_offset (struct control *p, char *str, char *num)
{
if (*num != '-' && *num != '+')
error (1, 0, _("%s: `+' or `-' expected after delimeter"), str);
ARGNUM is the ARGV index of STR. */
static void
-parse_repeat_count (argnum, p, str)
- int argnum;
- struct control *p;
- char *str;
+parse_repeat_count (int argnum, struct control *p, char *str)
{
char *end;
Unless IGNORE is TRUE, mark these lines for output. */
static struct control *
-extract_regexp (argnum, ignore, str)
- int argnum;
- boolean ignore;
- char *str;
+extract_regexp (int argnum, boolean ignore, char *str)
{
int len; /* Number of chars in this regexp. */
char delim = *str;
After each pattern, check if the next argument is a repeat count. */
static void
-parse_patterns (argc, start, argv)
- int argc;
- int start;
- char **argv;
+parse_patterns (int argc, int start, char **argv)
{
int i; /* Index into ARGV. */
struct control *p; /* New control record created. */
}
static unsigned
-get_format_flags (format_ptr)
- char **format_ptr;
+get_format_flags (char **format_ptr)
{
unsigned count = 0;
}
static unsigned
-get_format_width (format_ptr)
- char **format_ptr;
+get_format_width (char **format_ptr)
{
unsigned count = 0;
char *start;
}
static unsigned
-get_format_prec (format_ptr)
- char **format_ptr;
+get_format_prec (char **format_ptr)
{
unsigned count = 0;
char *start;
}
static void
-get_format_conv_type (format_ptr)
- char **format_ptr;
+get_format_conv_type (char **format_ptr)
{
int ch = *((*format_ptr)++);
}
static unsigned
-max_out (format)
- char *format;
+max_out (char *format)
{
unsigned out_count = 0;
unsigned percents = 0;
}
static void
-interrupt_handler (signum)
- int signum;
+interrupt_handler (int signum)
{
error (0, 0, _("interrupted"));
cleanup ();
}
void
-main (argc, argv)
- int argc;
- char **argv;
+main (int argc, char **argv)
{
int optc;
#ifdef SA_INTERRUPT
}
static void
-usage (status)
- int status;
+usage (int status)
{
if (status != 0)
fprintf (stderr, _("Try `%s --help' for more information.\n"),
projects / platform / upstream / coreutils.git / commitdiff