First run of 3C

Author: mwhicks1

bn.c

@@ -26,15 +26,15 @@ There may well be room for performance-optimizations and improvements.
 
 
 /* Functions for shifting number in-place. */
-static void _lshift_one_bit(struct bn* a);
-static void _rshift_one_bit(struct bn* a);
-static void _lshift_word(struct bn* a, int nwords);
-static void _rshift_word(struct bn* a, int nwords);
+static void _lshift_one_bit(_Ptr<struct bn> a);
+static void _rshift_one_bit(_Ptr<struct bn> a);
+static void _lshift_word(_Ptr<struct bn> a, int nwords);
+static void _rshift_word(_Ptr<struct bn> a, int nwords);
 
 
 
 /* Public / Exported functions. */
-void bignum_init(struct bn* n)
+void bignum_init(_Ptr<struct bn> n)
 {
   require(n, "n is null");
 
@@ -46,7 +46,7 @@ void bignum_init(struct bn* n)
 }
 
 
-void bignum_from_int(struct bn* n, DTYPE_TMP i)
+void bignum_from_int(_Ptr<struct bn> n, DTYPE_TMP i)
 {
   require(n, "n is null");
 
@@ -72,7 +72,7 @@ void bignum_from_int(struct bn* n, DTYPE_TMP i)
 }
 
 
-int bignum_to_int(struct bn* n)
+int bignum_to_int(_Ptr<struct bn> n)
 {
   require(n, "n is null");
 
@@ -95,7 +95,7 @@ int bignum_to_int(struct bn* n)
 }
 
 
-void bignum_from_string(struct bn* n, char* str, int nbytes)
+void bignum_from_string(_Ptr<struct bn> n, _Nt_array_ptr<char> str : count(nbytes), int nbytes)
 {
   require(n, "n is null");
   require(str, "str is null");
@@ -122,7 +122,7 @@ void bignum_from_string(struct bn* n, char* str, int nbytes)
 }
 
 
-void bignum_to_string(struct bn* n, char* str, int nbytes)
+void bignum_to_string(_Ptr<struct bn> n, char *str : itype(_Array_ptr<char>) count(8191), int nbytes)
 {
   require(n, "n is null");
   require(str, "str is null");
@@ -158,7 +158,7 @@ void bignum_to_string(struct bn* n, char* str, int nbytes)
 }
 
 
-void bignum_dec(struct bn* n)
+void bignum_dec(_Ptr<struct bn> n)
 {
   require(n, "n is null");
 
@@ -180,7 +180,7 @@ void bignum_dec(struct bn* n)
 }
 
 
-void bignum_inc(struct bn* n)
+void bignum_inc(_Ptr<struct bn> n)
 {
   require(n, "n is null");
 
@@ -202,7 +202,7 @@ void bignum_inc(struct bn* n)
 }
 
 
-void bignum_add(struct bn* a, struct bn* b, struct bn* c)
+void bignum_add(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -220,7 +220,7 @@ void bignum_add(struct bn* a, struct bn* b, struct bn* c)
 }
 
 
-void bignum_sub(struct bn* a, struct bn* b, struct bn* c)
+void bignum_sub(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -242,14 +242,14 @@ void bignum_sub(struct bn* a, struct bn* b, struct bn* c)
 }
 
 
-void bignum_mul(struct bn* a, struct bn* b, struct bn* c)
+void bignum_mul(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
   require(c, "c is null");
 
-  struct bn row;
-  struct bn tmp;
+  struct bn row = {};
+  struct bn tmp = {};
   int i, j;
 
   bignum_init(c);
@@ -274,15 +274,15 @@ void bignum_mul(struct bn* a, struct bn* b, struct bn* c)
 }
 
 
-void bignum_div(struct bn* a, struct bn* b, struct bn* c)
+void bignum_div(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
   require(c, "c is null");
 
-  struct bn current;
-  struct bn denom;
-  struct bn tmp;
+  struct bn current = {};
+  struct bn denom = {};
+  struct bn tmp = {};
 
   bignum_from_int(&current, 1);               // int current = 1;
   bignum_assign(&denom, b);                   // denom = b
@@ -320,7 +320,7 @@ void bignum_div(struct bn* a, struct bn* b, struct bn* c)
 }
 
 
-void bignum_lshift(struct bn* a, struct bn* b, int nbits)
+void bignum_lshift(_Ptr<struct bn> a, _Ptr<struct bn> b, int nbits)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -348,7 +348,7 @@ void bignum_lshift(struct bn* a, struct bn* b, int nbits)
 }
 
 
-void bignum_rshift(struct bn* a, struct bn* b, int nbits)
+void bignum_rshift(_Ptr<struct bn> a, _Ptr<struct bn> b, int nbits)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -377,7 +377,7 @@ void bignum_rshift(struct bn* a, struct bn* b, int nbits)
 }
 
 
-void bignum_mod(struct bn* a, struct bn* b, struct bn* c)
+void bignum_mod(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   /*
     Take divmod and throw away div part
@@ -386,12 +386,12 @@ void bignum_mod(struct bn* a, struct bn* b, struct bn* c)
   require(b, "b is null");
   require(c, "c is null");
 
-  struct bn tmp;
+  struct bn tmp = {};
 
   bignum_divmod(a,b,&tmp,c);
 }
 
-void bignum_divmod(struct bn* a, struct bn* b, struct bn* c, struct bn* d)
+void bignum_divmod(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c, _Ptr<struct bn> d)
 {
   /*
     Puts a%b in d
@@ -406,7 +406,7 @@ void bignum_divmod(struct bn* a, struct bn* b, struct bn* c, struct bn* d)
   require(b, "b is null");
   require(c, "c is null");
 
-  struct bn tmp;
+  struct bn tmp = {};
 
   /* c = (a / b) */
   bignum_div(a, b, c);
@@ -419,7 +419,7 @@ void bignum_divmod(struct bn* a, struct bn* b, struct bn* c, struct bn* d)
 }
 
 
-void bignum_and(struct bn* a, struct bn* b, struct bn* c)
+void bignum_and(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -433,7 +433,7 @@ void bignum_and(struct bn* a, struct bn* b, struct bn* c)
 }
 
 
-void bignum_or(struct bn* a, struct bn* b, struct bn* c)
+void bignum_or(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -447,7 +447,7 @@ void bignum_or(struct bn* a, struct bn* b, struct bn* c)
 }
 
 
-void bignum_xor(struct bn* a, struct bn* b, struct bn* c)
+void bignum_xor(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -461,7 +461,7 @@ void bignum_xor(struct bn* a, struct bn* b, struct bn* c)
 }
 
 
-int bignum_cmp(struct bn* a, struct bn* b)
+int bignum_cmp(_Ptr<struct bn> a, _Ptr<struct bn> b)
 {
   require(a, "a is null");
   require(b, "b is null");
@@ -485,7 +485,7 @@ int bignum_cmp(struct bn* a, struct bn* b)
 }
 
 
-int bignum_is_zero(struct bn* n)
+int bignum_is_zero(_Ptr<struct bn> n)
 {
   require(n, "n is null");
 
@@ -502,13 +502,13 @@ int bignum_is_zero(struct bn* n)
 }
 
 
-void bignum_pow(struct bn* a, struct bn* b, struct bn* c)
+void bignum_pow(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c)
 {
   require(a, "a is null");
   require(b, "b is null");
   require(c, "c is null");
 
-  struct bn tmp;
+  struct bn tmp = {};
 
   bignum_init(c);
 
@@ -519,7 +519,7 @@ void bignum_pow(struct bn* a, struct bn* b, struct bn* c)
   }
   else
   {
-    struct bn bcopy;
+    struct bn bcopy = {};
     bignum_assign(&bcopy, b);
 
     /* Copy a -> tmp */
@@ -544,12 +544,15 @@ void bignum_pow(struct bn* a, struct bn* b, struct bn* c)
   }
 }
 
-void bignum_isqrt(struct bn *a, struct bn* b)
+void bignum_isqrt(_Ptr<struct bn> a, _Ptr<struct bn> b)
 {
   require(a, "a is null");
   require(b, "b is null");
 
-  struct bn low, high, mid, tmp;
+  struct bn low = {};
+struct bn high = {};
+struct bn mid = {};
+struct bn tmp = {};
 
   bignum_init(&low);
   bignum_assign(&high, a);
@@ -577,7 +580,7 @@ void bignum_isqrt(struct bn *a, struct bn* b)
 }
 
 
-void bignum_assign(struct bn* dst, struct bn* src)
+void bignum_assign(_Ptr<struct bn> dst, _Ptr<struct bn> src)
 {
   require(dst, "dst is null");
   require(src, "src is null");
@@ -591,7 +594,7 @@ void bignum_assign(struct bn* dst, struct bn* src)
 
 
 /* Private / Static functions. */
-static void _rshift_word(struct bn* a, int nwords)
+static void _rshift_word(_Ptr<struct bn> a, int nwords)
 {
   /* Naive method: */
   require(a, "a is null");
@@ -618,7 +621,7 @@ static void _rshift_word(struct bn* a, int nwords)
 }
 
 
-static void _lshift_word(struct bn* a, int nwords)
+static void _lshift_word(_Ptr<struct bn> a, int nwords)
 {
   require(a, "a is null");
   require(nwords >= 0, "no negative shifts");
@@ -637,7 +640,7 @@ static void _lshift_word(struct bn* a, int nwords)
 }
 
 
-static void _lshift_one_bit(struct bn* a)
+static void _lshift_one_bit(_Ptr<struct bn> a)
 {
   require(a, "a is null");
 
@@ -650,7 +653,7 @@ static void _lshift_one_bit(struct bn* a)
 }
 
 
-static void _rshift_one_bit(struct bn* a)
+static void _rshift_one_bit(_Ptr<struct bn> a)
 {
   require(a, "a is null");
 

bn.h

@@ -76,7 +76,7 @@ There may well be room for performance-optimizations and improvements.
 /* Data-holding structure: array of DTYPEs */
 struct bn
 {
-  DTYPE array[BN_ARRAY_SIZE];
+  uint32_t array _Checked[BN_ARRAY_SIZE];
 };
 
 
@@ -87,35 +87,35 @@ enum { SMALLER = -1, EQUAL = 0, LARGER = 1 };
 
 
 /* Initialization functions: */
-void bignum_init(struct bn* n);
-void bignum_from_int(struct bn* n, DTYPE_TMP i);
-int  bignum_to_int(struct bn* n);
-void bignum_from_string(struct bn* n, char* str, int nbytes);
-void bignum_to_string(struct bn* n, char* str, int maxsize);
+void bignum_init(_Ptr<struct bn> n);
+void bignum_from_int(_Ptr<struct bn> n, DTYPE_TMP i);
+int  bignum_to_int(_Ptr<struct bn> n);
+void bignum_from_string(_Ptr<struct bn> n, _Nt_array_ptr<char> str : count(nbytes), int nbytes);
+void bignum_to_string(_Ptr<struct bn> n, char *str : itype(_Array_ptr<char>) count(8191), int maxsize);
 
 /* Basic arithmetic operations: */
-void bignum_add(struct bn* a, struct bn* b, struct bn* c); /* c = a + b */
-void bignum_sub(struct bn* a, struct bn* b, struct bn* c); /* c = a - b */
-void bignum_mul(struct bn* a, struct bn* b, struct bn* c); /* c = a * b */
-void bignum_div(struct bn* a, struct bn* b, struct bn* c); /* c = a / b */
-void bignum_mod(struct bn* a, struct bn* b, struct bn* c); /* c = a % b */
-void bignum_divmod(struct bn* a, struct bn* b, struct bn* c, struct bn* d); /* c = a/b, d = a%b */
+void bignum_add(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* c = a + b */
+void bignum_sub(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* c = a - b */
+void bignum_mul(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* c = a * b */
+void bignum_div(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* c = a / b */
+void bignum_mod(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* c = a % b */
+void bignum_divmod(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c, _Ptr<struct bn> d); /* c = a/b, d = a%b */
 
 /* Bitwise operations: */
-void bignum_and(struct bn* a, struct bn* b, struct bn* c); /* c = a & b */
-void bignum_or(struct bn* a, struct bn* b, struct bn* c);  /* c = a | b */
-void bignum_xor(struct bn* a, struct bn* b, struct bn* c); /* c = a ^ b */
-void bignum_lshift(struct bn* a, struct bn* b, int nbits); /* b = a << nbits */
-void bignum_rshift(struct bn* a, struct bn* b, int nbits); /* b = a >> nbits */
+void bignum_and(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* c = a & b */
+void bignum_or(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c);  /* c = a | b */
+void bignum_xor(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* c = a ^ b */
+void bignum_lshift(_Ptr<struct bn> a, _Ptr<struct bn> b, int nbits); /* b = a << nbits */
+void bignum_rshift(_Ptr<struct bn> a, _Ptr<struct bn> b, int nbits); /* b = a >> nbits */
 
 /* Special operators and comparison */
-int  bignum_cmp(struct bn* a, struct bn* b);               /* Compare: returns LARGER, EQUAL or SMALLER */
-int  bignum_is_zero(struct bn* n);                         /* For comparison with zero */
-void bignum_inc(struct bn* n);                             /* Increment: add one to n */
-void bignum_dec(struct bn* n);                             /* Decrement: subtract one from n */
-void bignum_pow(struct bn* a, struct bn* b, struct bn* c); /* Calculate a^b -- e.g. 2^10 => 1024 */
-void bignum_isqrt(struct bn* a, struct bn* b);             /* Integer square root -- e.g. isqrt(5) => 2*/
-void bignum_assign(struct bn* dst, struct bn* src);        /* Copy src into dst -- dst := src */
+int  bignum_cmp(_Ptr<struct bn> a, _Ptr<struct bn> b);               /* Compare: returns LARGER, EQUAL or SMALLER */
+int  bignum_is_zero(_Ptr<struct bn> n);                         /* For comparison with zero */
+void bignum_inc(_Ptr<struct bn> n);                             /* Increment: add one to n */
+void bignum_dec(_Ptr<struct bn> n);                             /* Decrement: subtract one from n */
+void bignum_pow(_Ptr<struct bn> a, _Ptr<struct bn> b, _Ptr<struct bn> c); /* Calculate a^b -- e.g. 2^10 => 1024 */
+void bignum_isqrt(_Ptr<struct bn> a, _Ptr<struct bn> b);             /* Integer square root -- e.g. isqrt(5) => 2*/
+void bignum_assign(_Ptr<struct bn> dst, _Ptr<struct bn> src);        /* Copy src into dst -- dst := src */
 
 
 #endif /* #ifndef __BIGNUM_H__ */