Style fixes to: #include ordering; use const and static; ANSI functions;

various usage synopses; bogus and/or unnecessary casting; exit values;
use LINE_MAX instead of magic numbers; declare extern variables in a
header; add $FreeBSD$ where missing.

Reviewed by:    markm, obrien
Obtained from:  NetBSD | fanf

4 files changed, 39 insertions, 33 deletions

diff --git a/games/primes/pattern.c b/games/primes/pattern.c
index 1d72fb2..dff1f4d 100644
--- a/games/primes/pattern.c
+++ b/games/primes/pattern.c
@@ -56,7 +56,9 @@ static const char rcsid[] =
 
 #include <stddef.h>
 
-char pattern[] = {
+#include "primes.h"
+
+const char pattern[] = {
 1,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,0,1,1,0,0,1,0,1,1,0,0,
 1,0,1,0,0,1,0,0,0,1,0,1,1,0,1,1,0,1,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,1,0,0,
 1,0,0,1,0,1,0,0,1,0,0,1,1,0,0,0,0,1,1,0,1,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,1,0,1,
@@ -443,4 +445,4 @@ char pattern[] = {
 0,0,1,1,0,0,0,0,1,1,0,0,1,0,1,0,0,0,0,0,0,1,0,1,1,0,1,1,0,1,0,0,0,1,0,0,1,0,1,
 0,0,1,1,0,1,0,0,1,1,0,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,0,0,0,0,0,0,1
 };
-size_t pattern_size = (sizeof(pattern)/sizeof(pattern[0]));
+const size_t pattern_size = (sizeof(pattern)/sizeof(pattern[0]));
diff --git a/games/primes/pr_tbl.c b/games/primes/pr_tbl.c
index dd02b85..6447916 100644
--- a/games/primes/pr_tbl.c
+++ b/games/primes/pr_tbl.c
@@ -53,9 +53,11 @@ static const char rcsid[] =
  * and 65537^2 > 2^32-1.
  */
 
+#include <stddef.h>
+
 #include "primes.h"
 
-ubig prime[] = {
+const ubig prime[] = {
 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,
 107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,
 211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,
@@ -547,4 +549,4 @@ ubig prime[] = {
 };
 
 /* pr_limit - largest prime in the prime table */
-ubig *pr_limit = &prime[(sizeof(prime)/sizeof(prime[0]))-1];
+const ubig *const pr_limit = &prime[(sizeof(prime)/sizeof(prime[0]))-1];
diff --git a/games/primes/primes.c b/games/primes/primes.c
index cf23fef..08141b6 100644
--- a/games/primes/primes.c
+++ b/games/primes/primes.c
@@ -56,7 +56,7 @@ static const char rcsid[] =
  * chongo <for a good prime call: 391581 * 2^216193 - 1> /\oo/\
  *
  * usage:
- *	primes [start [stop]]
+ *	primes [-h] [start [stop]]
  *
  *	Print primes >= start and < stop.  If stop is omitted,
  *	the value 4294967295 (2^32-1) is assumed.  If start is
@@ -88,23 +88,6 @@ static const char rcsid[] =
  */
 static char table[TABSIZE];	 /* Eratosthenes sieve of odd numbers */
 
-/*
- * prime[i] is the (i-1)th prime.
- *
- * We are able to sieve 2^32-1 because this byte table yields all primes
- * up to 65537 and 65537^2 > 2^32-1.
- */
-extern ubig prime[];
-extern ubig *pr_limit;		/* largest prime in the prime array */
-
-/*
- * To avoid excessive sieves for small factors, we use the table below to
- * setup our sieve blocks.  Each element represents a odd number starting
- * with 1.  All non-zero elements are factors of 3, 5, 7, 11 and 13.
- */
-extern char pattern[];
-extern size_t pattern_size;	/* length of pattern array */
-
 static int	hflag;
 
 static void	primes(ubig, ubig);
@@ -193,7 +176,7 @@ static ubig
 read_num_buf(void)
 {
 	ubig val;
-	char *p, buf[100];		/* > max number of digits. */
+	char *p, buf[LINE_MAX];		/* > max number of digits. */
 
 	for (;;) {
 		if (fgets(buf, sizeof(buf), stdin) == NULL) {
@@ -225,8 +208,9 @@ primes(ubig start, ubig stop)
 	char *q;		/* sieve spot */
 	ubig factor;		/* index and factor */
 	char *tab_lim;		/* the limit to sieve on the table */
-	ubig *p;		/* prime table pointer */
+	const ubig *p;		/* prime table pointer */
 	ubig fact_lim;		/* highest prime for current block */
+	ubig mod;		/* temp storage for mod */
 
 	/*
 	 * A number of systems can not convert double values into unsigned
@@ -296,28 +280,28 @@ primes(ubig start, ubig stop)
 		/* note highest useful factor and sieve spot */
 		if (stop-start > TABSIZE+TABSIZE) {
 			tab_lim = &table[TABSIZE]; /* sieve it all */
-			fact_lim = (int)sqrt(
-					(double)(start)+TABSIZE+TABSIZE+1.0);
+			fact_lim = sqrt(start+1.0+TABSIZE+TABSIZE);
 		} else {
 			tab_lim = &table[(stop-start)/2]; /* partial sieve */
-			fact_lim = (int)sqrt((double)(stop)+1.0);
+			fact_lim = sqrt(stop+1.0);
 		}
 		/* sieve for factors >= 17 */
 		factor = 17;	/* 17 is first prime to use */
 		p = &prime[7];	/* 19 is next prime, pi(19)=7 */
 		do {
 			/* determine the factor's initial sieve point */
-			q = (char *)(start%factor); /* temp storage for mod */
-			if ((long)q & 0x1) {
-				q = &table[(factor-(long)q)/2];
+			mod = start%factor;
+			if (mod & 0x1) {
+				q = &table[(factor-mod)/2];
 			} else {
-				q = &table[q ? factor-((long)q/2) : 0];
+				q = &table[mod ? factor-(mod/2) : 0];
 			}
 			/* sive for our current factor */
 			for ( ; q < tab_lim; q += factor) {
 				*q = '\0'; /* sieve out a spot */
 			}
-		} while ((factor=(ubig)(*(p++))) <= fact_lim);
+			factor = *p++;
+		} while (factor <= fact_lim);
 
 		/*
 		 * print generated primes
@@ -333,6 +317,6 @@ primes(ubig start, ubig stop)
 static void
 usage(void)
 {
-	(void)fprintf(stderr, "usage: primes [-h] [start [stop]]\n");
+	fprintf(stderr, "usage: primes [-h] [start [stop]]\n");
 	exit(1);
 }
diff --git a/games/primes/primes.h b/games/primes/primes.h
index 611c86d..f4a90fa 100644
--- a/games/primes/primes.h
+++ b/games/primes/primes.h
@@ -34,6 +34,7 @@
  * SUCH DAMAGE.
  *
  *	@(#)primes.h	8.2 (Berkeley) 3/1/94
+ * $FreeBSD$
  */
 
 /*
@@ -50,3 +51,20 @@ typedef unsigned long ubig;		/* must be >=32 bit unsigned value */
 
 /* bytes in sieve table (must be > 3*5*7*11) */
 #define	TABSIZE		256*1024
+
+/*
+ * prime[i] is the (i-1)th prime.
+ *
+ * We are able to sieve 2^32-1 because this byte table yields all primes
+ * up to 65537 and 65537^2 > 2^32-1.
+ */
+extern const ubig prime[];
+extern const ubig *const pr_limit;	/* largest prime in the prime array */
+
+/*
+ * To avoid excessive sieves for small factors, we use the table below to
+ * setup our sieve blocks.  Each element represents a odd number starting
+ * with 1.  All non-zero elements are factors of 3, 5, 7, 11 and 13.
+ */
+extern const char pattern[];
+extern const size_t pattern_size;	/* length of pattern array */