gzip: local → static

* gzip.h (local): Remove.  All uses replaced by ‘static’.
Previously, the source code was inconsistent about using ‘local’
vs ‘static’ even before the recent changes, and ‘local’ was
more trouble than it was worth.

7 files changed, 154 insertions, 135 deletions

diff --git a/bits.c b/bits.c
index 0c4a6aa..23b65f9 100644
--- a/bits.c
+++ b/bits.c
@@ -76,7 +76,7 @@
  * Local data used by the "bit string" routines.
  */
 
-local file_t zfile; /* output gzip file */
+static file_t zfile; /* output gzip file */
 
 #ifndef IBM_Z_DFLTCC
 static
diff --git a/deflate.c b/deflate.c
index 1a47bc6..d95f454 100644
--- a/deflate.c
+++ b/deflate.c
@@ -176,7 +176,7 @@ long block_start;
  * negative when the window is moved backwards.
  */
 
-local unsigned ins_h;  /* hash index of string to be inserted */
+static unsigned ins_h;  /* hash index of string to be inserted */
 
 #define H_SHIFT  ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH)
 /* Number of bits by which ins_h and del_h must be shifted at each
@@ -192,15 +192,15 @@ local unsigned ins_h;  /* hash index of string to be inserted */
 
       unsigned near strstart;      /* start of string to insert */
       unsigned near match_start;   /* start of matching string */
-local int           eofile;        /* flag set at end of input file */
-local unsigned      lookahead;     /* number of valid bytes ahead in window */
+static int eofile;		   /* flag set at end of input file */
+static unsigned lookahead;	   /* number of valid bytes ahead in window */
 
        unsigned max_chain_length;
 /* To speed up deflation, hash chains are never searched beyond this length.
  * A higher limit improves compression ratio but degrades the speed.
  */
 
-local unsigned int max_lazy_match;
+static unsigned int max_lazy_match;
 /* Attempt to find a better match only when the current match is strictly
  * smaller than this value. This mechanism is used only for compression
  * levels >= 4.
@@ -214,8 +214,8 @@ local unsigned int max_lazy_match;
 unsigned good_match;
 /* Use a faster search when the previous match is longer than this */
 
-local ulg rsync_sum;  /* rolling sum of rsync window */
-local ulg rsync_chunk_end; /* next rsync sequence point */
+static ulg rsync_sum;  /* rolling sum of rsync window */
+static ulg rsync_chunk_end; /* next rsync sequence point */
 
 /* Values for max_lazy_match, good_match and max_chain_length, depending on
  * the desired pack level (0..9). The values given below have been tuned to
@@ -243,7 +243,7 @@ typedef struct config {
   static_unless_ASMV int nice_match;
 #endif
 
-local config configuration_table[10] = {
+static config configuration_table[10] = {
 /*      good lazy nice chain */
 /* 0 */ {0,    0,  0,    0},  /* store only */
 /* 1 */ {4,    4,  8,    4},  /* maximum speed, no lazy matches */
@@ -265,8 +265,8 @@ local config configuration_table[10] = {
 /* ===========================================================================
  *  Prototypes for local functions.
  */
-local void fill_window   (void);
-local off_t deflate_fast (void);
+static void fill_window (void);
+static off_t deflate_fast (void);
 
 #ifdef ASMV
       int  longest_match (IPos cur_match);
@@ -274,7 +274,7 @@ local off_t deflate_fast (void);
 #endif
 
 #ifdef DEBUG
-local  void check_match (IPos start, IPos match, int length);
+static void check_match (IPos start, IPos match, int length);
 #endif
 
 /* ===========================================================================
@@ -528,7 +528,8 @@ check_match (IPos start, IPos match, int length)
  *    file reads are performed for at least two bytes (required for the
  *    translate_eol option).
  */
-local void fill_window()
+static void
+fill_window ()
 {
     register unsigned n, m;
     unsigned more = (unsigned)(window_size - (ulg)lookahead - (ulg)strstart);
@@ -584,7 +585,8 @@ local void fill_window()
 
 /* With an initial offset of START, advance rsync's rolling checksum
    by NUM bytes.  */
-local void rsync_roll(unsigned int start, unsigned int num)
+static void
+rsync_roll (unsigned int start, unsigned int num)
 {
     unsigned i;
 
@@ -630,7 +632,8 @@ local void rsync_roll(unsigned int start, unsigned int num)
  * new strings in the dictionary only for unmatched strings or for short
  * matches. It is used only for the fast compression options.
  */
-local off_t deflate_fast()
+static off_t
+deflate_fast ()
 {
     IPos hash_head; /* head of the hash chain */
     int flush = 0;  /* set if current block must be flushed, 2=>and padded  */
diff --git a/gzip.c b/gzip.c
index fb1a089..fcf8e06 100644
--- a/gzip.c
+++ b/gzip.c
@@ -305,33 +305,33 @@ static const struct option longopts[] =
 
 /* local functions */
 
-_Noreturn local void try_help (void);
-local void help         (void);
-local void license      (void);
-local void version      (void);
-local int input_eof	(void);
-local void treat_stdin  (void);
-local void treat_file   (char *iname);
-local int create_outfile (void);
-local char *get_suffix  (char *name);
-local int  open_input_file (char *iname, struct stat *sbuf);
-local void discard_input_bytes (size_t nbytes, unsigned int flags);
-local int  make_ofname  (void);
-local void shorten_name  (char *name);
-local int  get_method   (int in);
-local void do_list      (int method);
-local int  check_ofname (void);
-local void copy_stat    (struct stat *ifstat);
-local void install_signal_handlers (void);
+_Noreturn static void try_help (void);
+static void help (void);
+static void license (void);
+static void version (void);
+static int input_eof (void);
+static void treat_stdin (void);
+static void treat_file (char *iname);
+static int create_outfile (void);
+static char *get_suffix (char *name);
+static int  open_input_file (char *iname, struct stat *sbuf);
+static void discard_input_bytes (size_t nbytes, unsigned int flags);
+static int  make_ofname (void);
+static void shorten_name (char *name);
+static int  get_method (int in);
+static void do_list (int method);
+static int  check_ofname (void);
+static void copy_stat (struct stat *ifstat);
+static void install_signal_handlers (void);
 static void remove_output_file (bool);
 static void abort_gzip_signal (int);
-_Noreturn local void do_exit (int exitcode);
+_Noreturn static void do_exit (int exitcode);
 static void finish_out (void);
       int main          (int argc, char **argv);
 static int (*work) (int infile, int outfile) = zip; /* function to call */
 
 #if ! NO_DIR
-local void treat_dir    (int fd, char *dir);
+static void treat_dir (int fd, char *dir);
 #endif
 
 #define strequ(s1, s2) (strcmp((s1),(s2)) == 0)
@@ -345,7 +345,8 @@ try_help ()
 }
 
 /* ======================================================================== */
-local void help()
+static void
+help ()
 {
     static char const* const help_msg[] = {
  "Compress or uncompress FILEs (by default, compress FILES in-place).",
@@ -394,7 +395,8 @@ local void help()
 }
 
 /* ======================================================================== */
-local void license()
+static void
+license ()
 {
     char const *const *p = license_msg;
 
@@ -403,14 +405,16 @@ local void license()
 }
 
 /* ======================================================================== */
-local void version()
+static void
+version ()
 {
     license ();
     printf ("\n");
     printf ("Written by Jean-loup Gailly.\n");
 }
 
-local void progerror (char const *string)
+static void
+progerror (char const *string)
 {
     int e = errno;
     fprintf (stderr, "%s: ", program_name);
@@ -687,7 +691,7 @@ int main (int argc, char **argv)
 }
 
 /* Return nonzero when at end of file on input.  */
-local int
+static int
 input_eof ()
 {
   if (!decompress || last_member)
@@ -727,7 +731,8 @@ get_input_size_and_time ()
 /* ========================================================================
  * Compress or decompress stdin
  */
-local void treat_stdin()
+static void
+treat_stdin ()
 {
     if (!force && !list
         && (presume_input_tty
@@ -1091,7 +1096,8 @@ volatile_strcpy (char volatile *dst, char const volatile *src)
  *   ofname has already been updated if there was an original name.
  * OUT assertions: ifd and ofd are closed in case of error.
  */
-local int create_outfile()
+static int
+create_outfile ()
 {
   int name_shortened = 0;
   int flags = (O_WRONLY | O_CREAT | O_EXCL
@@ -1382,7 +1388,8 @@ open_input_file (char *iname, struct stat *sbuf)
  * Generate ofname given ifname. Return OK, or WARNING if file must be skipped.
  * Sets save_orig_name to true if the file name has been truncated.
  */
-local int make_ofname()
+static int
+make_ofname ()
 {
     char *suff;            /* ofname z suffix */
 
@@ -1871,7 +1878,8 @@ shorten_name (char *name)
  * The compressed file already exists, so ask for confirmation.
  * Return ERROR if the file must be skipped.
  */
-local int check_ofname()
+static int
+check_ofname ()
 {
     /* Ask permission to overwrite the existing file */
     if (!force) {
diff --git a/gzip.h b/gzip.h
index 668d635..3334cd4 100644
--- a/gzip.h
+++ b/gzip.h
@@ -40,8 +40,6 @@
 #include <string.h>
 #define memzero(s, n) memset ((voidp)(s), 0, (n))
 
-#define local static
-
 typedef unsigned char  uch;
 typedef unsigned short ush;
 typedef unsigned long  ulg;
diff --git a/trees.c b/trees.c
index 14c6191..948c9aa 100644
--- a/trees.c
+++ b/trees.c
@@ -101,13 +101,13 @@
 /* number of codes used to transfer the bit lengths */
 
 
-local int near extra_lbits[LENGTH_CODES] /* extra bits for each length code */
+static int near extra_lbits[LENGTH_CODES] /* extra bits for each length code */
    = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
 
-local int near extra_dbits[D_CODES] /* extra bits for each distance code */
+static int near extra_dbits[D_CODES] /* extra bits for each distance code */
    = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
 
-local int near extra_blbits[BL_CODES]/* extra bits for each bit length code */
+static int near extra_blbits[BL_CODES]/* extra bits for each bit length code */
    = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
 
 #define STORED_BLOCK 0
@@ -186,22 +186,22 @@ typedef struct ct_data {
 #define HEAP_SIZE (2*L_CODES+1)
 /* maximum heap size */
 
-local ct_data near dyn_ltree[HEAP_SIZE];   /* literal and length tree */
-local ct_data near dyn_dtree[2*D_CODES+1]; /* distance tree */
+static ct_data near dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+static ct_data near dyn_dtree[2*D_CODES+1]; /* distance tree */
 
-local ct_data near static_ltree[L_CODES+2];
+static ct_data near static_ltree[L_CODES+2];
 /* The static literal tree. Since the bit lengths are imposed, there is no
  * need for the L_CODES extra codes used during heap construction. However
  * The codes 286 and 287 are needed to build a canonical tree (see ct_init
  * below).
  */
 
-local ct_data near static_dtree[D_CODES];
+static ct_data near static_dtree[D_CODES];
 /* The static distance tree. (Actually a trivial tree since all codes use
  * 5 bits.)
  */
 
-local ct_data near bl_tree[2*BL_CODES+1];
+static ct_data near bl_tree[2*BL_CODES+1];
 /* Huffman tree for the bit lengths */
 
 typedef struct tree_desc {
@@ -214,48 +214,48 @@ typedef struct tree_desc {
     int     max_code;            /* largest code with non zero frequency */
 } tree_desc;
 
-local tree_desc near l_desc =
+static tree_desc near l_desc =
 {dyn_ltree, static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS, 0};
 
-local tree_desc near d_desc =
+static tree_desc near d_desc =
 {dyn_dtree, static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS, 0};
 
-local tree_desc near bl_desc =
+static tree_desc near bl_desc =
 {bl_tree, (ct_data near *)0, extra_blbits, 0,      BL_CODES, MAX_BL_BITS, 0};
 
 
-local ush near bl_count[MAX_BITS+1];
+static ush near bl_count[MAX_BITS+1];
 /* number of codes at each bit length for an optimal tree */
 
-local uch near bl_order[BL_CODES]
+static uch near bl_order[BL_CODES]
    = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
 /* The lengths of the bit length codes are sent in order of decreasing
  * probability, to avoid transmitting the lengths for unused bit length codes.
  */
 
-local int near heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
-local int heap_len;               /* number of elements in the heap */
-local int heap_max;               /* element of largest frequency */
+static int near heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
+static int heap_len;               /* number of elements in the heap */
+static int heap_max;               /* element of largest frequency */
 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
  * The same heap array is used to build all trees.
  */
 
-local uch near depth[2*L_CODES+1];
+static uch near depth[2*L_CODES+1];
 /* Depth of each subtree used as tie breaker for trees of equal frequency */
 
-local uch length_code[MAX_MATCH-MIN_MATCH+1];
+static uch length_code[MAX_MATCH-MIN_MATCH+1];
 /* length code for each normalized match length (0 == MIN_MATCH) */
 
-local uch dist_code[512];
+static uch dist_code[512];
 /* distance codes. The first 256 values correspond to the distances
  * 3 .. 258, the last 256 values correspond to the top 8 bits of
  * the 15 bit distances.
  */
 
-local int near base_length[LENGTH_CODES];
+static int near base_length[LENGTH_CODES];
 /* First normalized length for each code (0 = MIN_MATCH) */
 
-local int near base_dist[D_CODES];
+static int near base_dist[D_CODES];
 /* First normalized distance for each code (0 = distance of 1) */
 
 #define l_buf inbuf
@@ -263,27 +263,27 @@ local int near base_dist[D_CODES];
 
 /* DECLARE(ush, d_buf, DIST_BUFSIZE); buffer for distances */
 
-local uch near flag_buf[(LIT_BUFSIZE/8)];
+static uch near flag_buf[(LIT_BUFSIZE/8)];
 /* flag_buf is a bit array distinguishing literals from lengths in
  * l_buf, thus indicating the presence or absence of a distance.
  */
 
-local unsigned last_lit;    /* running index in l_buf */
-local unsigned last_dist;   /* running index in d_buf */
-local unsigned last_flags;  /* running index in flag_buf */
-local uch flags;            /* current flags not yet saved in flag_buf */
-local uch flag_bit;         /* current bit used in flags */
+static unsigned last_lit;    /* running index in l_buf */
+static unsigned last_dist;   /* running index in d_buf */
+static unsigned last_flags;  /* running index in flag_buf */
+static uch flags;            /* current flags not yet saved in flag_buf */
+static uch flag_bit;         /* current bit used in flags */
 /* bits are filled in flags starting at bit 0 (least significant).
  * Note: these flags are overkill in the current code since we don't
  * take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
  */
 
-local ulg opt_len;        /* bit length of current block with optimal trees */
-local ulg static_len;     /* bit length of current block with static trees */
+static ulg opt_len;        /* bit length of current block with optimal trees */
+static ulg static_len;     /* bit length of current block with static trees */
 
-local off_t compressed_len; /* total bit length of compressed file */
+static off_t compressed_len; /* total bit length of compressed file */
 
-local off_t input_len;      /* total byte length of input file */
+static off_t input_len;      /* total byte length of input file */
 /* input_len is for debugging only since we can get it by other means. */
 
 static ush *file_type;        /* pointer to UNKNOWN, BINARY or ASCII */
@@ -300,17 +300,17 @@ extern unsigned near strstart; /* window offset of current string */
  * Local (static) routines in this file.
  */
 
-local void init_block     (void);
-local void pqdownheap     (ct_data near *tree, int k);
-local void gen_bitlen     (tree_desc near *desc);
-local void gen_codes      (ct_data near *tree, int max_code);
-local void build_tree     (tree_desc near *desc);
-local void scan_tree      (ct_data near *tree, int max_code);
-local void send_tree      (ct_data near *tree, int max_code);
-local int  build_bl_tree  (void);
-local void send_all_trees (int lcodes, int dcodes, int blcodes);
-local void compress_block (ct_data near *ltree, ct_data near *dtree);
-local void set_file_type  (void);
+static void init_block (void);
+static void pqdownheap (ct_data near *tree, int k);
+static void gen_bitlen (tree_desc near *desc);
+static void gen_codes (ct_data near *tree, int max_code);
+static void build_tree (tree_desc near *desc);
+static void scan_tree (ct_data near *tree, int max_code);
+static void send_tree (ct_data near *tree, int max_code);
+static int  build_bl_tree  (void);
+static void send_all_trees (int lcodes, int dcodes, int blcodes);
+static void compress_block (ct_data near *ltree, ct_data near *dtree);
+static void set_file_type (void);
 
 
 #ifndef DEBUG
@@ -414,7 +414,8 @@ ct_init (ush *attr, int *methodp)
 /* ===========================================================================
  * Initialize a new block.
  */
-local void init_block()
+static void
+init_block ()
 {
     int n; /* iterates over tree elements */
 
@@ -803,7 +804,8 @@ send_tree (ct_data near *tree, int max_code)
  * Construct the Huffman tree for the bit lengths and return the index in
  * bl_order of the last bit length code to send.
  */
-local int build_bl_tree()
+static int
+build_bl_tree ()
 {
     int max_blindex;  /* index of last bit length code of non zero freq */
 
@@ -1080,7 +1082,8 @@ compress_block (ct_data near *ltree, ct_data near *dtree)
  * IN assertion: the fields freq of dyn_ltree are set and the total of all
  * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
  */
-local void set_file_type()
+static void
+set_file_type ()
 {
     int n = 0;
     unsigned ascii_freq = 0;
diff --git a/unlzh.c b/unlzh.c
index 0fb45e0..25c05e3 100644
--- a/unlzh.c
+++ b/unlzh.c
@@ -12,25 +12,24 @@
 
 /* decode.c */
 
-local unsigned  decode  (unsigned count, uch buffer[]);
-local void decode_start (void);
+static unsigned  decode (unsigned count, uch buffer[]);
+static void decode_start (void);
 
 /* huf.c */
-local void huf_decode_start (void);
-local unsigned decode_c     (void);
-local unsigned decode_p     (void);
-local void read_pt_len      (int nn, int nbit, int i_special);
-local void read_c_len       (void);
+static void huf_decode_start (void);
+static unsigned decode_c (void);
+static unsigned decode_p (void);
+static void read_pt_len (int nn, int nbit, int i_special);
+static void read_c_len (void);
 
 /* io.c */
-local void fillbuf      (int n);
-local unsigned getbits  (int n);
-local void init_getbits (void);
+static void fillbuf (int n);
+static unsigned getbits (int n);
+static void init_getbits (void);
 
 /* maketbl.c */
 
-local void make_table (int nchar, uch bitlen[],
-                       int tablebits, ush table[]);
+static void make_table (int nchar, uch bitlen[], int tablebits, ush table[]);
 
 
 #define DICBIT    13    /* 12(-lh4-) or 13(-lh5-) */
@@ -67,25 +66,25 @@ local void make_table (int nchar, uch bitlen[],
 #define TBIT 5  /* smallest integer such that (1U << TBIT) > NT */
 #define NPT (1 << TBIT)
 
-/* local ush left[2 * NC - 1]; */
-/* local ush right[2 * NC - 1]; */
+/* static ush left[2 * NC - 1]; */
+/* static ush right[2 * NC - 1]; */
 #define left  prev
 #define right head
 #if NC > (1<<(BITS-2))
     error cannot overlay left+right and prev
 #endif
 
-/* local uch c_len[NC]; */
+/* static uch c_len[NC]; */
 #define c_len outbuf
 #if NC > OUTBUFSIZ
     error cannot overlay c_len and outbuf
 #endif
 
-local uch pt_len[NPT];
-local unsigned blocksize;
-local ush pt_table[256];
+static uch pt_len[NPT];
+static unsigned blocksize;
+static ush pt_table[256];
 
-/* local ush c_table[4096]; */
+/* static ush c_table[4096]; */
 #define c_table d_buf
 #if (DIST_BUFSIZE-1) < 4095
     error cannot overlay c_table and d_buf
@@ -95,9 +94,9 @@ local ush pt_table[256];
         io.c -- input/output
 ***********************************************************/
 
-local ush       bitbuf;
-local unsigned  subbitbuf;
-local int       bitcount;
+static ush       bitbuf;
+static unsigned  subbitbuf;
+static int       bitcount;
 
 /* Shift bitbuf N bits left, read N bits.  */
 static void
@@ -122,7 +121,8 @@ getbits (int n)
     return x;
 }
 
-local void init_getbits()
+static void
+init_getbits ()
 {
     bitbuf = 0;  subbitbuf = 0;  bitcount = 0;
     fillbuf(BITBUFSIZ);
@@ -228,7 +228,8 @@ read_pt_len (int nn, int nbit, int i_special)
     }
 }
 
-local void read_c_len()
+static void
+read_c_len ()
 {
     int i, c, n;
     unsigned mask;
@@ -263,7 +264,8 @@ local void read_c_len()
     }
 }
 
-local unsigned decode_c()
+static unsigned
+decode_c ()
 {
     unsigned j, mask;
 
@@ -290,7 +292,8 @@ local unsigned decode_c()
     return j;
 }
 
-local unsigned decode_p()
+static unsigned
+decode_p ()
 {
     unsigned j, mask;
 
@@ -308,7 +311,8 @@ local unsigned decode_p()
     return j;
 }
 
-local void huf_decode_start()
+static void
+huf_decode_start ()
 {
     init_getbits();  blocksize = 0;
 }
@@ -317,10 +321,11 @@ local void huf_decode_start()
         decode.c
 ***********************************************************/
 
-local int j;    /* remaining bytes to copy */
-local int done; /* set at end of input */
+static int j;    /* remaining bytes to copy */
+static int done; /* set at end of input */
 
-local void decode_start()
+static void
+decode_start ()
 {
     huf_decode_start();
     j = 0;
@@ -340,7 +345,7 @@ decode (unsigned count, uch buffer[])
        before calling this function.
      */
 {
-    local unsigned i;
+    static unsigned i;
     unsigned r, c;
 
     r = 0;
diff --git a/unpack.c b/unpack.c
index 2a87457..39ca75d 100644
--- a/unpack.c
+++ b/unpack.c
@@ -38,26 +38,26 @@
  * Huffman tree.
  */
 
-local ulg orig_len;       /* original uncompressed length */
-local int max_len;        /* maximum bit length of Huffman codes */
+static ulg orig_len;       /* original uncompressed length */
+static int max_len;        /* maximum bit length of Huffman codes */
 
-local uch literal[LITERALS];
+static uch literal[LITERALS];
 /* The literal bytes present in the Huffman tree. The EOB code is not
  * represented.
  */
 
-local int lit_base[MAX_BITLEN+1];
+static int lit_base[MAX_BITLEN+1];
 /* All literals of a given bit length are contiguous in literal[] and
  * have contiguous codes. literal[code+lit_base[len]] is the literal
  * for a code of len bits.
  */
 
-local int leaves [MAX_BITLEN+1]; /* Number of leaves for each bit length */
-local int parents[MAX_BITLEN+1]; /* Number of parents for each bit length */
+static int leaves [MAX_BITLEN+1]; /* Number of leaves for each bit length */
+static int parents[MAX_BITLEN+1]; /* Number of parents for each bit length */
 
-local int peek_bits; /* Number of peek bits currently used */
+static int peek_bits; /* Number of peek bits currently used */
 
-/* local uch prefix_len[1 << MAX_PEEK]; */
+/* static uch prefix_len[1 << MAX_PEEK]; */
 #define prefix_len outbuf
 /* For each bit pattern b of peek_bits bits, prefix_len[b] is the length
  * of the Huffman code starting with a prefix of b (upper bits), or 0
@@ -70,10 +70,10 @@ local int peek_bits; /* Number of peek bits currently used */
     error cannot overlay prefix_len and outbuf
 #endif
 
-local ulg bitbuf;
+static ulg bitbuf;
 /* Bits are added on the low part of bitbuf and read from the high part. */
 
-local int valid;                  /* number of valid bits in bitbuf */
+static int valid;                  /* number of valid bits in bitbuf */
 /* all bits above the last valid bit are always zero */
 
 /* Read an input byte, reporting an error at EOF.  */
@@ -104,13 +104,14 @@ read_byte ()
 
 /* Local functions */
 
-local void read_tree  (void);
-local void build_tree (void);
+static void read_tree (void);
+static void build_tree (void);
 
 /* ===========================================================================
  * Read the Huffman tree.
  */
-local void read_tree()
+static void
+read_tree ()
 {
     int len;  /* bit length */
     int base; /* base offset for a sequence of leaves */
@@ -167,7 +168,8 @@ local void read_tree()
 /* ===========================================================================
  * Build the Huffman tree and the prefix table.
  */
-local void build_tree()
+static void
+build_tree ()
 {
     int nodes = 0; /* number of nodes (parents+leaves) at current bit length */
     int len;       /* current bit length */