From fe1ffaff239017f31b04c3329012f4ff3c6759ee Mon Sep 17 00:00:00 2001
From: Lev Walkin <vlm@lionet.info>
Date: Mon, 25 Oct 2010 21:07:59 -0700
Subject: [PATCH] removed warnings in debug mode compilation
---
skeletons/per_decoder.c | 6 ++---
skeletons/per_encoder.c | 2 +-
skeletons/per_opentype.c | 54 ++++++++++++++++++++--------------------
skeletons/per_support.c | 38 ++++++++++++++--------------
4 files changed, 51 insertions(+), 49 deletions(-)
diff --git a/skeletons/per_decoder.c b/skeletons/per_decoder.c
index 2b3d2e29..220d7f9f 100644
--- a/skeletons/per_decoder.c
+++ b/skeletons/per_decoder.c
@@ -21,7 +21,7 @@ uper_decode_complete(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
rval.consumed >>= 3;
} else if(rval.code == RC_OK) {
if(size) {
- if(((uint8_t *)buffer)[0] == 0) {
+ if(((const uint8_t *)buffer)[0] == 0) {
rval.consumed = 1; /* 1 byte */
} else {
ASN_DEBUG("Expecting single zeroed byte");
@@ -81,8 +81,8 @@ uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sp
/* Return the number of consumed bits */
rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)
+ pd.nboff - skip_bits;
- ASN_DEBUG("PER decoding consumed %d, counted %d",
- rval.consumed, pd.moved);
+ ASN_DEBUG("PER decoding consumed %ld, counted %ld",
+ (long)rval.consumed, (long)pd.moved);
assert(rval.consumed == pd.moved);
} else {
/* PER codec is not a restartable */
diff --git a/skeletons/per_encoder.c b/skeletons/per_encoder.c
index f4bace06..e76ef74a 100644
--- a/skeletons/per_encoder.c
+++ b/skeletons/per_encoder.c
@@ -88,7 +88,7 @@ uper_encode_to_new_buffer(asn_TYPE_descriptor_t *td, asn_per_constraints_t *cons
}
default:
*buffer_r = key.buffer;
- ASN_DEBUG("Complete encoded in %d bits", er.encoded);
+ ASN_DEBUG("Complete encoded in %ld bits", (long)er.encoded);
return ((er.encoded + 7) >> 3);
}
}
diff --git a/skeletons/per_opentype.c b/skeletons/per_opentype.c
index bbb9380e..ebcf076c 100644
--- a/skeletons/per_opentype.c
+++ b/skeletons/per_opentype.c
@@ -49,8 +49,8 @@ uper_open_type_put(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints
FREEMEM(buf);
if(toGo) return -1;
- ASN_DEBUG("Open type put %s of length %d + overhead (1byte?)",
- td->name, size);
+ ASN_DEBUG("Open type put %s of length %ld + overhead (1byte?)",
+ td->name, (long)size);
return 0;
}
@@ -94,8 +94,8 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
bufLen += chunk_bytes;
} while(repeat);
- ASN_DEBUG("Getting open type %s encoded in %d bytes", td->name,
- bufLen);
+ ASN_DEBUG("Getting open type %s encoded in %ld bytes", td->name,
+ (long)bufLen);
memset(&spd, 0, sizeof(spd));
spd.buffer = buf;
@@ -118,7 +118,7 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
}
FREEMEM(buf);
if(padding >= 8) {
- ASN_DEBUG("Too large padding %d in open type", padding);
+ ASN_DEBUG("Too large padding %d in open type", (int)padding);
_ASN_DECODE_FAILED;
} else {
ASN_DEBUG("Non-zero padding");
@@ -170,24 +170,23 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
return rv;
}
- ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d"
- , td->name,
+ ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d", td->name,
per_data_string(pd),
per_data_string(&arg.oldpd),
- arg.unclaimed, arg.repeat);
+ (int)arg.unclaimed, (int)arg.repeat);
padding = pd->moved % 8;
if(padding) {
int32_t pvalue;
if(padding > 7) {
ASN_DEBUG("Too large padding %d in open type",
- padding);
+ (int)padding);
rv.code = RC_FAIL;
UPDRESTOREPD;
return rv;
}
padding = 8 - padding;
- ASN_DEBUG("Getting padding of %d bits", padding);
+ ASN_DEBUG("Getting padding of %d bits", (int)padding);
pvalue = per_get_few_bits(pd, padding);
switch(pvalue) {
case -1:
@@ -197,7 +196,7 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
case 0: break;
default:
ASN_DEBUG("Non-blank padding (%d bits 0x%02x)",
- padding, (int)pvalue);
+ (int)padding, (int)pvalue);
UPDRESTOREPD;
_ASN_DECODE_FAILED;
}
@@ -217,14 +216,14 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
UPDRESTOREPD;
/* Skip data not consumed by the decoder */
- if(arg.unclaimed) ASN_DEBUG("Getting unclaimed %d", arg.unclaimed);
if(arg.unclaimed) {
+ ASN_DEBUG("Getting unclaimed %d", (int)arg.unclaimed);
switch(per_skip_bits(pd, arg.unclaimed)) {
case -1:
- ASN_DEBUG("Claim of %d failed", arg.unclaimed);
+ ASN_DEBUG("Claim of %d failed", (int)arg.unclaimed);
_ASN_DECODE_STARVED;
case 0:
- ASN_DEBUG("Got claim of %d", arg.unclaimed);
+ ASN_DEBUG("Got claim of %d", (int)arg.unclaimed);
break;
default:
/* Padding must be blank */
@@ -248,9 +247,7 @@ asn_dec_rval_t
uper_open_type_get(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
- return uper_open_type_get_simple(ctx, td, constraints,
- sptr, pd);
-
+ return uper_open_type_get_simple(ctx, td, constraints, sptr, pd);
}
int
@@ -298,8 +295,8 @@ uper_ugot_refill(asn_per_data_t *pd) {
asn_per_data_t *oldpd = &arg->oldpd;
- ASN_DEBUG("REFILLING pd->moved=%d, oldpd->moved=%d",
- pd->moved, oldpd->moved);
+ ASN_DEBUG("REFILLING pd->moved=%ld, oldpd->moved=%ld",
+ (long)pd->moved, (long)oldpd->moved);
/* Advance our position to where pd is */
oldpd->buffer = pd->buffer;
@@ -319,7 +316,8 @@ uper_ugot_refill(asn_per_data_t *pd) {
pd->buffer = oldpd->buffer;
pd->nboff = oldpd->nboff - 1;
pd->nbits = oldpd->nbits;
- ASN_DEBUG("UNCLAIMED <- return from (pd->moved=%d)", pd->moved);
+ ASN_DEBUG("UNCLAIMED <- return from (pd->moved=%ld)",
+ (long)pd->moved);
return 0;
}
@@ -329,8 +327,8 @@ uper_ugot_refill(asn_per_data_t *pd) {
}
next_chunk_bytes = uper_get_length(oldpd, -1, &arg->repeat);
- ASN_DEBUG("Open type LENGTH %d bytes at off %d, repeat %d",
- next_chunk_bytes, oldpd->moved, arg->repeat);
+ ASN_DEBUG("Open type LENGTH %ld bytes at off %ld, repeat %ld",
+ (long)next_chunk_bytes, (long)oldpd->moved, (long)arg->repeat);
if(next_chunk_bytes < 0) return -1;
if(next_chunk_bytes == 0) {
pd->refill = 0; /* No more refills, naturally */
@@ -341,14 +339,16 @@ uper_ugot_refill(asn_per_data_t *pd) {
if(avail >= next_chunk_bits) {
pd->nbits = oldpd->nboff + next_chunk_bits;
arg->unclaimed = 0;
- ASN_DEBUG("!+Parent frame %d bits, alloting %d [%d..%d] (%d)",
- next_chunk_bits, oldpd->moved,
- oldpd->nboff, oldpd->nbits,
- oldpd->nbits - oldpd->nboff);
+ ASN_DEBUG("!+Parent frame %ld bits, alloting %ld [%ld..%ld] (%ld)",
+ (long)next_chunk_bits, (long)oldpd->moved,
+ (long)oldpd->nboff, (long)oldpd->nbits,
+ (long)(oldpd->nbits - oldpd->nboff));
} else {
pd->nbits = oldpd->nbits;
arg->unclaimed = next_chunk_bits - avail;
- ASN_DEBUG("!-Parent frame %d, require %d, will claim %d", avail, next_chunk_bits, arg->unclaimed);
+ ASN_DEBUG("!-Parent frame %ld, require %ld, will claim %ld",
+ (long)avail, (long)next_chunk_bits,
+ (long)arg->unclaimed);
}
pd->buffer = oldpd->buffer;
pd->nboff = oldpd->nboff;
diff --git a/skeletons/per_support.c b/skeletons/per_support.c
index 54e93fa6..c2d4247a 100644
--- a/skeletons/per_support.c
+++ b/skeletons/per_support.c
@@ -13,11 +13,11 @@ per_data_string(asn_per_data_t *pd) {
static int n;
n = (n+1) % 2;
snprintf(buf[n], sizeof(buf),
- "{m=%d span %+d[%d..%d] (%d)}",
- pd->moved,
+ "{m=%ld span %+d[%d..%d] (%d)}",
+ (long)pd->moved,
(((int)pd->buffer) & 0xf),
- pd->nboff, pd->nbits,
- pd->nbits - pd->nboff);
+ (int)pd->nboff, (int)pd->nbits,
+ (int)(pd->nbits - pd->nboff));
return buf[n];
}
@@ -49,7 +49,8 @@ per_get_few_bits(asn_per_data_t *pd, int nbits) {
int32_t tailv, vhead;
if(!pd->refill || nbits > 31) return -1;
/* Accumulate unused bytes before refill */
- ASN_DEBUG("Obtain the rest %d bits (want %d)", nleft, nbits);
+ ASN_DEBUG("Obtain the rest %d bits (want %d)",
+ (int)nleft, (int)nbits);
tailv = per_get_few_bits(pd, nleft);
if(tailv < 0) return -1;
/* Refill (replace pd contents with new data) */
@@ -104,12 +105,12 @@ per_get_few_bits(asn_per_data_t *pd, int nbits) {
accum &= (((uint32_t)1 << nbits) - 1);
ASN_DEBUG(" [PER got %2d<=%2d bits => span %d %+d[%d..%d]:%02x (%d) => 0x%x]",
- nbits, nleft,
- pd->moved,
+ (int)nbits, (int)nleft,
+ (int)pd->moved,
(((int)pd->buffer) & 0xf),
- pd->nboff, pd->nbits,
+ (int)pd->nboff, (int)pd->nbits,
pd->buffer[0],
- pd->nbits - pd->nboff,
+ (int)(pd->nbits - pd->nboff),
(int)accum);
return accum;
@@ -200,7 +201,7 @@ uper_get_nslength(asn_per_data_t *pd) {
if(per_get_few_bits(pd, 1) == 0) {
length = per_get_few_bits(pd, 6) + 1;
if(length <= 0) return -1;
- ASN_DEBUG("l=%d", length);
+ ASN_DEBUG("l=%d", (int)length);
return length;
} else {
int repeat;
@@ -275,7 +276,7 @@ per_put_few_bits(asn_per_outp_t *po, uint32_t bits, int obits) {
if(obits <= 0 || obits >= 32) return obits ? -1 : 0;
ASN_DEBUG("[PER put %d bits %x to %p+%d bits]",
- obits, (int)bits, po->buffer, po->nboff);
+ obits, (int)bits, po->buffer, (int)po->nboff);
/*
* Normalize position indicator.
@@ -291,8 +292,8 @@ per_put_few_bits(asn_per_outp_t *po, uint32_t bits, int obits) {
*/
if(po->nboff + obits > po->nbits) {
int complete_bytes = (po->buffer - po->tmpspace);
- ASN_DEBUG("[PER output %d complete + %d]",
- complete_bytes, po->flushed_bytes);
+ ASN_DEBUG("[PER output %ld complete + %ld]",
+ (long)complete_bytes, (long)po->flushed_bytes);
if(po->outper(po->tmpspace, complete_bytes, po->op_key) < 0)
return -1;
if(po->nboff)
@@ -314,7 +315,9 @@ per_put_few_bits(asn_per_outp_t *po, uint32_t bits, int obits) {
ASN_DEBUG("[PER out %d %u/%x (t=%d,o=%d) %x&%x=%x]", obits,
(int)bits, (int)bits,
- po->nboff, off, buf[0], omsk&0xff, buf[0] & omsk);
+ (int)po->nboff, (int)off,
+ buf[0], (int)(omsk&0xff),
+ (int)(buf[0] & omsk));
if(off <= 8) /* Completely within 1 byte */
po->nboff = off,
@@ -339,14 +342,13 @@ per_put_few_bits(asn_per_outp_t *po, uint32_t bits, int obits) {
buf[2] = bits >> 8,
buf[3] = bits;
else {
- ASN_DEBUG("->[PER out split %d]", obits);
per_put_few_bits(po, bits >> (obits - 24), 24);
per_put_few_bits(po, bits, obits - 24);
- ASN_DEBUG("<-[PER out split %d]", obits);
}
- ASN_DEBUG("[PER out %u/%x => %02x buf+%d]",
- (int)bits, (int)bits, buf[0], po->buffer - po->tmpspace);
+ ASN_DEBUG("[PER out %u/%x => %02x buf+%ld]",
+ (int)bits, (int)bits, buf[0],
+ (long)(po->buffer - po->tmpspace));
return 0;
}
--
GitLab