def __getValueFromTwoRegisters(self, registers): lowWord = BitArray(uint=registers[0], length=16) highWord = BitArray(uint=registers[1], length=16) total = BitArray(lowWord) total.insert(highWord, 0) return total.int
def send(self, msg, type_=34): data = BitArray(f"int:8={type_}") data.append(protocol.encodeArray(msg)) data.insert(self._make_header(data), 0) try: self.connection.send(data.bytes) except (BrokenPipeError, OSError): self.connection.close()
def _ensure_padding(self, cipher_stream): stream = BitArray(hex=cipher_stream) stream_len = stream.len while stream_len % 8: stream.insert('0b0', 0) stream_len = stream_len + 1 return stream
def string_to_bitarray(self, _string, _maxsize=448): b = BitArray() pos = 0 if (_string): for c in _string: c_str = "{:#09b}".format(ord(c)) print("{:s}:{:s}".format(c, c_str)) b.insert(c_str, pos) pos += 7 if (len(b.bin) < _maxsize): b.insert("{:#09b}".format(TERMINATOR), pos) if (len(b.bin) > _maxsize): raise Exception("Size of bit array exceeds the maximum size allowed ({:d}).".format(_maxsize)) return b
def string_to_bitarray(self, _string, _maxsize=448): b = BitArray() pos = 0 if (_string): for c in _string: c_str = "{:#09b}".format(ord(c)) print("{:s}:{:s}".format(c, c_str)) b.insert(c_str, pos) pos += 7 if (len(b.bin) < _maxsize): b.insert("{:#09b}".format(TERMINATOR), pos) if (len(b.bin) > _maxsize): raise Exception( "Size of bit array exceeds the maximum size allowed ({:d}).". format(_maxsize)) return b
def __setSubnet(self): oldSubnet = self.__safeReadHoldingRegisters(32776, 2) firstOctet = Bits(uint=255, length=8) secondOctet = Bits(uint=255, length=8) thirdOctet = Bits(uint=255, length=8) fourthOctet = Bits(uint=0, length=8) firstWord = BitArray(secondOctet) firstWord.insert(firstOctet, 0) secondWord = BitArray(fourthOctet) secondWord.insert(thirdOctet, 0) #print(secondWord.bin) commands = [] commands.append(secondWord.uint) commands.append(firstWord.uint) self.__safeWriteRegisters(32776, commands)
def __setAddress(self): oldAddress = self.__safeReadHoldingRegisters(32774,2) firstOctet = Bits(uint=192, length=8) secondOctet = Bits(uint=168, length=8) thirdOctet = Bits(uint=0, length=8) fourthOctet = Bits(uint=12, length=8) firstWord = BitArray(secondOctet) firstWord.insert(firstOctet, 0) secondWord = BitArray(fourthOctet) secondWord.insert(thirdOctet, 0) commands = [] commands.append(secondWord.uint) commands.append(firstWord.uint) self.__safeWriteRegisters(32774, commands) newAddress = self.__safeReadHoldingRegisters(32774, 2)
def generate(self, string): bS = BitStream() mode = BitArray(bin='0010') nBits = 9 lenOfString = len(string) bLen = bin(lenOfString) bs = BitArray(bin=bLen) while bs._datastore.bitlength < 9: bs.insert('0b0', 0) bs.insert(mode, 0) stringPair = [string[i:i + 2] for i in range(0, len(string), 2)] for sp in stringPair: print(sp[0], sp[1]) # number of characters read into 9 bit stream appended to mode. Now to encode the message pass
def int_to_vlv(number: int) -> bytes: """Calculate variable-length time from integer""" assert type(number) is int, "Input should be integer" assert number <= 4294967295, "Woah! Number too huge. Should be <= 4294967295 " # inputs below 127 don't change try: if number <= 127: return number.to_bytes(1, 'big') except OverflowError: print(number) # get input into bit array number = struct.pack( '>I', number) # must do big endian as midi values are read forward bits = BitArray(number) # remove 0s from beginning while bits[0] == 0: del (bits[0]) length = len(bits) # insert 0 at the beginning of the final byte, signifying it is the final byte bits.insert(1, length - 7) # insert 1s at beginning of each byte, shifting the rest left for pos in range(length)[length - 14::-7]: bits.insert(1, pos) bits.invert(pos) # pad 0s to complete the first byte while len(bits) % 8 != 0: bits.insert(1, 0) # make first bit 1 if not already if bits[0] is not True: bits.invert(0) return bits.bytes
def testInsert(self): s = BitArray("0b00") s.insert("0xf", 1) self.assertEqual(s, "0b011110")
def testInsert(self): s = BitArray('0b00') s.insert('0xf', 1) self.assertEqual(s, '0b011110')
def pass_1_inst(self, line, line_idx): # TODO: create another class that deals with ABI definitions of xC architecture tokens = list(filter(None, re.split('\s|\t', line))) if self.__asm_debug: print('\tinst\t: {}'.format(tokens)) # skip assembler directives if tokens[0] not in self.mne_table and tokens[0] not in self.sym_table: if self.__asm_debug: print("\t// skipping assembler directive '{}'".format(tokens[0])) return 0 # tokens[0] is either instruction, label, or symbol if tokens[0] in abi.optable: # instruction _bytecode = BitArray( '{}'.format( hex(abi.optable[tokens[0]]) ) ) while len(_bytecode) < 6: _bytecode.insert('0b0',0) if tokens[0] in ['nop']: while len(_bytecode) < 64: _bytecode.insert('0b0',0) # one-arg variable jump instructions (58-bit addr) if tokens[0] in ['jmp', 'jal']: # if this is a register if tokens[1].startswith('$'): _regval = BitArray( '{}'.format( hex(abi.regtable[tokens[1]]) ) ) while len(_regval) < 6: _regval.insert('0b0',0) _bytecode.append(_regval) # else, if this is an immediate value elif re.match('^([0-9]+|0x([0-9a-f])+)$',tokens[1]): _immval = BitArray( '{}'.format( hex(int(tokens[1],0) * 16) ) ) while len(_immval) < 58: _immval.insert('0b0',0) _bytecode.append(_immval) # else, this must be a symbol else: _syment = self.sym_table[tokens[1]] # { 'name' : ['LC offset', 'type (N/O/F)', 'relative? (R/A)', 'internal? (I/E)']} _valid_imm_internal = (_syment[1] == 'O' and _syment[2] == 'A' and _syment[3] == 'I') \ or (_syment[1] == 'F' and _syment[2] == 'R' and _syment[3] == 'I') # if this is a value we can immediately substitute into the instruction if _valid_imm_internal: _subval = BitArray( '{}'.format( hex(_syment[0] * 16) ) ) while len(_subval) < 58: _subval.insert('0b0',0) _bytecode.append(_subval) elif (_syment[1] == 'O' and _syment[2] == 'R' and _syment[3] == 'I'): # this is most likely a calculatable value, let's just do it now for immediate bytecode "linking purposes" _sym_ariexp = _syment[0] for idx in range(0, len(_sym_ariexp)): if _sym_ariexp[idx] in self.sym_table: _sym_ariexp[idx] = self.sym_table[_sym_ariexp[idx]][0] elif _sym_ariexp[idx].isdigit(): _sym_ariexp[idx] = int(_sym_ariexp[idx]) _sym_endval = self.parse_ari(_sym_ariexp) _subval = BitArray( '{}'.format( hex(_sym_endval * 8) ) ) while len(_subval) < 58: _subval.insert('0b0',0) _bytecode.append(_subval) # one-arg register jump instruction elif tokens[0] == 'jr': _regval = BitArray( '{}'.format( hex(abi.regtable[tokens[1]]) ) ) while len(_regval) < 58: if len(_regval) < 6: _regval.insert('0b0',0) else: _regval.append('0b0') _bytecode.append(_regval) # two-arg non-memory instructions (50-bit immediate) elif tokens[0] in ['mov', 'add', 'sub']: _regval = None _immval = None # if first arg is a register if tokens[1].startswith('$'): _immval = BitArray( '{}'.format( hex(abi.regtable[tokens[1]]) ) ) while len(_immval) < 52: if len(_immval) < 6: _immval.insert('0b0',0) else: _immval.append('0b0') # else, if this is an immediate value elif re.match('(^[0-9]+$|^0x([0-9a-f])+$)',tokens[1]): # make sure it is in the valid range for these instructions _tok_imm = tokens[0] + 'i' _bytecode = None _bytecode = BitArray( '{}'.format( hex(abi.optable[_tok_imm]) ) ) while len(_bytecode) < 6: _bytecode.insert('0b0',0) while len(_bytecode) > 6: _bytecode = _bytecode[1:] _immval = BitArray( '{}'.format( hex(int(tokens[1])) ) ) while len(_immval) < 52: if int(tokens[1]) < 0: _immval.insert('0b1',0) else: _immval.insert('0b0',0) # else, this must be a named literal else: _tok_imm = tokens[0] + 'i' _bytecode = None _bytecode = BitArray( '{}'.format( hex(abi.optable[_tok_imm]) ) ) while len(_bytecode) < 6: _bytecode.insert('0b0',0) while len(_bytecode) > 6: _bytecode = _bytecode[1:] # symbol val processing _syment = self.sym_table[tokens[1]] # { 'name' : ['LC offset', 'type (N/O/F)', 'relative? (R/A)', 'internal? (I/E)']} _valid_imm_internal = (_syment[1] == 'O' and _syment[2] == 'A' and _syment[3] == 'I') \ or (_syment[1] == 'F' and _syment[2] == 'R' and _syment[3] == 'I') # if this is a value we can immediately substitute into the instruction if _valid_imm_internal: _immval = BitArray( '{}'.format( hex(_syment[0]) ) ) while len(_immval) < 52: _immval.insert('0b0',0) elif (_syment[1] == 'O' and _syment[2] == 'R' and _syment[3] == 'I'): # this is most likely a calculatable value, let's just do it now for immediate bytecode "linking purposes" _sym_ariexp = _syment[0] for idx in range(0, len(_sym_ariexp)): if _sym_ariexp[idx] in self.sym_table: _sym_ariexp[idx] = self.sym_table[_sym_ariexp[idx]][0] elif _sym_ariexp[idx].isdigit(): _sym_ariexp[idx] = int(_sym_ariexp[idx]) _sym_endval = self.parse_ari(_sym_ariexp) _immval = BitArray( '{}'.format( hex(_sym_endval) ) ) while len(_immval) < 52: _immval.insert('0b0',0) # second arg must be a register if tokens[2].startswith('$'): _regval = BitArray( '{}'.format( hex(abi.regtable[tokens[2]]) ) ) while len(_regval) < 6: _regval.insert('0b0',0) while len(_regval) > 6: _regval = _regval[1:] _bytecode.append(_regval) _bytecode.append(_immval) # three-arg memory instructions (46-bit addr) [format: 'LOAD reg off(mem)'] elif tokens[0] in ['load', 'stor']: _rsrcvl = BitArray( '{}'.format( hex(abi.regtable[tokens[1]]) ) ) _roffvl = None _rmemvl = None while len(_rsrcvl) < 6: _rsrcvl.insert('0b0',0) # valid offset(memptr) format if re.match('^([0-9]+|0x[0-9a-f]+|[$][0-9a-z]+)[(][$][0-9a-z]+[)]$', tokens[2]): tokspl = tokens[2].split('(') tokspl[1] = tokspl[1][:-1] # tokspl = ['offset', 'memptr'] # if offset starts with '$', is a register if tokspl[0].startswith('$'): _roffvl = BitArray( '{}'.format( hex(abi.regtable[tokspl[0]]) ) ) while len(_roffvl) < 46: if len(_roffvl) < 6: _roffvl.insert('0b0',0) else: _roffvl.append('0b0') else: _bytecode = None _iminst = tokens[0] + 'i' _bytecode = BitArray( '{}'.format( hex(abi.optable[_iminst]) ) ) while len(_bytecode) < 6: _bytecode.insert('0b0',0) while len(_bytecode) > 6: _bytecode = _bytecode[1:] _roffvl = BitArray( '{}'.format( hex(int(tokspl[0])) ) ) while len(_roffvl) < 46: if int(tokspl[0]) < 0: _roffvl.insert('0b1',0) else: _roffvl.insert('0b0',0) # then check memptr -- must be a register _rmemvl = BitArray( '{}'.format( hex(abi.regtable[tokspl[1]]) ) ) while len(_rmemvl) < 6: _rmemvl.insert('0b0',0) _bytecode.append(_rsrcvl) _bytecode.append(_rmemvl) _bytecode.append(_roffvl) # three-arg conditional jump instructions (46-bit addr) elif tokens[0] in ['beq', 'bne', 'blt', 'bgt']: _rsrcvl = BitArray( '{}'.format( hex(abi.regtable[tokens[1]]) ) ) while len(_rsrcvl) < 6: _rsrcvl.insert('0b0',0) while len(_rsrcvl) > 6: _rsrcvl = _rsrcvl[1:] _rcmpvl = BitArray( '{}'.format( hex(abi.regtable[tokens[2]]) ) ) while len(_rcmpvl) < 6: _rcmpvl.insert('0b0',0) while len(_rcmpvl) > 6: _rcmpvl = _rcmpvl[1:] _bytecode.append(_rsrcvl) _bytecode.append(_rcmpvl) # symbol val processing _syment = self.sym_table[tokens[3]] # { 'name' : ['LC offset', 'type (N/O/F)', 'relative? (R/A)', 'internal? (I/E)']} _valid_imm_internal = (_syment[1] == 'O' and _syment[2] == 'A' and _syment[3] == 'I') \ or (_syment[1] == 'F' and _syment[2] == 'R' and _syment[3] == 'I') # if this is a value we can immediately substitute into the instruction if _valid_imm_internal: _subval = BitArray( '{}'.format( hex(_syment[0] * 16) ) ) while len(_subval) < 46: _subval.insert('0b0',0) _bytecode.append(_subval) elif (_syment[1] == 'O' and _syment[2] == 'R' and _syment[3] == 'I'): # this is most likely a calculatable value, let's just do it now for immediate bytecode "linking purposes" _sym_ariexp = _syment[0] for idx in range(0, len(_sym_ariexp)): if _sym_ariexp[idx] in self.sym_table: _sym_ariexp[idx] = self.sym_table[_sym_ariexp[idx]][0] elif _sym_ariexp[idx].isdigit(): _sym_ariexp[idx] = int(_sym_ariexp[idx]) _sym_endval = self.parse_ari(_sym_ariexp) _subval = BitArray( '{}'.format( hex(_sym_endval * 16) ) ) while len(_subval) < 46: _subval.insert('0b0',0) _bytecode.append(_subval) if self.__asm_debug: print( ">>\tbytecode: {} | len: {}".format(_bytecode.bin, len(_bytecode)) ) self.obj_raw.append(_bytecode) else: # label or symbol, reference symtable if self.__asm_debug: print("\tsymbol: address {}".format(self.sym_table[tokens[0]])) return 0
def testInsertParameters(self): s = BitArray('0b111') with self.assertRaises(TypeError): s.insert('0x4')
def testInsert(self): a = BitArray('0x0123456') a.insert('0xf', 4) self.assertEqual(a, '0x012345f6')