spacepaste

Paste details

reply | raw

  1.  
  2. $ cat ../../disassemblertmp/encoding.h
  3. int offset = 0;
  4. int bitcount = 0;
  6. unsigned char * readbin(unsigned char * encoding, int len) {
  7. unsigned char * bits = malloc(32);
  8. int ii = 7;
  9. int was_set = 0;
  11. for (int i = 0; i < len; i++)
  12. {
  13. bits[i]=!getBit(*encoding, ii)?'0':'1';
  14. ii--;
  15. bitcount++;
  16. if (bitcount>7) {
  17. encoding = (encoding)+0x1;
  18. bitcount = 0;
  19. was_set = 1;
  20. ii = 7;
  21. }
  22. }
  23. if (was_set == 0 && bitcount<=7) for(int i = 0; i < len; i++) *encoding = *encoding << 0x1;
  24. was_set = 0;
  25. return bits;
  26. }
  28. unsigned char * readbin_(unsigned char * encoding, int len) {
  29. unsigned char * bits = malloc(len);
  30. int ii = 7;
  31. int was_set = 0;
  33. for (int i = 0; i < len; i++)
  34. {
  35. bits[i]=!getBit(*encoding, ii)?'0':'1';
  36. ii--;
  37. bitcount++;
  38. if (bitcount>7) {
  39. encoding = (encoding)+0x1;
  40. bitcount = 0;
  41. was_set = 1;
  42. ii = 7;
  43. }
  44. }
  45. bits[len] = 0;
  46. if (was_set == 0 && bitcount<=7) for(int i = 0; i < len; i++) *encoding = *encoding << 0x1;
  47. was_set = 0;
  48. return bits;
  49. }
  51. unsigned char * readbin_l(unsigned char * encoding, int len) {
  52. unsigned char * bits = malloc(len);
  53. int ii = 7;
  54. int was_set = 0;
  56. for (int i = len-1; i >= 0 ; i--)
  57. {
  58. bits[i]=!getBit(*encoding, ii)?'0':'1';
  59. ii--;
  60. bitcount++;
  61. if (bitcount>7) {
  62. encoding = (encoding)+0x1;
  63. bitcount = 0;
  64. was_set = 1;
  65. ii = 7;
  66. }
  67. }
  68. bits[len] = 0;
  69. if (was_set == 0 && bitcount<=7) for(int i = 0; i < len; i++) *encoding = *encoding << 0x1;
  70. was_set = 0;
  71. return bits;
  72. }
  76. unsigned char * readbin_r(unsigned char * encoding, int len) {
  77. unsigned char * bits = malloc(len);
  78. int ii = 7;
  79. int was_set = 0;
  81. for (int i = 0; i < len; i++)
  82. {
  83. bits[i]=!getBit(*encoding, ii)?'0':'1';
  84. ii--;
  85. bitcount++;
  86. if (bitcount>7) {
  87. encoding = (encoding)+0x1;
  88. bitcount = 0;
  89. was_set = 1;
  90. ii = 7;
  91. }
  92. }
  93. bits[len] = 0;
  94. if (was_set == 0 && bitcount<=7) for(int i = 0; i < len; i++) *encoding = *encoding << 0x1;
  95. was_set = 0;
  96. return bits;
  97. }
  100. #define printBin32(num) { \
  101. for (int i = 31; i != -1; i--) { \
  102. ifc printf_r("%d", (num >> i) & 0x1); \
  103. else printf("%d", (num >> i) & 0x1); \
  104. } \
  105. printf(" = %s", #num); \
  106. }
  108. #define printBinLen(num, len) { \
  109. for (int i = len-1; i != -1; i--) { \
  110. ifc printf_r("%d", (num >> i) & 0x1); \
  111. else printf("%d", (num >> i) & 0x1); \
  112. } \
  113. printf(" = %s", #num); \
  114. }
  116. int BITC = 0;
  117. int BITL = 0;
  118. int BITI = 0;
  119. char * BinLen(unsigned char ** num, int len) {
  120. unsigned char * n = *num;
  121. unsigned char * bits = malloc(len+1);
  122. for (int i = len-1; i != -1; i--) {
  123. pi(getBit((*num), 7));
  124. pi(getBit((*num), 7));
  125. }
  126. return bits;
  127. }
  129. char * BinLen_(unsigned char ** encoding, int len) {
  130. unsigned char * bits = malloc(32);
  131. int ii = 7;
  132. int was_set = 0;
  134. for (int i = 0; i < len; i++)
  135. {
  136. bits[i]=(!getBit(*encoding, ii))?'0':'1';
  137. ii--;
  138. bitcount++;
  139. if (bitcount>7) {
  140. (*encoding)++;
  141. bitcount = 0;
  142. was_set = 1;
  143. ii = 7;
  144. }
  145. }
  146. // if (was_set == 0 && bitcount<=7) for(int i = 0; i < len; i++) *encoding = *encoding << 0x1;
  147. was_set = 0;
  148. return bits;
  149. }
  151. #define printarray32(num) { \
  152. for (int i = 0; i != 32; i++) { \
  153. ifc printf_r("%c", num[i]); \
  154. else printf("%c", num[i]); \
  155. } \
  156. printf(" = %s", #num); \
  157. }
  159. $ cat ../../disassemblertmp/binary.h
  160. #include <stdio.h>
  161. #include <inttypes.h>
  162. #include <string.h>
  163. #include <stdlib.h>
  164. #include <limits.h>
  165. #include <stdbool.h>
  166. #define BINMODE_WRITE 0
  167. #define BINMODE_APPEND 1
  168. // add two write modes:
  169. // truncate to 0 and append from index 0
  170. // append from current index without truncating
  171. #define ENDIAN_LITTLE 1
  172. #define ENDIAN_BIG 0
  173. #define pui64(x) printf("%s = %" PRIu64 "\n", #x, x);
  174. #define pi(x) printf("%s = %d\n", #x, x);
  175. #define ps(x) printf("%s = %s\n", #x, x);
  176. #define pc(x) printf("%s = %c\n", #x, x);
  177. #define psize_t(x) printf("%s = %zu\n", #x, x);
  178. #define pz(x) psize_t(x)
  179. int bitcount_ = 1;
  181. struct strStream {
  182. unsigned char *s;
  183. int bitpos;
  184. uint64_t *s64;
  185. int bitpos64;
  186. };
  188. struct binbuf {
  189. struct strStream * data;
  190. size_t length;
  191. size_t length64;
  192. int BINMODE;
  193. int bitcount;
  194. int bitcount64;
  195. };
  197. struct strStream * strStream_init(unsigned char * string) {
  198. struct strStream * str = malloc(sizeof(struct strStream));
  199. str->s = string;
  200. str->s64 = NULL;
  201. str->bitpos = 0;
  202. str->bitpos64 = 0;
  203. return str;
  204. }
  206. void strStream_deinit(struct strStream * * str) {
  207. (*str)->s = NULL;
  208. (*str)->s64 = NULL;
  209. (*str)->bitpos = 0;
  210. (*str)->bitpos64 = 0;
  211. free((*str));
  212. }
  214. struct binbuf binbuf_init(int mode) {
  215. struct binbuf bin = {0};
  216. bin.data = strStream_init(NULL);
  217. bin.BINMODE = mode;
  218. bin.bitcount = 0;
  219. bin.bitcount64 = 0;
  220. return bin;
  221. }
  223. int divtoshift(int x) {
  224. int n = 0;
  225. while(x /= 2) n++;
  226. return n;
  227. }
  229. // reads a binary string writing it as literal to a buffer
  231. int read__binary(struct binbuf * bin, char * s) {
  232. //printf( "INPUT:%s\n", s );
  233. int newlen = strlen(s);
  234. int totlen = bin->length + newlen; // adds number of bits in input string
  236. // realloc new total (rounded up) bytes for new bittotal
  237. bin->data->s = realloc(bin->data->s, ((bin->length = totlen) + (CHAR_BIT-1)) /CHAR_BIT );
  238. memset( bin->data->s + ( ( bin->bitcount + (CHAR_BIT-1)) /CHAR_BIT ), 0, ( ( bin->length - bin->bitcount + (CHAR_BIT-1)) /CHAR_BIT ) );
  240. int i;
  241. for( i = 0; i < newlen; i++) {
  242. bin->data->s[((bin->bitcount + i)>>divtoshift(CHAR_BIT))] |= ( s[i] == '1' ? (UINT8_MAX) : 0 ) >> ((CHAR_BIT-1)-(bin->bitcount + i)&(CHAR_BIT-1));
  243. }
  245. // bitcount is really the same as bin->length, but delayed ....
  246. bin->bitcount += i;
  247. return 0;
  248. }
  250. int read__binary64(struct binbuf * bin, char * s) {
  251. //printf( "INPUT:%s\n", s );
  252. int newlen = strlen(s);
  253. int totlen = bin->length64 + newlen; // adds number of bits in input string
  255. // realloc new total (rounded up) bytes for new bittotal
  256. bin->data->s64 = realloc(bin->data->s64, ((bin->length64 = totlen) + (64-1)) /64 );
  257. memset( bin->data->s64 + ( ( bin->bitcount64 + (64-1) ) / 64 ), 0, ( ( bin->length64 - bin->bitcount64 + (64-1) ) / 64 ) );
  259. int i;
  260. for( i = 0; i < newlen; i++) {
  261. bin->data->s64[((bin->bitcount64 + i)>>divtoshift(64))] |= ( s[i] == '1' ? (UINT64_MAX) : 0 ) >> ((64-1)-(bin->bitcount64 + i)&(64-1));
  262. }
  264. // bitcount is really the same as bin->length, but delayed ....
  265. bin->bitcount64 += i;
  266. return 0;
  267. }
  269. unsigned char * bits = NULL;
  271. int read__string_undo(struct strStream * strStream) {
  272. if (bits) strStream->bitpos -= strlen(bits);
  273. return 0;
  274. }
  276. // reads a string returning it as a binary string
  277. unsigned char * read__string(struct strStream * strStream, int len, bool undo, bool endian) {
  278. if (undo == true) read__string_undo(strStream);
  279. if (bits) {
  280. memset(bits,0,strlen(bits));
  281. free(bits);
  282. }
  283. bits = malloc(len+1);
  284. int i, idx = 0;
  285. if (endian == ENDIAN_BIG) {
  286. for ( i = 0; i < len; i++) {
  287. if( strStream->s[ (strStream->bitpos + i)>>divtoshift(CHAR_BIT) ]
  288. & ( 1 << ( ( strStream->bitpos + i ) & (CHAR_BIT-1) ) ) )
  289. bits[idx] = '1';
  290. else
  291. bits[idx] = '0';
  292. idx++;
  293. }
  294. } else if (endian == ENDIAN_LITTLE) { // reads incorrectly
  295. for ( i = len-1; i >= 0; i--) {
  296. if( strStream->s[ (strStream->bitpos + i)>>divtoshift(CHAR_BIT) ]
  297. & ( 1 << ( ( strStream->bitpos + i ) & (CHAR_BIT-1) ) ) )
  298. bits[idx] = '1';
  299. else
  300. bits[idx] = '0';
  301. idx++;
  302. }
  303. }
  304. strStream->bitpos += idx;
  305. bits[idx] = 0;
  306. return bits;
  307. }
  309. unsigned char * bits64 = NULL;
  311. int read__string_undo64(struct strStream * strStream) {
  312. if (bits64) strStream->bitpos64 -= strlen(bits64);
  313. return 0;
  314. }
  317. unsigned char * read__string64(struct strStream * strStream, int len, bool undo, bool endian) {
  318. if (undo == true) read__string_undo64(strStream);
  319. if (bits64) {
  320. memset(bits64,0,strlen(bits64));
  321. free(bits64);
  322. }
  323. bits64 = malloc(len+1);
  324. int i, idx = 0;
  325. if (endian == ENDIAN_BIG) {
  326. for ( i = 0; i < len; i++) {
  327. if( strStream->s64[ (strStream->bitpos64 + i)>>divtoshift(64) ]
  328. & ( (uint64_t)1 << ( ( strStream->bitpos64 + i ) & (64-1)) ) )
  329. bits64[idx] = '1';
  330. else
  331. bits64[idx] = '0';
  332. idx++;
  333. }
  334. } else if (endian == ENDIAN_LITTLE) {
  335. for ( i = len; i > 0; i--) {
  336. if( strStream->s64[ (strStream->bitpos64 + i)>>divtoshift(64) ]
  337. & ( (uint64_t)1 << ( ( strStream->bitpos64 + i ) & (64-1)) ) )
  338. bits64[idx] = '1';
  339. else
  340. bits64[idx] = '0';
  341. idx++;
  342. }
  343. }
  344. strStream->bitpos64 += len;
  345. bits64[idx] = 0;
  346. return bits64;
  347. }
  348.  
Powered by spacepaste. Paste removal.