From 3d300acca1433ec36eaec3806568d17d7bdaacac Mon Sep 17 00:00:00 2001 From: Landon Curt Noll Date: Sun, 28 Nov 2021 20:47:52 -0800 Subject: [PATCH] Improve internal pre-defined constant handling Improved the way that internal pre-defined constants are managed. Removed unused internal pre-defined constants. Added code to prevent an internal pre-defined constant (that was never allocated) from being freed. --- CHANGES | 5 ++ sample_many.c | 2 +- sample_rand.c | 2 +- zmath.c | 128 ++++++++++++++++++++++++++++++++------------------ zmath.h | 101 ++++++++++++++++++++++++++++++++++----- zrandom.c | 4 +- 6 files changed, 181 insertions(+), 61 deletions(-) diff --git a/CHANGES b/CHANGES index e05d43c..741e81c 100644 --- a/CHANGES +++ b/CHANGES @@ -26,6 +26,11 @@ The following are the changes from calc version 2.14.0.9 to date: Fixed a few cases where v_subtype was not properly initialuzed. + Improved the way that internal pre-defined constants are managed. + Removed unused internal pre-defined constants. Added code to + prevent an internal pre-defined constant (that was never allocated) + from being freed. + The following are the changes from calc version 2.14.0.7 to 2.14.0.8: diff --git a/sample_many.c b/sample_many.c index f455866..3049043 100644 --- a/sample_many.c +++ b/sample_many.c @@ -103,7 +103,7 @@ main(int argc, char **argv) /* * seed the generator */ - prev_state = zsrandom2(seed, zconst[1]); + prev_state = zsrandom2(seed, _one_); if (prev_state == NULL) { math_error("previous random state is NULL"); /*NOTREACHED*/ diff --git a/sample_rand.c b/sample_rand.c index 66390cd..12edc6f 100644 --- a/sample_rand.c +++ b/sample_rand.c @@ -93,7 +93,7 @@ main(int argc, char **argv) /* * seed the generator */ - prev_state = zsrandom2(seed, zconst[10]); + prev_state = zsrandom2(seed, _ten_); if (prev_state == NULL) { math_error("previous random state is NULL"); /*NOTREACHED*/ diff --git a/zmath.c b/zmath.c index 65daaf0..647849f 100644 --- a/zmath.c +++ b/zmath.c @@ -35,54 +35,45 @@ HALF _zeroval_[] = { 0 }; -HALF _oneval_[] = { 1 }; -HALF _twoval_[] = { 2 }; -HALF _threeval_[] = { 3 }; -HALF _fourval_[] = { 4 }; -HALF _fiveval_[] = { 5 }; -HALF _sixval_[] = { 6 }; -HALF _sevenval_[] = { 7 }; -HALF _eightval_[] = { 8 }; -HALF _nineval_[] = { 9 }; -HALF _tenval_[] = { 10 }; -HALF _elevenval_[] = { 11 }; -HALF _twelveval_[] = { 12 }; -HALF _thirteenval_[] = { 13 }; -HALF _fourteenval_[] = { 14 }; -HALF _fifteenval_[] = { 15 }; -HALF _sixteenval_[] = { 16 }; -HALF _seventeenval_[] = { 17 }; -HALF _eightteenval_[] = { 18 }; -HALF _nineteenval_[] = { 19 }; -HALF _twentyval_[] = { 20 }; -HALF _sqbaseval_[] = { 0, 1 }; -HALF _pow4baseval_[] = { 0, 0, 1 }; -HALF _pow8baseval_[] = { 0, 0, 0, 0, 1 }; -HALF _threesixtyval_[] = { 360 }; -HALF _fourhundredval_[] = { 400 }; -HALF _twentyfourval_[] = { 24 }; - -ZVALUE zconst[] = { - { _zeroval_, 1, 0}, { _oneval_, 1, 0}, { _twoval_, 1, 0}, - { _threeval_, 1, 0}, { _fourval_, 1, 0}, { _fiveval_, 1, 0}, - { _sixval_, 1, 0}, { _sevenval_, 1, 0}, { _eightval_, 1, 0}, - { _nineval_, 1, 0}, { _tenval_, 1, 0}, { _elevenval_, 1, 0}, - { _twelveval_, 1, 0}, { _thirteenval_, 1, 0}, { _fourteenval_, 1, 0}, - { _fifteenval_, 1, 0}, { _sixteenval_, 1, 0}, { _seventeenval_, 1, 0}, - { _eightteenval_, 1, 0}, { _nineteenval_, 1, 0}, { _twentyval_, 1, 0}, - { _threesixtyval_, 1, 0}, { _fourhundredval_, 1, 0}, - { _twentyfourval_, 1, 0} -}; - ZVALUE _zero_ = { _zeroval_, 1, 0}; + +HALF _oneval_[] = { 1 }; ZVALUE _one_ = { _oneval_, 1, 0 }; -ZVALUE _two_ = { _twoval_, 1, 0 }; -ZVALUE _ten_ = { _tenval_, 1, 0 }; -ZVALUE _sqbase_ = { _sqbaseval_, 2, 0 }; -ZVALUE _pow4base_ = { _pow4baseval_, 4, 0 }; -ZVALUE _pow8base_ = { _pow8baseval_, 4, 0 }; ZVALUE _neg_one_ = { _oneval_, 1, 1 }; +HALF _twoval_[] = { 2 }; +ZVALUE _two_ = { _twoval_, 1, 0 }; + +HALF _threeval_[] = { 3 }; +ZVALUE _three_ = { _threeval_, 1, 0 }; + +HALF _fourval_[] = { 4 }; +ZVALUE _four_ = { _fourval_, 1, 0 }; + +HALF _nineval_[] = { 9 }; +ZVALUE _nine_ = { _nineval_, 1, 0 }; + +HALF _tenval_[] = { 10 }; +ZVALUE _ten_ = { _tenval_, 1, 0 }; + +HALF _sqbaseval_[] = { 0, 1 }; +ZVALUE _sqbase_ = { _sqbaseval_, 2, 0 }; + +HALF _pow4baseval_[] = { 0, 0, 1 }; +ZVALUE _pow4base_ = { _pow4baseval_, 4, 0 }; + +HALF _pow8baseval_[] = { 0, 0, 0, 0, 1 }; +ZVALUE _pow8base_ = { _pow8baseval_, 4, 0 }; + +HALF _threesixtyval_[] = { 360 }; +ZVALUE _threesixty_ = { _threesixtyval_, 4, 0 }; + +HALF _fourhundredval_[] = { 400 }; +ZVALUE _fourhundred_ = { _fourhundredval_, 4, 0 }; + +HALF _twentyfourval_[] = { 24 }; +ZVALUE _twentyfour_ = { _twentyfourval_, 4, 0 }; + /* * 2^64 as a ZVALUE */ @@ -96,6 +87,26 @@ ZVALUE _b64_ = { _pow8baseval_, 5, 0 }; -=@=- BASEB not 16 or 32 -=@=- #endif +/* + * ZVALUE - values that should not be freed + */ +HALF *half_tbl[] = { + _zeroval_, + _oneval_, + _twoval_, + _threeval_, + _fourval_, + _nineval_, + _tenval_, + _sqbaseval_, + _pow4baseval_, + _pow8baseval_, + _threesixtyval_, + _fourhundredval_, + _twentyfourval_, + NULL /* must be last */ +}; + /* * highhalf[i] - masks off the upper i bits of a HALF @@ -260,11 +271,38 @@ alloc(LEN len) } +/* + * is_const - determine if a HALF array is an pre-allocated array + * + * given: + * h pointer to the beginning of the HALF array + * + * returns: + * TRUE - h is found in the half_tbl array + * FALSE - is is not found in the half_tbl array + */ +int +is_const(HALF* h) +{ + HALF **h_p; /* half_tbl array pointer */ + + /* search the half_tbl for h */ + for (h_p = &half_tbl[0]; *h_p != NULL; ++h_p) { + if (h == *h_p) { + return TRUE; /* found in the half_tbl array */ + } + } + + /* not found in the half_tbl array */ + return FALSE; +} + + #ifdef ALLOCTEST void freeh(HALF *h) { - if ((h != _zeroval_) && (h != _oneval_)) { + if (!is_const(h)) { free(h); ++nfree; } diff --git a/zmath.h b/zmath.h index 53b0b63..8f6c2c1 100644 --- a/zmath.h +++ b/zmath.h @@ -55,8 +55,7 @@ #ifndef ALLOCTEST -# define freeh(p) { if (((void *)p != (void *)_zeroval_) && \ - ((void *)p != (void *)_oneval_)) free((void *)p); } +# define freeh(p) { if (!is_const(p)) { free((void *)(p)); } } #endif @@ -289,6 +288,7 @@ typedef struct { * Function prototypes for integer math routines. */ E_FUNC HALF * alloc(LEN len); +E_FUNC int is_const(HALF* h); #ifdef ALLOCTEST E_FUNC void freeh(HALF *); #endif @@ -642,20 +642,97 @@ E_FUNC ZVALUE *swap_HALF_in_ZVALUE(ZVALUE *dest, ZVALUE *src, BOOL all); /* * constants used often by the arithmetic routines */ -EXTERN HALF _zeroval_[], _oneval_[], _twoval_[], _threeval_[], _fourval_[]; -EXTERN HALF _fiveval_[], _sixval_[], _sevenval_[], _eightval_[], _nineval_[]; -EXTERN HALF _tenval_[], _elevenval_[], _twelveval_[], _thirteenval_[]; -EXTERN HALF _fourteenval_[], _fifteenval_[]; +EXTERN HALF _zeroval_[]; +EXTERN ZVALUE _zero_; + +EXTERN HALF _oneval_[]; +EXTERN ZVALUE _one_; +EXTERN ZVALUE _neg_one_; + +EXTERN HALF _twoval_[]; +EXTERN ZVALUE _two_; + +EXTERN HALF _threeval_[]; +EXTERN ZVALUE _three_; + +EXTERN HALF _fourval_[]; +EXTERN ZVALUE _four_; + +#if 0 +EXTERN HALF _fiveval_[]; +EXTERN ZVALUE _five_; + +EXTERN HALF _sixval_[]; +EXTERN ZVALUE _six_; + +EXTERN HALF _sevenval_[]; +EXTERN ZVALUE _seven_; + +EXTERN HALF _eightval_[]; +EXTERN ZVALUE _eight_; +#endif + +EXTERN HALF _nineval_[]; +EXTERN ZVALUE _nine_; + +EXTERN HALF _tenval_[]; +EXTERN ZVALUE _ten_; + +EXTERN HALF _elevenval_[]; +EXTERN ZVALUE _eleven_; + +EXTERN HALF _twelveval_[]; +EXTERN ZVALUE _twelve_; + +EXTERN HALF _thirteenval_[]; +EXTERN ZVALUE _thirteen_; + +EXTERN HALF _fourteenval_[]; +EXTERN ZVALUE _fourteen_; + +EXTERN HALF _fifteenval_[]; +EXTERN ZVALUE _fifteen_; + +EXTERN HALF _sixteenval_[]; +EXTERN ZVALUE _sixteen_; + +EXTERN HALF _seventeenval_[]; +EXTERN ZVALUE _seventeen_; + +EXTERN HALF _eightteenval_[]; +EXTERN ZVALUE _eightteen_; + +EXTERN HALF _nineteenval_[]; +EXTERN ZVALUE _nineteen_; + +EXTERN HALF _twentyval_[]; +EXTERN ZVALUE _twenty_; + EXTERN HALF _sqbaseval_[]; -EXTERN HALF _fourthbaseval_[]; -EXTERN HALF _threesixtyval_[], _fourhundredval_[], _twentyfourval_[]; +EXTERN ZVALUE _sqbase_; -EXTERN ZVALUE zconst[]; /* ZVALUE integers from 0 thru 15 */ +EXTERN HALF _pow4baseval_[]; +EXTERN ZVALUE _pow4base_; -EXTERN ZVALUE _zero_, _one_, _two_, _ten_, _neg_one_; -EXTERN ZVALUE _sqbase_, _pow4base_, _pow8base_; +EXTERN HALF _pow8baseval_[]; +EXTERN ZVALUE _pow8base_; -EXTERN ZVALUE _b32_, _b64_; +EXTERN HALF _threesixtyval_[]; +EXTERN ZVALUE _threesixty_; + +EXTERN HALF _fourhundredval_[]; +EXTERN ZVALUE _fourhundred_; + +EXTERN HALF _twentyfourval_[]; +EXTERN ZVALUE _fourhundred_; + +/* _b32_ is _sqbaseval_ or _pow4baseval_ depending on BASEB */ +EXTERN ZVALUE _b32_; + +/* _b64_ is _pow4baseval_ or _pow8baseval_ depending on BASEB */ +EXTERN ZVALUE _b64_; + +EXTERN HALF *half_tbl[]; /* preset HALF constants, NULL termated list */ EXTERN BOOL _math_abort_; /* nonzero to abort calculations */ EXTERN ZVALUE _tenpowers_[]; /* table of 10^2^n */ diff --git a/zrandom.c b/zrandom.c index e9c2d3e..0fa485b 100644 --- a/zrandom.c +++ b/zrandom.c @@ -2532,11 +2532,11 @@ zsrandom4(CONST ZVALUE seed, CONST ZVALUE ip, CONST ZVALUE iq, long trials) /* * search the 'p' and 'q' Blum prime (3 mod 4) candidates */ - if (!znextcand(ip, trials, _zero_, zconst[3], zconst[4], &p)) { + if (!znextcand(ip, trials, _zero_, _three_, _four_, &p)) { math_error("failed to find 1st Blum prime"); /*NOTREACHED*/ } - if (!znextcand(iq, trials, _zero_, zconst[3], zconst[4], &q)) { + if (!znextcand(iq, trials, _zero_, _three_, _four_, &q)) { math_error("failed to find 2nd Blum prime"); /*NOTREACHED*/ }