doxygen

jimi-wzq

2021-01-12 48e47110397c894716525db219e53300c08f64dd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include "net_mod_socket_io.h"
#include "socket_io.h"
#include <stdint.h> 
 
ssize_t rio_read_until_sep(rio_t *rp, char *usrbuf, size_t maxlen, const char *sep)
{
  int n, rc;
  char c;
  char *bufp = usrbuf;
  int sep_i = 0;
  int sep_len = strlen(sep);
 
  for (n = 0; n < maxlen; n++)
  {
    if ((rc = rio_readnb(rp, &c, 1)) == 1)
    {
      
      *bufp++ = c;
      
      if(c == *(sep + sep_i)) {
        sep_i++;
        if(sep_i == sep_len) {
             
          break;
        } 
      } else {
 
        sep_i = 0;
      }
 
    }
    else if (rc == 0)
    {
      if (n == 0)
        return 0; /* EOF, no data read */
      else
        break;    /* EOF, some data was read */
    }
    else
      return -1;    /* Error */
  }
 
  if(sep_i == sep_len) {
    *(bufp - sep_len) = 0;
    return n - sep_len;
  } else {
    return -1;
  }
  
}
 
 
 
int is_little_endian() {
  int test_num = 0xff;
  unsigned char* byte_start = (unsigned char*) &test_num;
 
  if (byte_start[0] == 0xff) {
    return 1;
  }
  return 0;
}
 
void swap_bytes(void *pv, size_t n)
{
    assert(n > 0);
 
    char *p = (char *)pv;
    size_t lo, hi;
    for(lo=0, hi=n-1; hi>lo; lo++, hi--)
    {
        char tmp=p[lo];
        p[lo] = p[hi];
        p[hi] = tmp;
    }
}
 
 
//! Byte swap unsigned short
uint16_t swap_uint16( uint16_t val ) 
{
    return (val << 8) | (val >> 8 );
}
 
//! Byte swap short
int16_t swap_int16( int16_t val ) 
{
    return (val << 8) | ((val >> 8) & 0xFF);
}
 
//! Byte swap unsigned int
uint32_t swap_uint32( uint32_t val )
{
    val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF ); 
    return (val << 16) | (val >> 16);
}
 
//! Byte swap int
int32_t swap_int32( int32_t val )
{
    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF ); 
    return (val << 16) | ((val >> 16) & 0xFFFF);
}
 
 
int64_t swap_int64( int64_t val )
{
    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
    return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
}
 
uint64_t swap_uint64( uint64_t val )
{
    val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
    val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
    return (val << 32) | (val >> 32);
}