Explorar el Código

add uint64 pack and unpack routines

master
Felix von Leitner hace 13 años
padre
commit
b8a94d5b7b
Se han modificado 18 ficheros con 231 adiciones y 3 borrados
  1. +1
    -0
      CHANGES
  2. +66
    -0
      test/uint.c
  3. +1
    -1
      uint/uint32_pack_big.3
  4. +17
    -0
      uint/uint64_pack.3
  5. +8
    -0
      uint/uint64_pack.c
  6. +17
    -0
      uint/uint64_pack_big.3
  7. +8
    -0
      uint/uint64_pack_big.c
  8. +15
    -0
      uint/uint64_read.3
  9. +7
    -0
      uint/uint64_read.c
  10. +15
    -0
      uint/uint64_read_big.3
  11. +7
    -0
      uint/uint64_read_big.c
  12. +17
    -0
      uint/uint64_unpack.3
  13. +7
    -0
      uint/uint64_unpack.c
  14. +18
    -0
      uint/uint64_unpack_big.3
  15. +7
    -0
      uint/uint64_unpack_big.c
  16. +1
    -1
      uint16.h
  17. +1
    -1
      uint32.h
  18. +18
    -0
      uint64.h

+ 1
- 0
CHANGES Ver fichero

@@ -1,4 +1,5 @@
0.28:
add uint64 pack and unpack routines

0.27:
add fmt_strm


+ 66
- 0
test/uint.c Ver fichero

@@ -0,0 +1,66 @@
#include <assert.h>
#include <uint16.h>
#include <uint32.h>
#include <uint64.h>
#include <byte.h>

int main() {
char buf[8];

{
uint16 a;

buf[0]=buf[1]=0;
uint16_pack_big(buf,0x1234);
assert(buf[0]==0x12 && buf[1]==0x34);
uint16_unpack_big(buf,&a);
assert(a==0x1234);
assert(uint16_read_big(buf)==0x1234);

buf[0]=buf[1]=0;
uint16_pack(buf,0x1234);
assert(buf[0]==0x34 && buf[1]==0x12);
uint16_unpack(buf,&a);
assert(a==0x1234);
assert(uint16_read(buf)==0x1234);
}

{
uint32 a;

buf[0]=buf[1]=buf[2]=buf[3]=0;
uint32_pack_big(buf,0x12345678);
assert(buf[0]==0x12 && buf[1]==0x34 && buf[2]==0x56 && buf[3]==0x78);
uint32_unpack_big(buf,&a);
assert(a==0x12345678);
assert(uint32_read_big(buf)==0x12345678);

buf[0]=buf[1]=buf[2]=buf[3]=0;
uint32_pack(buf,0x12345678);
assert(buf[0]==0x78 && buf[1]==0x56 && buf[2]==0x34 && buf[3]==0x12);
uint32_unpack(buf,&a);
assert(a==0x12345678);
assert(uint32_read(buf)==0x12345678);
}

{
uint64 a;
unsigned int i;

byte_zero(buf,sizeof(buf));
uint64_pack_big(buf,0x0102030405060708ull);
for (i=0; i<8; ++i) assert(buf[i]==i+1);
uint64_unpack_big(buf,&a);
assert(a==0x0102030405060708ull);
assert(uint64_read_big(buf)==0x0102030405060708ull);

byte_zero(buf,sizeof(buf));
uint64_pack(buf,0x0102030405060708ull);
for (i=0; i<8; ++i) assert(buf[7-i]==i+1);
uint64_unpack(buf,&a);
assert(a==0x0102030405060708ull);
assert(uint64_read(buf)==0x0102030405060708ull);
}


}

+ 1
- 1
uint/uint32_pack_big.3 Ver fichero

@@ -11,7 +11,7 @@ void \fBuint32_pack_big\fP(char \fIs\fR[4],uint32 \fIu\fR);
uint32 is a 32-bit unsigned integer type, normally either unsigned int
or unsigned long.

uint32_pack_big portably writes a uint16 \fIu\fR to \fIs\fR in
uint32_pack_big portably writes a uint32 \fIu\fR to \fIs\fR in
big-endian (i.e. network) byte order.

.SH "SEE ALSO"


+ 17
- 0
uint/uint64_pack.3 Ver fichero

@@ -0,0 +1,17 @@
.TH uint64_pack 3
.SH NAME
uint64_pack \- write an unsigned little-endian 64-bit integer
.SH SYNTAX
.B #include <uint64.h>

uint64 \fIu\fR;

void \fBuint64_pack\fP(char \fIs\fR[4],uint64 \fIu\fR);
.SH DESCRIPTION
uint64 is a 64-bit unsigned integer type.

uint64_pack portably writes a uint64 \fIu\fR to \fIs\fR in
little-endian byte order.

.SH "SEE ALSO"
uint64_unpack(3), uint64_pack_big(3)

+ 8
- 0
uint/uint64_pack.c Ver fichero

@@ -0,0 +1,8 @@
#define NO_UINT64_MACROS
#include "uint64.h"
#include "uint32.h"

void uint64_pack(char *out,uint64 in) {
uint32_pack(out,in&0xffffffff);
uint32_pack(out+4,in>>32);
}

+ 17
- 0
uint/uint64_pack_big.3 Ver fichero

@@ -0,0 +1,17 @@
.TH uint64_pack_big 3
.SH NAME
uint64_pack_big \- write an unsigned big-endian 64-bit integer
.SH SYNTAX
.B #include <uint64.h>

uint64 \fIu\fR;

void \fBuint64_pack_big\fP(char \fIs\fR[4],uint64 \fIu\fR);
.SH DESCRIPTION
uint64 is a 64-bit unsigned integer type.

uint64_pack_big portably writes a uint64 \fIu\fR to \fIs\fR in
big-endian (i.e. network) byte order.

.SH "SEE ALSO"
uint64_unpack_big(3), uint64_pack(3)

+ 8
- 0
uint/uint64_pack_big.c Ver fichero

@@ -0,0 +1,8 @@
#define NO_UINT64_MACROS
#include "uint64.h"
#include "uint32.h"

void uint64_pack_big(char *out,uint64 in) {
uint32_pack_big(out,in>>32);
uint32_pack_big(out+4,in&0xffffffff);
}

+ 15
- 0
uint/uint64_read.3 Ver fichero

@@ -0,0 +1,15 @@
.TH uint64_read 3
.SH NAME
uint64_read \- read an unsigned little-endian 64-bit integer
.SH SYNTAX
.B #include <uint64.h>

uint64 \fBuint64_read\fP(const char \fIs\fR[4]);
.SH DESCRIPTION
uint64 is a 64-bit unsigned integer type.

uint64_read portably reads a uint64 as stored on a little-endian
architecture from \fIs\fR and returns it.

.SH "SEE ALSO"
uint64_unpack(3), uint64_unpack_big(3)

+ 7
- 0
uint/uint64_read.c Ver fichero

@@ -0,0 +1,7 @@
#define NO_UINT64_MACROS
#include "uint64.h"
#include "uint32.h"

uint64 uint64_read(const char *in) {
return uint32_read(in) | ((uint64)uint32_read(in+4)<<32);
}

+ 15
- 0
uint/uint64_read_big.3 Ver fichero

@@ -0,0 +1,15 @@
.TH uint64_read_big 3
.SH NAME
uint64_read_big \- read an unsigned big-endian 64-bit integer
.SH SYNTAX
.B #include <uint64.h>

uint64 \fBuint64_read_big\fP(const char \fIs\fR[4]);
.SH DESCRIPTION
uint64 is a 64-bit unsigned integer type.

uint64_read_big portably reads a uint64 as stored on a big-endian
architecture from \fIs\fR and returns it.

.SH "SEE ALSO"
uint64_unpack(3), uint64_unpack_big(3)

+ 7
- 0
uint/uint64_read_big.c Ver fichero

@@ -0,0 +1,7 @@
#define NO_UINT64_MACROS
#include "uint64.h"
#include "uint32.h"

uint64 uint64_read_big(const char *in) {
return ((uint64)uint32_read_big(in)<<32) | uint32_read_big(in+4);
}

+ 17
- 0
uint/uint64_unpack.3 Ver fichero

@@ -0,0 +1,17 @@
.TH uint64_unpack 3
.SH NAME
uint64_unpack \- read an unsigned little-endian 64-bit integer
.SH SYNTAX
.B #include <uint64.h>

uint64 \fIu\fR;

void \fBuint64_unpack\fP(const char \fIs\fR[4],uint64 *\fIu\fR);
.SH DESCRIPTION
uint64 is a 64-bit unsigned integer type.

uint64_unpack portably reads a uint64 as stored on a little-endian
architecture from \fIs\fR and writes it into \fIu\fR in the native byte order.

.SH "SEE ALSO"
uint64_pack(3), uint64_unpack_big(3)

+ 7
- 0
uint/uint64_unpack.c Ver fichero

@@ -0,0 +1,7 @@
#define NO_UINT64_MACROS
#include "uint64.h"
#include "uint32.h"

void uint64_unpack(const char *in,uint64 *out) {
*out = uint64_read(in);
}

+ 18
- 0
uint/uint64_unpack_big.3 Ver fichero

@@ -0,0 +1,18 @@
.TH uint64_unpack_big 3
.SH NAME
uint64_unpack_big \- read an unsigned big-endian 64-bit integer
.SH SYNTAX
.B #include <uint64.h>

uint64 \fIu\fR;

void \fBuint64_unpack_big\fP(const char \fIs\fR[4],uint64 *\fIu\fR);
.SH DESCRIPTION
uint64 is a 64-bit unsigned integer type.

uint64_unpack_big portably reads a uint64 as stored on a big-endian
architecture (i.e. in network byte order) from \fIs\fR and writes it
into \fIu\fR in the native byte order.

.SH "SEE ALSO"
uint64_pack_big(3), uint64_unpack(3)

+ 7
- 0
uint/uint64_unpack_big.c Ver fichero

@@ -0,0 +1,7 @@
#define NO_UINT64_MACROS
#include "uint64.h"
#include "uint32.h"

void uint64_unpack_big(const char *in,uint64 *out) {
*out = uint64_read_big(in);
}

+ 1
- 1
uint16.h Ver fichero

@@ -6,7 +6,7 @@
typedef uint16_t uint16;
typedef int16_t int16;

#if defined(__i386__) && !defined(NO_UINT16_MACROS)
#if (defined(__i386__) || defined(__x86_64__)) && !defined(NO_UINT16_MACROS)
#define uint16_pack(out,in) (*(uint16*)(out)=(in))
#define uint16_unpack(in,out) (*(out)=*(uint16*)(in))
#define uint16_read(in) (*(uint16*)(in))


+ 1
- 1
uint32.h Ver fichero

@@ -6,7 +6,7 @@
typedef uint32_t uint32;
typedef int32_t int32;

#if defined(__i386__) && !defined(NO_UINT32_MACROS)
#if (defined(__i386__) || defined(__x86_64__)) && !defined(NO_UINT32_MACROS)
#define uint32_pack(out,in) (*(uint32*)(out)=(in))
#define uint32_unpack(in,out) (*(out)=*(uint32*)(in))
#define uint32_read(in) (*(uint32*)(in))


+ 18
- 0
uint64.h Ver fichero

@@ -6,4 +6,22 @@
typedef uint64_t uint64;
typedef int64_t int64;

#if (defined(__i386__) || defined(__x86_64__)) && !defined(NO_UINT64_MACROS)
#define uint64_pack(out,in) (*(uint64*)(out)=(in))
#define uint64_unpack(in,out) (*(out)=*(uint64*)(in))
#define uint64_read(in) (*(uint64*)(in))
void uint64_pack_big(char *out,uint64 in);
void uint64_unpack_big(const char *in,uint64* out);
uint64 uint64_read_big(const char *in);
#else

void uint64_pack(char *out,uint64 in);
void uint64_pack_big(char *out,uint64 in);
void uint64_unpack(const char *in,uint64* out);
void uint64_unpack_big(const char *in,uint64* out);
uint64 uint64_read(const char *in);
uint64 uint64_read_big(const char *in);

#endif

#endif

Cargando…
Cancelar
Guardar