[BACK]Return to factor.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / games / factor

File: [cvs.NetBSD.org] / src / games / factor / factor.c (download)

Revision 1.38, Mon Oct 12 13:54:51 2020 UTC (13 months, 3 weeks ago) by christos
Branch: MAIN
CVS Tags: cjep_sun2x-base1, cjep_sun2x-base, cjep_sun2x, cjep_staticlib_x-base1, cjep_staticlib_x-base, cjep_staticlib_x, HEAD
Changes since 1.37: +3 -3 lines

- remove duplicate comment
- flush after printing the number
(from kre@)

/*	$NetBSD: factor.c,v 1.38 2020/10/12 13:54:51 christos Exp $	*/
/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Landon Curt Noll.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
#include <sys/cdefs.h>
#ifdef __COPYRIGHT
__COPYRIGHT("@(#) Copyright (c) 1989, 1993\
	The Regents of the University of California.  All rights reserved.");
#endif
#ifdef __SCCSID
__SCCSID("@(#)factor.c	8.4 (Berkeley) 5/4/95");
#endif
#ifdef __RCSID
__RCSID("$NetBSD: factor.c,v 1.38 2020/10/12 13:54:51 christos Exp $");
#endif
#ifdef __FBSDID
__FBSDID("$FreeBSD: head/usr.bin/factor/factor.c 356666 2020-01-12 20:25:11Z gad $");
#endif
#endif /* not lint */

/*
 * factor - factor a number into primes
 *
 * By: Landon Curt Noll   chongo@toad.com,   ...!{sun,tolsoft}!hoptoad!chongo
 *
 *   chongo <for a good prime call: 391581 * 2^216193 - 1> /\oo/\
 *
 * usage:
 *	factor [-hx] [number] ...
 *
 * The form of the output is:
 *
 *	number: factor1 factor1 factor2 factor3 factor3 factor3 ...
 *
 * where factor1 <= factor2 <= factor3 <= ...
 *
 * If the -h flag is specified, the output is in "human-readable" format.
 * Duplicate factors are printed in the form of x^n.
 *
 * If the -x flag is specified numbers are printed in hex.
 *
 * If no number args are given, the list of numbers are read from stdin.
 */

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "primes.h"

#ifdef HAVE_OPENSSL

#include <openssl/bn.h>

#define	PRIME_CHECKS	5

/* print factors for big numbers */
static void	pollard_pminus1(BIGNUM *, int, int);

#else

typedef long	BIGNUM;
typedef u_long	BN_ULONG;

#define BN_CTX			int
#define BN_CTX_new()		NULL
#define BN_new()		calloc(sizeof(BIGNUM), 1)
#define BN_free(a)		free(a)

#define BN_copy(a, b)		*(a) = *(b)
#define BN_cmp(a, b)		(*(a) - *(b))
#define BN_is_zero(v)		(*(v) == 0)
#define BN_is_one(v)		(*(v) == 1)
#define BN_mod_word(a, b)	(*(a) % (b))

static BIGNUM  *BN_dup(const BIGNUM *);
static int	BN_dec2bn(BIGNUM **, const char *);
static int	BN_hex2bn(BIGNUM **, const char *);
static BN_ULONG BN_div_word(BIGNUM *, BN_ULONG);
static void	BN_print_fp(FILE *, const BIGNUM *);

#endif

static void	BN_print_dec_fp(FILE *, const BIGNUM *);
static void	convert_str2bn(BIGNUM **, char *);
static void	pr_fact(BIGNUM *, int, int);	/* print factors of a value */
static void	pr_print(BIGNUM *, int, int);	/* print a prime */
static void	usage(void) __dead;

static BN_CTX	*ctx;			/* just use a global context */

int
main(int argc, char *argv[])
{
	BIGNUM *val;
	int ch, hflag, xflag;
	char *p, buf[LINE_MAX];		/* > max number of digits. */

	hflag = xflag = 0;
	ctx = BN_CTX_new();
	val = BN_new();
	if (val == NULL)
		errx(1, "can't initialise bignum");

	while ((ch = getopt(argc, argv, "hx")) != -1)
		switch (ch) {
		case 'h':
			hflag++;
			break;
		case 'x':
			xflag++;
			break;
		case '?':
		default:
			usage();
		}
	argc -= optind;
	argv += optind;

	/* No args supplied, read numbers from stdin. */
	if (argc == 0)
		for (;;) {
			if (fgets(buf, sizeof(buf), stdin) == NULL) {
				if (ferror(stdin))
					err(1, "stdin");
				exit (0);
			}
			for (p = buf; isblank((unsigned char)*p); ++p);
			if (*p == '\n' || *p == '\0')
				continue;
			convert_str2bn(&val, p);
			pr_fact(val, hflag, xflag);
		}
	/* Factor the arguments. */
	else
		for (p = *argv; p != NULL; p = *++argv) {
			convert_str2bn(&val, p);
			pr_fact(val, hflag, xflag);
		}
	exit(0);
}

static void
pr_exp(int i, int xflag)
{
	printf(xflag && i > 9 ? "^0x%x" : "^%d", i);
}

static void
pr_uint64(uint64_t i, int xflag)
{
	printf(xflag ? " 0x%" PRIx64 : " %" PRIu64, i);
}

/*
 * pr_fact - print the factors of a number
 *
 * Print the factors of the number, from the lowest to the highest.
 * A factor will be printed multiple times if it divides the value
 * multiple times.
 *
 * If hflag is specified, duplicate factors are printed in "human-
 * readable" form of x^n.
 *
 * If the xflag is specified, numbers will be printed in hex.
 *
 * Factors are printed with leading tabs.
 */
static void
pr_fact(BIGNUM *val, int hflag, int xflag)
{
	int i;
	const uint64_t *fact;	/* The factor found. */

	/* Firewall - catch 0 and 1. */
	if (BN_is_zero(val))	/* Historical practice; 0 just exits. */
		exit(0);
	if (BN_is_one(val)) {
		printf("1: 1\n");
		return;
	}

	/* Factor value. */

	if (xflag) {
		fputs("0x", stdout);
		BN_print_fp(stdout, val);
	} else
		BN_print_dec_fp(stdout, val);
	putchar(':');
	fflush(stdout);
	for (fact = &prime[0]; !BN_is_one(val); ++fact) {
		/* Look for the smallest factor. */
		do {
			if (BN_mod_word(val, (BN_ULONG)*fact) == 0)
				break;
		} while (++fact <= pr_limit);

		/* Watch for primes larger than the table. */
		if (fact > pr_limit) {
#ifdef HAVE_OPENSSL
			BIGNUM *bnfact;

			bnfact = BN_new();
			BN_set_word(bnfact, *(fact - 1));
			if (!BN_sqr(bnfact, bnfact, ctx))
				errx(1, "error in BN_sqr()");
			if (BN_cmp(bnfact, val) > 0 ||
			    BN_is_prime_ex(val, PRIME_CHECKS, NULL, NULL) == 1)
				pr_print(val, hflag, xflag);
			else
				pollard_pminus1(val, hflag, xflag);
#else
			pr_print(val, hflag, xflag);
#endif
			pr_print(NULL, hflag, xflag);
			break;
		}

		/* Divide factor out until none are left. */
		i = 0;
		do {
			i++;
			if (!hflag)
				pr_uint64(*fact, xflag);
			BN_div_word(val, (BN_ULONG)*fact);
		} while (BN_mod_word(val, (BN_ULONG)*fact) == 0);

		if (hflag) {
			pr_uint64(*fact, xflag);
			if (i > 1)
				pr_exp(i, xflag);
		}

		/* Let the user know we're doing something. */
		fflush(stdout);
	}
	putchar('\n');
}

static void
pr_print(BIGNUM *val, int hflag, int xflag)
{
	static BIGNUM *sval;
	static int ex = 1;
	BIGNUM *pval;

	if (hflag) {
		if (sval == NULL) {
			sval = BN_dup(val);
			return;
		}

		if (val != NULL && BN_cmp(val, sval) == 0) {
			ex++;
			return;
		}
		pval = sval;
	} else if (val == NULL) {
		return;
	} else {
		pval = val;
	}

	if (xflag) {
		fputs(" 0x", stdout);
		BN_print_fp(stdout, pval);
	} else {
		putchar(' ');
		BN_print_dec_fp(stdout, pval);
	}

	if (hflag) {
		if (ex > 1)
			pr_exp(ex, xflag);

		if (val != NULL) {
			BN_copy(sval, val);
		} else {
			BN_free(sval);
			sval = NULL;
		}
		ex = 1;
	}
}

static void
usage(void)
{
	fprintf(stderr, "Usage: %s [-hx] [value ...]\n", getprogname());
	exit(1);
}

#ifdef HAVE_OPENSSL

/* pollard p-1, algorithm from Jim Gillogly, May 2000 */
static void
pollard_pminus1(BIGNUM *val, int hflag, int xflag)
{
	BIGNUM *base, *rbase, *num, *i, *x;

	base = BN_new();
	rbase = BN_new();
	num = BN_new();
	i = BN_new();
	x = BN_new();

	BN_set_word(rbase, 1);
newbase:
	if (!BN_add_word(rbase, 1))
		errx(1, "error in BN_add_word()");
	BN_set_word(i, 2);
	BN_copy(base, rbase);

	for (;;) {
		BN_mod_exp(base, base, i, val, ctx);
		if (BN_is_one(base))
			goto newbase;

		BN_copy(x, base);
		BN_sub_word(x, 1);
		if (!BN_gcd(x, x, val, ctx))
			errx(1, "error in BN_gcd()");

		if (!BN_is_one(x)) {
			if (BN_is_prime_ex(x, PRIME_CHECKS, NULL, NULL) == 1)
				pr_print(x, hflag, xflag);
			else
				pollard_pminus1(x, hflag, xflag);
			fflush(stdout);

			BN_div(num, NULL, val, x, ctx);
			if (BN_is_one(num))
				return;
			if (BN_is_prime_ex(num, PRIME_CHECKS, NULL,
			    NULL) == 1) {
				pr_print(num, hflag, xflag);
				fflush(stdout);
				return;
			}
			BN_copy(val, num);
		}
		if (!BN_add_word(i, 1))
			errx(1, "error in BN_add_word()");
	}
}

/*
 * Sigh..  No _decimal_ output to file functions in BN.
 */
static void
BN_print_dec_fp(FILE *fp, const BIGNUM *num)
{
	char *buf;

	buf = BN_bn2dec(num);
	if (buf == NULL)
		return;	/* XXX do anything here? */
	fprintf(fp, "%s", buf);
	free(buf);
}

#else

static void
BN_print_fp(FILE *fp, const BIGNUM *num)
{
	fprintf(fp, "%lx", (unsigned long)*num);
}

static void
BN_print_dec_fp(FILE *fp, const BIGNUM *num)
{
	fprintf(fp, "%lu", (unsigned long)*num);
}

static int
BN_dec2bn(BIGNUM **a, const char *str)
{
	char *p;

	errno = 0;
	**a = strtoul(str, &p, 10);
	return (errno == 0 ? 1 : 0);	/* OpenSSL returns 0 on error! */
}

static int
BN_hex2bn(BIGNUM **a, const char *str)
{
	char *p;

	errno = 0;
	**a = strtoul(str, &p, 16);
	return (errno == 0 ? 1 : 0);	/* OpenSSL returns 0 on error! */
}

static BN_ULONG
BN_div_word(BIGNUM *a, BN_ULONG b)
{
	BN_ULONG mod;

	mod = *a % b;
	*a /= b;
	return mod;
}

static BIGNUM *
BN_dup(const BIGNUM *a)
{
	BIGNUM *b = BN_new();
	BN_copy(b, a);
	return b;
}

#endif

/* Convert string pointed to by *str to a bignum.  */
static void
convert_str2bn(BIGNUM **val, char *p)
{
	int n = 0;

	if (*p == '+') p++;
	if (*p == '-')
		errx(1, "negative numbers aren't permitted.");
	if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) {
		n = BN_hex2bn(val, p + 2);
	} else {
		n = BN_dec2bn(val, p);
	}
	if (n == 0)
		errx(1, "%s: illegal numeric format.", p);
}