git2d: Reformat C code in Linux style

1 files changed, 67 insertions, 95 deletions

diff --git a/git2d/bare.c b/git2d/bare.c
index a349e91..b580980 100644
--- a/git2d/bare.c
+++ b/git2d/bare.c
@@ -18,33 +18,31 @@ enum {
 	MAXVARINTSZ = 10,
 };
 
-bare_error
-bare_put_uint(struct bare_writer *ctx, uint64_t x)
+bare_error bare_put_uint(struct bare_writer *ctx, uint64_t x)
 {
 	uint64_t i = 0;
 	uint8_t b[MAXVARINTSZ];
 
 	while (x >= 0x80) {
-		b[i] = (uint8_t)x | 0x80;
+		b[i] = (uint8_t) x | 0x80;
 		x >>= 7;
 		i++;
 	}
 
-	b[i] = (uint8_t)x;
+	b[i] = (uint8_t) x;
 	i++;
 
 	return ctx->write(ctx->buffer, b, i);
 }
 
-bare_error
-bare_get_uint(struct bare_reader *ctx, uint64_t *x)
+bare_error bare_get_uint(struct bare_reader *ctx, uint64_t *x)
 {
 	bare_error err = BARE_ERROR_NONE;
 
 	uint8_t shift = 0;
 	uint64_t result = 0;
 
-	for (uint8_t i = 0;i < 10;i++) {
+	for (uint8_t i = 0; i < 10; i++) {
 		uint8_t b;
 
 		err = ctx->read(ctx->buffer, &b, U8SZ);
@@ -53,10 +51,10 @@ bare_get_uint(struct bare_reader *ctx, uint64_t *x)
 		}
 
 		if (b < 0x80) {
-			result |= (uint64_t)b << shift;
+			result |= (uint64_t) b << shift;
 			break;
 		} else {
-			result |= ((uint64_t)b & 0x7f) << shift;
+			result |= ((uint64_t) b & 0x7f) << shift;
 			shift += 7;
 		}
 	}
@@ -66,10 +64,9 @@ bare_get_uint(struct bare_reader *ctx, uint64_t *x)
 	return err;
 }
 
-bare_error
-bare_put_int(struct bare_writer *ctx, int64_t x)
+bare_error bare_put_int(struct bare_writer *ctx, int64_t x)
 {
-	uint64_t ux = (uint64_t)x << 1;
+	uint64_t ux = (uint64_t) x << 1;
 
 	if (x < 0) {
 		ux = ~ux;
@@ -78,15 +75,14 @@ bare_put_int(struct bare_writer *ctx, int64_t x)
 	return bare_put_uint(ctx, ux);
 }
 
-bare_error
-bare_get_int(struct bare_reader *ctx, int64_t *x)
+bare_error bare_get_int(struct bare_reader *ctx, int64_t *x)
 {
 	uint64_t ux;
 
 	bare_error err = bare_get_uint(ctx, &ux);
 
 	if (err == BARE_ERROR_NONE) {
-		*x = (int64_t)(ux >> 1);
+		*x = (int64_t) (ux >> 1);
 
 		if ((ux & 1) != 0) {
 			*x = ~(*x);
@@ -96,67 +92,62 @@ bare_get_int(struct bare_reader *ctx, int64_t *x)
 	return err;
 }
 
-bare_error
-bare_put_u8(struct bare_writer *ctx, uint8_t x)
+bare_error bare_put_u8(struct bare_writer *ctx, uint8_t x)
 {
 	return ctx->write(ctx->buffer, &x, U8SZ);
 }
 
-bare_error
-bare_get_u8(struct bare_reader *ctx, uint8_t *x)
+bare_error bare_get_u8(struct bare_reader *ctx, uint8_t *x)
 {
 	return ctx->read(ctx->buffer, x, U8SZ);
 }
 
-bare_error
-bare_put_u16(struct bare_writer *ctx, uint16_t x)
+bare_error bare_put_u16(struct bare_writer *ctx, uint16_t x)
 {
-	return ctx->write(ctx->buffer, (uint8_t[U16SZ]){x, x >> 8}, U16SZ);
+	return ctx->write(ctx->buffer, (uint8_t[U16SZ]) {
+			  x, x >> 8}
+			  , U16SZ);
 }
 
-bare_error
-bare_get_u16(struct bare_reader *ctx, uint16_t *x)
+bare_error bare_get_u16(struct bare_reader *ctx, uint16_t *x)
 {
 	bare_error err = ctx->read(ctx->buffer, x, U16SZ);
 
 	if (err == BARE_ERROR_NONE) {
-		*x = (uint16_t)((uint8_t *)x)[0]
-		   | (uint16_t)((uint8_t *)x)[1] << 8;
+		*x = (uint16_t) ((uint8_t *) x)[0]
+		    | (uint16_t) ((uint8_t *) x)[1] << 8;
 	}
 
 	return err;
 }
 
-bare_error
-bare_put_u32(struct bare_writer *ctx, uint32_t x)
+bare_error bare_put_u32(struct bare_writer *ctx, uint32_t x)
 {
 	uint8_t buf[U32SZ];
 
-	buf[0] = (uint8_t)(x);
-	buf[1] = (uint8_t)(x >> 8);
-	buf[2] = (uint8_t)(x >> 16);
-	buf[3] = (uint8_t)(x >> 24);
+	buf[0] = (uint8_t) (x);
+	buf[1] = (uint8_t) (x >> 8);
+	buf[2] = (uint8_t) (x >> 16);
+	buf[3] = (uint8_t) (x >> 24);
 
 	return ctx->write(ctx->buffer, buf, U32SZ);
 }
 
-bare_error
-bare_get_u32(struct bare_reader *ctx, uint32_t *x)
+bare_error bare_get_u32(struct bare_reader *ctx, uint32_t *x)
 {
 	bare_error err = ctx->read(ctx->buffer, x, U32SZ);
 
 	if (err == BARE_ERROR_NONE) {
-		*x = (uint32_t)(((uint8_t *)x)[0])
-		   | (uint32_t)(((uint8_t *)x)[1] << 8)
-		   | (uint32_t)(((uint8_t *)x)[2] << 16)
-		   | (uint32_t)(((uint8_t *)x)[3] << 24);
+		*x = (uint32_t) (((uint8_t *) x)[0])
+		    | (uint32_t) (((uint8_t *) x)[1] << 8)
+		    | (uint32_t) (((uint8_t *) x)[2] << 16)
+		    | (uint32_t) (((uint8_t *) x)[3] << 24);
 	}
 
 	return err;
 }
 
-bare_error
-bare_put_u64(struct bare_writer *ctx, uint64_t x)
+bare_error bare_put_u64(struct bare_writer *ctx, uint64_t x)
 {
 	uint8_t buf[U64SZ];
 
@@ -172,75 +163,65 @@ bare_put_u64(struct bare_writer *ctx, uint64_t x)
 	return ctx->write(ctx->buffer, buf, U64SZ);
 }
 
-bare_error
-bare_get_u64(struct bare_reader *ctx, uint64_t *x)
+bare_error bare_get_u64(struct bare_reader *ctx, uint64_t *x)
 {
 	bare_error err = ctx->read(ctx->buffer, x, U64SZ);
 
 	if (err == BARE_ERROR_NONE) {
-		*x = (uint64_t)((uint8_t *)x)[0]
-		   | (uint64_t)((uint8_t *)x)[1] << 8
-		   | (uint64_t)((uint8_t *)x)[2] << 16
-		   | (uint64_t)((uint8_t *)x)[3] << 24
-		   | (uint64_t)((uint8_t *)x)[4] << 32
-		   | (uint64_t)((uint8_t *)x)[5] << 40
-		   | (uint64_t)((uint8_t *)x)[6] << 48
-		   | (uint64_t)((uint8_t *)x)[7] << 56;
+		*x = (uint64_t) ((uint8_t *) x)[0]
+		    | (uint64_t) ((uint8_t *) x)[1] << 8
+		    | (uint64_t) ((uint8_t *) x)[2] << 16
+		    | (uint64_t) ((uint8_t *) x)[3] << 24
+		    | (uint64_t) ((uint8_t *) x)[4] << 32
+		    | (uint64_t) ((uint8_t *) x)[5] << 40
+		    | (uint64_t) ((uint8_t *) x)[6] << 48
+		    | (uint64_t) ((uint8_t *) x)[7] << 56;
 	}
 
 	return err;
 }
 
-bare_error
-bare_put_i8(struct bare_writer *ctx, int8_t x)
+bare_error bare_put_i8(struct bare_writer *ctx, int8_t x)
 {
 	return bare_put_u8(ctx, x);
 }
 
-bare_error
-bare_get_i8(struct bare_reader *ctx, int8_t *x)
+bare_error bare_get_i8(struct bare_reader *ctx, int8_t *x)
 {
-	return bare_get_u8(ctx, (uint8_t *)x);
+	return bare_get_u8(ctx, (uint8_t *) x);
 }
 
-bare_error
-bare_put_i16(struct bare_writer *ctx, int16_t x)
+bare_error bare_put_i16(struct bare_writer *ctx, int16_t x)
 {
 	return bare_put_u16(ctx, x);
 }
 
-bare_error
-bare_get_i16(struct bare_reader *ctx, int16_t *x)
+bare_error bare_get_i16(struct bare_reader *ctx, int16_t *x)
 {
-	return bare_get_u16(ctx, (uint16_t *)x);
+	return bare_get_u16(ctx, (uint16_t *) x);
 }
 
-bare_error
-bare_put_i32(struct bare_writer *ctx, int32_t x)
+bare_error bare_put_i32(struct bare_writer *ctx, int32_t x)
 {
 	return bare_put_u32(ctx, x);
 }
 
-bare_error
-bare_get_i32(struct bare_reader *ctx, int32_t *x)
+bare_error bare_get_i32(struct bare_reader *ctx, int32_t *x)
 {
-	return bare_get_u32(ctx, (uint32_t *)x);
+	return bare_get_u32(ctx, (uint32_t *) x);
 }
 
-bare_error
-bare_put_i64(struct bare_writer *ctx, int64_t x)
+bare_error bare_put_i64(struct bare_writer *ctx, int64_t x)
 {
 	return bare_put_u64(ctx, x);
 }
 
-bare_error
-bare_get_i64(struct bare_reader *ctx, int64_t *x)
+bare_error bare_get_i64(struct bare_reader *ctx, int64_t *x)
 {
-	return bare_get_u64(ctx, (uint64_t *)x);
+	return bare_get_u64(ctx, (uint64_t *) x);
 }
 
-bare_error
-bare_put_f32(struct bare_writer *ctx, float x)
+bare_error bare_put_f32(struct bare_writer *ctx, float x)
 {
 	uint32_t b;
 	memcpy(&b, &x, U32SZ);
@@ -248,14 +229,12 @@ bare_put_f32(struct bare_writer *ctx, float x)
 	return bare_put_u32(ctx, b);
 }
 
-bare_error
-bare_get_f32(struct bare_reader *ctx, float *x)
+bare_error bare_get_f32(struct bare_reader *ctx, float *x)
 {
 	return ctx->read(ctx->buffer, x, U32SZ);
 }
 
-bare_error
-bare_put_f64(struct bare_writer *ctx, double x)
+bare_error bare_put_f64(struct bare_writer *ctx, double x)
 {
 	uint64_t b;
 	memcpy(&b, &x, U64SZ);
@@ -263,22 +242,19 @@ bare_put_f64(struct bare_writer *ctx, double x)
 	return bare_put_u64(ctx, b);
 }
 
-bare_error
-bare_get_f64(struct bare_reader *ctx, double *x)
+bare_error bare_get_f64(struct bare_reader *ctx, double *x)
 {
 	return ctx->read(ctx->buffer, x, U64SZ);
 }
 
-bare_error
-bare_put_bool(struct bare_writer *ctx, bool x)
+bare_error bare_put_bool(struct bare_writer *ctx, bool x)
 {
-	return bare_put_u8(ctx, (uint8_t)x);
+	return bare_put_u8(ctx, (uint8_t) x);
 }
 
-bare_error
-bare_get_bool(struct bare_reader *ctx, bool *x)
+bare_error bare_get_bool(struct bare_reader *ctx, bool *x)
 {
-	return bare_get_u8(ctx, (uint8_t *)x);
+	return bare_get_u8(ctx, (uint8_t *) x);
 }
 
 bare_error
@@ -307,8 +283,7 @@ bare_put_data(struct bare_writer *ctx, const uint8_t *src, uint64_t sz)
 	return err;
 }
 
-bare_error
-bare_get_data(struct bare_reader *ctx, uint8_t *dst, uint64_t sz)
+bare_error bare_get_data(struct bare_reader *ctx, uint8_t *dst, uint64_t sz)
 {
 	bare_error err = BARE_ERROR_NONE;
 	uint64_t ssz = 0;
@@ -316,22 +291,19 @@ bare_get_data(struct bare_reader *ctx, uint8_t *dst, uint64_t sz)
 	err = bare_get_uint(ctx, &ssz);
 
 	if (err == BARE_ERROR_NONE) {
-		err = ssz <= sz \
-			? bare_get_fixed_data(ctx, dst, ssz) \
-			: BARE_ERROR_BUFFER_TOO_SMALL;
+		err = ssz <= sz ? bare_get_fixed_data(ctx, dst, ssz)
+		    : BARE_ERROR_BUFFER_TOO_SMALL;
 	}
 
 	return err;
 }
 
-bare_error
-bare_put_str(struct bare_writer *ctx, const char *src, uint64_t sz)
+bare_error bare_put_str(struct bare_writer *ctx, const char *src, uint64_t sz)
 {
-	return bare_put_data(ctx, (uint8_t *)src, sz);
+	return bare_put_data(ctx, (uint8_t *) src, sz);
 }
 
-bare_error
-bare_get_str(struct bare_reader *ctx, char *dst, uint64_t sz)
+bare_error bare_get_str(struct bare_reader *ctx, char *dst, uint64_t sz)
 {
-	return bare_get_data(ctx, (uint8_t *)dst, sz);
+	return bare_get_data(ctx, (uint8_t *) dst, sz);
 }