mtd-utils: fec.c uses bcopy()

[Mitch Davis]

Hi Mike,

On Wed, Oct 8, 2008 at 1:38 PM, Mike Frysinger <vapier.adi at gmail.com> wrote:
> On Tue, Oct 7, 2008 at 22:36, Mitch Davis wrote:
>> On Wed, Oct 8, 2008 at 12:02 PM, Mike Frysinger wrote:
>>> On Tue, Oct 7, 2008 at 20:27, Mitch Davis wrote:
>>>> fec.c in mtd-utils uses bcopy(), so mtd-utils doesn't compile for me.
>>>> I'd like to fix this.
>>>>
>>>>  - Should I rewrite fec.c so it uses memcpy instead?
>>>
>>> a simple sed can fix the code as the only difference between bcopy()
>>> and memcpy() is the argument order.  ifdef's are pointless/ugly in
>>> this case.
>>
>> I agree.  I've attached a diff that makes this change.
>>
>> It compiles with no warnings, but I have no way of testing it.  Any
>> suggestions what to do next?
>
> use `git diff` to generate a diff instead of posting the entire file
> as an attachment.

The diff I attached previously was generated by git diff from HEAD.
It was not the entire file.

> really you should use git to send the patch

Do you mean a git push?  I'd need an account for that on infradead,
no?  A pointer to some instructions would be great.  Note, two of the
three links to informative articles on the MTD GIT HOWTO page are
broken.  If you don't mean a git push, please tell me what you mean.

Hmm, I hope the following inline pasting doesn't break tabs, etc.

Thanks for your help,

Mitch.

[PATCH] [MTD] mtd-utils: fec.c: bzero->memset, bcopy->memcpy, bcmp->memcmp

This patch alters fec.c so it does not use the deprecated bzero, bcopy and bcmp
functions.  This can help on platforms that do not have these functions.

From: Mitch Davis <mitch.davis at symstream.com>
Signed-off-by: Mitch Davis <mitch.davis at symstream.com>

diff --git a/fec.c b/fec.c
index 09e8453..6d9020f 100644
--- a/fec.c
+++ b/fec.c
@@ -47,19 +47,6 @@
 #include <string.h>

 /*
- * compatibility stuff
- */
-#ifdef MSDOS	/* but also for others, e.g. sun... */
-#define NEED_BCOPY
-#define bcmp(a,b,n) memcmp(a,b,n)
-#endif
-
-#ifdef NEED_BCOPY
-#define bcopy(s, d, siz)        memcpy((d), (s), (siz))
-#define bzero(d, siz)   memset((d), '\0', (siz))
-#endif
-
-/*
  * stuff used for testing purposes only
  */

@@ -433,7 +420,7 @@ invert_mat(gf *src, int k)
     gf *id_row = NEW_GF_MATRIX(1, k);
     gf *temp_row = NEW_GF_MATRIX(1, k);

-    bzero(id_row, k*sizeof(gf));
+    memset(id_row, '\0', k*sizeof(gf));
     DEB( pivloops=0; pivswaps=0 ; /* diagnostic */ )
     /*
      * ipiv marks elements already used as pivots.
@@ -513,7 +500,7 @@ found_piv:
 	 * we can optimize the addmul).
 	 */
 	id_row[icol] = 1;
-	if (bcmp(pivot_row, id_row, k*sizeof(gf)) != 0) {
+	if (memcmp(pivot_row, id_row, k*sizeof(gf)) != 0) {
 	    for (p = src, ix = 0 ; ix < k ; ix++, p += k ) {
 		if (ix != icol) {
 		    c = p[icol] ;
@@ -704,7 +691,7 @@ fec_new(int k, int n)
     /*
      * the upper matrix is I so do not bother with a slow multiply
      */
-    bzero(retval->enc_matrix, k*k*sizeof(gf) );
+    memset(retval->enc_matrix, '\0', k*k*sizeof(gf) );
     for (p = retval->enc_matrix, col = 0 ; col < k ; col++, p += k+1 )
 	*p = 1 ;
     free(tmp_m);
@@ -731,10 +718,10 @@ fec_encode(struct fec_parms *code, gf *src[], gf
*fec, int index, int sz)
 	sz /= 2 ;

     if (index < k)
-         bcopy(src[index], fec, sz*sizeof(gf) ) ;
+         memcpy(fec, src[index], sz*sizeof(gf) ) ;
     else if (index < code->n) {
 	p = &(code->enc_matrix[index*k] );
-	bzero(fec, sz*sizeof(gf));
+	memset(fec, '\0', sz*sizeof(gf));
 	for (i = 0; i < k ; i++)
 	    addmul(fec, src[i], p[i], sz ) ;
     } else
@@ -751,10 +738,10 @@ void fec_encode_linear(struct fec_parms *code,
gf *src, gf *fec, int index, int
 	sz /= 2 ;

     if (index < k)
-	    bcopy(src + (index * sz), fec, sz*sizeof(gf) ) ;
+	    memcpy(fec, src + (index * sz), sz*sizeof(gf) ) ;
     else if (index < code->n) {
 	p = &(code->enc_matrix[index*k] );
-	bzero(fec, sz*sizeof(gf));
+	memset(fec, '\0', sz*sizeof(gf));
 	for (i = 0; i < k ; i++)
 	    addmul(fec, src + (i * sz), p[i], sz ) ;
     } else
@@ -814,12 +801,12 @@ build_decode_matrix(struct fec_parms *code, gf
*pkt[], int index[])
     for (i = 0, p = matrix ; i < k ; i++, p += k ) {
 #if 1 /* this is simply an optimization, not very useful indeed */
 	if (index[i] < k) {
-	    bzero(p, k*sizeof(gf) );
+	    memset(p, '\0', k*sizeof(gf) );
 	    p[i] = 1 ;
 	} else
 #endif
 	if (index[i] < code->n )
-	    bcopy( &(code->enc_matrix[index[i]*k]), p, k*sizeof(gf) );
+	    memcpy(p,  &(code->enc_matrix[index[i]*k]), k*sizeof(gf) );
 	else {
 	    fprintf(stderr, "decode: invalid index %d (max %d)\n",
 		index[i], code->n - 1 );
@@ -870,7 +857,7 @@ fec_decode(struct fec_parms *code, gf *pkt[], int
index[], int sz)
     for (row = 0 ; row < k ; row++ ) {
 	if (index[row] >= k) {
 	    new_pkt[row] = my_malloc (sz * sizeof (gf), "new pkt buffer" );
-	    bzero(new_pkt[row], sz * sizeof(gf) ) ;
+	    memset(new_pkt[row], '\0', sz * sizeof(gf) ) ;
 	    for (col = 0 ; col < k ; col++ )
 		addmul(new_pkt[row], pkt[col], m_dec[row*k + col], sz) ;
 	}
@@ -880,7 +867,7 @@ fec_decode(struct fec_parms *code, gf *pkt[], int
index[], int sz)
      */
     for (row = 0 ; row < k ; row++ ) {
 	if (index[row] >= k) {
-	    bcopy(new_pkt[row], pkt[row], sz*sizeof(gf));
+	    memcpy(pkt[row], new_pkt[row], sz*sizeof(gf));
 	    free(new_pkt[row]);
 	}
     }