void UArray_setAllBitsTo_(UArray *self, uint8_t aBool) { size_t i, max = UArray_sizeInBytes(self); uint8_t *data = self->data; uint8_t bits = aBool ? ~0 : 0; for (i = 0; i < max; i ++) { data[i] = bits; } }
void UArray_setItemType_(UArray *self, CTYPE type) { size_t itemSize = CTYPE_size(type); div_t q = div(UArray_sizeInBytes(self), itemSize); if (q.rem != 0) { q.quot += 1; UArray_setSize_(self, (q.quot * itemSize) / self->itemSize); } self->itemType = type; self->itemSize = itemSize; self->size = q.quot; // ensure encoding is sane for type if (UArray_isFloatType(self)) { self->encoding = CENCODING_NUMBER; } else if (self->encoding == CENCODING_ASCII) { switch(self->itemSize) { case 2: self->encoding = CENCODING_UCS2; break; case 4: self->encoding = CENCODING_UCS4; break; case 8: self->encoding = CENCODING_NUMBER; break; } } }
int UArray_bitAt_(UArray *self, size_t i) { size_t bytePos = i / 8; size_t bitPos = i - bytePos; if (bytePos >= UArray_sizeInBytes(self)) return 0; return self->data[bytePos] = (self->data[bytePos] >> bitPos) & 0x1; }
size_t UArray_bitCount(UArray *self) { const unsigned char map[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 }; size_t i, max = UArray_sizeInBytes(self); uint8_t *data = self->data; size_t total = 0; for (i = 0; i < max; i ++) { total += map[data[i]]; } return total; }
Datum Datum_FromUArray_(UArray *ba) { Datum d; d.data = (unsigned char *)UArray_bytes(ba); d.size = UArray_sizeInBytes(ba); return d; }
void UArray_bitwiseNot(UArray *self) { size_t i, max = UArray_sizeInBytes(self); uint8_t *data = self->data; for (i = 0; i < max; i ++) { data[i] = ~(data[i]); } }
IoObject *IoSeq_sizeInBytes(IoSeq *self, IoObject *locals, IoMessage *m) { /*doc Sequence sizeInBytes Returns the length in bytes of the receiver. */ return IONUMBER(UArray_sizeInBytes(DATA(self))); }
IO_METHOD(IoSeq, sizeInBytes) { /*doc Sequence sizeInBytes Returns the length in bytes of the receiver. */ return IONUMBER(UArray_sizeInBytes(DATA(self))); }
void UArray_setBit_at_(UArray *self, int aBool, size_t i) { size_t bytePos = i / 8; size_t bitPos = i - bytePos; uint8_t n = 0x1 << bitPos; uint8_t b; if (bytePos >= UArray_sizeInBytes(self)) return; b = self->data[bytePos]; b ^= n; if (aBool) b |= (0x1 << bitPos); self->data[bytePos] = b; }
IoObject *IoBlowfish_beginProcessing(IoObject *self, IoObject *locals, IoMessage *m) { /*doc Blowfish beginProcessing Sets the key from the key slot and initializes the cipher. */ UArray *key = IoObject_rawGetUArraySlot(self, locals, m, IOSYMBOL("key")); blowfish_ctx *context = &(DATA(self)->context); blowfish_init(context, (uint8_t *)UArray_bytes(key), UArray_sizeInBytes(key)); return self; }
IoObject *IoBlowfish_endProcessing(IoBlowfish *self, IoObject *locals, IoMessage *m) { /*doc Blowfish endProcessing Finish processing remaining bytes of inputBuffer. */ blowfish_ctx *context = &(DATA(self)->context); unsigned long lr[2]; IoBlowfish_process(self, locals, m); // process the full blocks first { int isEncrypting = DATA(self)->isEncrypting; UArray *input = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("inputBuffer")); UArray *output = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("outputBuffer")); IOASSERT(UArray_sizeInBytes(input) < sizeof(lr), "internal error - too many bytes left in inputBuffer"); memset(lr, 0, sizeof(lr)); memcpy(lr, (uint8_t *)UArray_bytes(input), UArray_sizeInBytes(input)); if (isEncrypting) { blowfish_encrypt(context, &lr[0], &lr[1]); } else { blowfish_decrypt(context, &lr[0], &lr[1]); } UArray_appendBytes_size_(output, (unsigned char *)&lr, sizeof(lr)); UArray_setSize_(input, 0); } return self; }
int UArray_isMultibyte(const UArray *self) { if (self->encoding == CENCODING_UTF8) { size_t i, max = UArray_sizeInBytes(self); const uint8_t *bytes = UArray_bytes(self); for (i = 0; i < max; i ++) { if (UArray_SizeOfUTF8Char(bytes + i) > 1) return 1; } //UARRAY_INTFOREACH(self, i, v, if (ismbchar((int)v)) return 1; ); } return 0; }
IoObject *IoZlibEncoder_process(IoZlibEncoder *self, IoObject *locals, IoMessage *m) { /*doc ZlibEncoder process Process the inputBuffer and appends the result to the outputBuffer. The processed inputBuffer is empties except for the spare bytes at the end which don't fit into a cipher block. */ z_stream *strm = DATA(self)->strm; UArray *input = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("inputBuffer")); UArray *output = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("outputBuffer")); uint8_t *inputBytes = (uint8_t *)UArray_bytes(input); size_t inputSize = UArray_sizeInBytes(input); if (inputSize) { int ret; size_t oldOutputSize = UArray_size(output); size_t outputRoom = (inputSize * 2); uint8_t *outputBytes; UArray_setSize_(output, oldOutputSize + outputRoom); outputBytes = (uint8_t *)UArray_bytes(output) + oldOutputSize; strm->next_in = inputBytes; strm->avail_in = inputSize; strm->next_out = outputBytes; strm->avail_out = outputRoom; ret = deflate(strm, Z_NO_FLUSH); //assert(ret != Z_STREAM_ERROR); { size_t outputSize = outputRoom - strm->avail_out; UArray_setSize_(output, oldOutputSize + outputSize); } UArray_setSize_(input, 0); } return self; }
UArray *UArray_asBits(const UArray *self) { UArray *out = UArray_new(); size_t i, max = UArray_sizeInBytes(self); uint8_t *data = self->data; for (i = 0; i < max; i ++) { uint8_t b = data[i]; int j; for (j = 0; j < 8; j ++) { int v = (b >> j) & 0x1; UArray_appendCString_(out, v ? "1" : "0"); } } return out; }
IoObject *IoLZOEncoder_process(IoLZOEncoder *self, IoObject *locals, IoMessage *m) { /*doc LZOEncoder process Process the inputBuffer and appends the result to the outputBuffer. The processed inputBuffer is emptied except for the spare bytes at the end which don't fit into a cipher block. */ lzo_align_t __LZO_MMODEL *wrkmem = DATA(self)->wrkmem; UArray *input = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("inputBuffer")); UArray *output = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("outputBuffer")); unsigned char *inputBytes = (uint8_t *)UArray_bytes(input); size_t inputSize = UArray_sizeInBytes(input); if (inputSize) { int r; size_t oldOutputSize = UArray_size(output); lzo_uint outputRoom = (inputSize + inputSize / 64 + 16 + 3); unsigned char *outputBytes; UArray_setSize_(output, oldOutputSize + outputRoom); outputBytes = (uint8_t *)UArray_bytes(output) + oldOutputSize; r = lzo1x_1_compress(inputBytes, inputSize, outputBytes, &outputRoom, wrkmem); // r = lzo1x_decompress(in, in_len, out, &out_len, wrkmem); if (r != LZO_E_OK) { IoState_error_(IOSTATE, m, "LZO compression failed: %d", r); } UArray_setSize_(output, oldOutputSize + outputRoom); UArray_setSize_(input, 0); } return self; }
IoObject *IoBlowfish_process(IoBlowfish *self, IoObject *locals, IoMessage *m) { /*doc Blowfish process Process the inputBuffer and appends the result to the outputBuffer. The processed inputBuffer is empties except for the spare bytes at the end which don't fit into a cipher block. */ blowfish_ctx *context = &(DATA(self)->context); int isEncrypting = DATA(self)->isEncrypting; UArray *input = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("inputBuffer")); UArray *output = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("outputBuffer")); const unsigned char *inputBytes = (uint8_t *)UArray_bytes(input); size_t inputSize = UArray_sizeInBytes(input); unsigned long lr[2]; size_t i, runs = inputSize / sizeof(lr); for (i = 0; i < runs; i ++) { memcpy(lr, inputBytes, sizeof(lr)); inputBytes += sizeof(lr); if (isEncrypting) { blowfish_encrypt(context, &lr[0], &lr[1]); } else { blowfish_decrypt(context, &lr[0], &lr[1]); } UArray_appendBytes_size_(output, (unsigned char *)&lr, sizeof(lr)); } UArray_removeRange(input, 0, runs * sizeof(lr)); return self; }
IoObject *IoTokyoCabinetPrefixCursor_jump(IoObject *self, IoObject *locals, IoMessage *m) { /*doc TokyoCabinetPrefixCursor jump(key) Move cursor to record before key. Returns self */ IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0); int result; UArray *p; IoSeq *prefix = IoObject_getSlot_(self, IOSYMBOL("prefix")); IOASSERT(ISSEQ(prefix), "prefix must be a sequence"); p = UArray_clone(IoSeq_rawUArray(prefix)); UArray_appendPath_(p, IoSeq_rawUArray(key)); result = tcbdbcurjump(TokyoCabinetPrefixCursor(self), (const void *)UArray_bytes(p), (int)UArray_sizeInBytes(p)); UArray_free(p); IOASSERT(TokyoCabinetPrefixCursor(self), "invalid TokyoCabinetPrefixCursor"); return IOBOOL(self, result); }
uint8_t UArray_byteAt_(UArray *self, size_t i) { if (i < UArray_sizeInBytes(self)) return self->data[i]; return 0; }
//inline size_t UArray_sizeRequiredToContain_(const UArray *self, const UArray *other) { return (UArray_sizeInBytes(other) + self->itemSize - 1) / self->itemSize; }
IoSymbol *IoState_symbolWithUArray_copy_convertToFixedWidth(IoState *self, UArray *ba, int copy) { IoSymbol *r = IoState_symbolWithCString_length_(self, (const char *)UArray_bytes(ba), UArray_sizeInBytes(ba)); if(!copy) UArray_free(ba); return r; }
size_t IoSeq_rawSizeInBytes(IoSeq *self) { return (size_t)(UArray_sizeInBytes(DATA(self)) ); }