Beispiel #1
0
def bin(v):
	"""
	Similar to __builtin__.bin but works on ndarrays.
	
	Useful in queries for converting flags to bit strings.

	FIXME: The current implementation is painfully slow.
	"""
	import __builtin__
	if not isinstance(v, np.ndarray):
		return __builtin__.bin(v)

	# Must be some kind of integer
	assert v.dtype.kind in ['i', 'u']

	# Create compatible string array
	l = v.dtype.itemsize*8
	ss = np.empty(v.shape, dtype=('a', v.dtype.itemsize*9))
	s = ss.reshape(-1)
	for i, n in enumerate(v.flat):
		c = __builtin__.bin(n)[2:]
		c = '0'*(l-len(c)) + c
		ll = [ c[k:k+8] for k in xrange(0, l, 8) ]
		s[i] = ','.join(ll)
	return ss
Beispiel #2
0
def bin(v):
    """
	Similar to __builtin__.bin but works on ndarrays.
	
	Useful in queries for converting flags to bit strings.

	FIXME: The current implementation is painfully slow.
	"""
    import __builtin__
    if not isinstance(v, np.ndarray):
        return __builtin__.bin(v)

    # Must be some kind of integer
    assert v.dtype.kind in ['i', 'u']

    # Create compatible string array
    l = v.dtype.itemsize * 8
    ss = np.empty(v.shape, dtype=('a', v.dtype.itemsize * 9))
    s = ss.reshape(-1)
    for i, n in enumerate(v.flat):
        c = __builtin__.bin(n)[2:]
        c = '0' * (l - len(c)) + c
        ll = [c[k:k + 8] for k in xrange(0, l, 8)]
        s[i] = ','.join(ll)
    return ss
Beispiel #3
0
    def bin(n):
        """Return the equivalent to Python 2.6's bin function.

        Examples
        ========

        >>> from sympy.core.compatibility import bin
        >>> bin(-123)
        '-0b1111011'
        >>> bin(0) # this is the only time a 0 will be to the right of 'b'
        '0b0'

        See Also
        ========
        sympy.physics.quantum.shor.arr

        Modified from http://code.activestate.com/recipes/576847/
        """
        # =========================================================
        # create hex of int, remove '0x'. now for each hex char,
        # look up binary string, append in list and join at the end.
        # =========================================================
        if n < 0:
            return '-%s' % bin(-n)
        return '0b%s' % (''.join(
            [_hexDict[hstr]
             for hstr in hex(n)[2:].lower()]).lstrip('0') or '0')
Beispiel #4
0
    def bin(n):
        """Return the equivalent to Python 2.6's bin function.

        Examples
        ========

        >>> from sympy.core.compatibility import bin
        >>> bin(-123)
        '-0b1111011'
        >>> bin(0) # this is the only time a 0 will be to the right of 'b'
        '0b0'

        See Also
        ========
        sympy.physics.quantum.shor.arr

        Modified from http://code.activestate.com/recipes/576847/
        """
        # =========================================================
        # create hex of int, remove '0x'. now for each hex char,
        # look up binary string, append in list and join at the end.
        # =========================================================
        if n < 0:
            return '-%s' % bin(-n)
        return '0b%s' % (''.join([_hexDict[hstr] for hstr in hex(n)[2:].lower()
                                  ]).lstrip('0') or '0')
Beispiel #5
0
def bin(obj):
    if isinstance(obj, Element):
        return obj.bin()
    elif hasattr(obj, '__bin__') and callable(obj.__bin__):
        return obj.__bin__()
    else:
        # will certainly raise
        return builtins.bin(obj)
Beispiel #6
0
    def bin(x):
        """
        bin(number) -> string

        Stringifies an int or long in base 2.
        """
        if x < 0: return '-' + bin(-x)
        out = []
        if x == 0: out.append('0')
        while x > 0:
            out.append('01'[x & 1])
            x >>= 1
            pass
        return '0b' + ''.join(reversed(out))
Beispiel #7
0
    def bin(x):
        """
        bin(number) -> string

        Stringifies an int or long in base 2.
        """
        if x < 0: return '-' + bin(-x)
        out = []
        if x == 0: out.append('0')
        while x > 0:
            out.append('01'[x & 1])
            x >>= 1
            pass
        return '0b' + ''.join(reversed(out))
Beispiel #8
0
    def bin(x):
        """
        bin(number) -> string

        Stringifies an int or long in base 2.
        """
        if x < 0:
            return "-" + bin(-x)
        out = []
        if x == 0:
            out.append("0")
        while x > 0:
            out.append("01"[x & 1])
            x >>= 1
            pass
        return "0b" + "".join(reversed(out))
Beispiel #9
0
def bin():
    """Return UUID as binary"""
    return __builtin__.bin(int())[2:]
def main():
    # open an output file
    input_path = sys.argv[FILE_POS]
    if isdir(input_path):
        input_list = [ input_path + "/" +f for f in listdir(input_path) 
            if (isfile(join(input_path, f))) and (f.endswith(".asm")) ]
    else:
        input_list = [input_path]
    
    for input_file in input_list:
        index = input_file.index(".")
        output_file = open(input_file[:index] + ".hack", "w")
        # parse a new line
        code = Code()
        symbol_table = SymbolTable()
        counter_address = FIRST_ADDRESS_RAM
        counter_rom = FIRST_ADDRESS_ROM

        # first pass
        parser_first_pass = Parser(input_file)
        while parser_first_pass.has_more_commands():
            command = parser_first_pass.advance()
            parse_type = parser_first_pass.command_type()
            if parse_type == L_COMMAND:
                if not symbol_table.contains(command[1:-1]):
                    symbol_table.add_entry(command[1:-1], counter_rom)
            else:
               counter_rom+=1

        # second pass
        parser_second_pass = Parser(input_file)
        while parser_second_pass.has_more_commands():
            command = parser_second_pass.advance()
            line_to_hack = ""
            parse_type = parser_second_pass.command_type()

            # translate the line to an A Command
            if parse_type == A_COMMAND:
                if command[1:].isdigit():
                    address = command[1:]
                else:
                    if symbol_table.contains(command[1:]):
                        address = symbol_table.get_address(command[1:])
                    else:
                        symbol_table.add_entry(command[1:], counter_address)
                        address = counter_address
                        
                        counter_address += 1
                binary_repr = str(bin(int(address))[2:].zfill(15))
                line_to_hack = A_PREFIX + binary_repr

            # translate the line to a C Command
            if parse_type == C_COMMAND:
                # C command comp
                comp_type = parser_second_pass.comp()
                code_comp = code.comp(comp_type)
                # C command dest
                dest_type = parser_second_pass.dest()
                code_dest = code.dest(dest_type)
                # C command jump
                jump_type = parser_second_pass.jump()
                code_jump = code.jump(jump_type)
                if ("<" in comp_type) or (">" in comp_type):
                    line_to_hack = C_PREFIX_SPE + code_comp + code_dest + code_jump
                else:
                    line_to_hack = C_PREFIX_REG + code_comp + code_dest + code_jump
                
            if parse_type == L_COMMAND:
                continue

            # write the line to the output file
            output_file.write(line_to_hack + "\n")


        output_file.close()
Beispiel #11
0
	def subWorkerThread(self, bytechar):
		self.cmdDecodeArray.append(bytechar)
		self.cmdDecodeString = ''.join(str(x) for x in self.cmdDecodeArray)
		self.cmdDecodeArray = []
		self.cmdDecodeArray.append(self.cmdDecodeString)
		#print self.cmdDecodeString

		cookee_cmd = varlisting.COOKEE

		offset_cookee = self.cmdDecodeString.find(cookee_cmd)
		offset_beacon1 = self.cmdDecodeString.find('aa55')
		offset_beacon2 = self.cmdDecodeString.find('bb66')

		#if offset_cookee != -1:
		#	self.ackString = self.cmdDecodeString[offset_cookee + 10:]
		#	#print self.ackString
		#	if len(self.ackString) == 14:
		#		if fnmatch.fnmatch(self.ackString, 'aaaa??????aaaa'):
		#			self.ackPkt = self.ackString
		#			print self.ackPkt
		#			print 'ACK Pkt Received'
		#			self.cmdDecodeArray = []
		#			self.cmdDecodeString = ''
		#			return
		#		else:
		#			print 'Error Occurred'
		#			self.cmdDecodeArray = []
		#			self.cmdDecodeString = ''
		#			return
		#	if len(self.ackString) == 12:
		#		if fnmatch.fnmatch(self.ackString, 'bbbb????bbbb'):
		#			self.ackPkt = self.ackString
		#			print self.ackPkt
		#			print 'ACK Pkt Received'
		#			self.cmdDecodeArray = []
		#			self.cmdDecodeString = ''
		#			return
		#		else:
		#			print 'Error Occurred'
		#			self.cmdDecodeArray = []
		#			self.cmdDecodeString = ''
		#			return
		###
		### Check for incoming bytes with 'aa55' value
		###
		if offset_beacon1 != -1:
			self.statdlString = self.cmdDecodeString[offset_beacon1:]
			if len(self.statdlString) == 216:
				tempMarks = ['?' for i in xrange(208)]
				tempMarks = ''.join(str(x) for x in tempMarks)
				if fnmatch.fnmatch(self.statdlString, 'aa55' + '%s' %tempMarks + 'aa55'):
					self.pkt1 = self.statdlString
					pktfrmtd = " ".join(self.pkt1[i:i+2] for i in range(0, len(self.pkt1), 2))

					pktNumDec =  int(self.pkt1[4:8], 16)
					timeStamp = self.pkt1[8:16]
					timeStampDec = '%i' %int(timeStamp, 16)
					formattedTime = strftime("%Y-%m-%d %H:%M:%S", localtime(int(timeStampDec)))

					# Used to convert little endian hex to integers
					#print struct.unpack("<h", "\xee\xee")[0]
					#str = "\\xee\\xee"
					#print struct.unpack("<h", str)[0]
					#flip bytes, little endian to big endian
					#data[::-1]

					EPS_DATA = self.pkt1[20:152]
					EPS_DATA = " ".join(EPS_DATA[i:i+2] for i in range(0, len(EPS_DATA), 2))
					RADIO_DATA = self.pkt1[156:192]
					RADIO_DATAARRAY = [RADIO_DATA[0:4], RADIO_DATA[4:8], RADIO_DATA[8:16], RADIO_DATA[16:20], RADIO_DATA[20:28], RADIO_DATA[28:36]]
					RADIO_DATAARRAY[0] = " ".join(RADIO_DATAARRAY[0][i:i+2] for i in range(0, len(RADIO_DATAARRAY[0]), 2))
					RADIO_DATAARRAY[0] = RADIO_DATAARRAY[0].split(' ')
					RADIO_DATAARRAY[0] = RADIO_DATAARRAY[0][::-1]
					RADIO_DATAARRAY[0] = "".join(RADIO_DATAARRAY[0])
					RADIO_DATAARRAY[0] = int(RADIO_DATAARRAY[0], 16)
					RADIO_DATAARRAY[1] = " ".join(RADIO_DATAARRAY[1][i:i+2] for i in range(0, len(RADIO_DATAARRAY[1]), 2))
					RADIO_DATAARRAY[1] = RADIO_DATAARRAY[1].split(' ')
					RADIO_DATAARRAY[1] = RADIO_DATAARRAY[1][::-1]
					RADIO_DATAARRAY[1] = "".join(RADIO_DATAARRAY[1])
					RADIO_DATAARRAY[1] = int(RADIO_DATAARRAY[1], 16)
					RADIO_DATAARRAY[2] = " ".join(RADIO_DATAARRAY[2][i:i+2] for i in range(0, len(RADIO_DATAARRAY[2]), 2))
					RADIO_DATAARRAY[2] = RADIO_DATAARRAY[2].split(' ')
					RADIO_DATAARRAY[2] = RADIO_DATAARRAY[2][::-1]
					RADIO_DATAARRAY[2] = "".join(RADIO_DATAARRAY[2])
					RADIO_DATAARRAY[2] = int(RADIO_DATAARRAY[2], 16)
					RADIO_DATAARRAY[3] = " ".join(RADIO_DATAARRAY[3][i:i+2] for i in range(0, len(RADIO_DATAARRAY[3]), 2))
					RADIO_DATAARRAY[3] = RADIO_DATAARRAY[3].split(' ')
					RADIO_DATAARRAY[3] = RADIO_DATAARRAY[3][::-1]
					RADIO_DATAARRAY[3] = "".join(RADIO_DATAARRAY[3])
					RADIO_DATAARRAY[3] = int(RADIO_DATAARRAY[3], 16)
					RADIO_DATAARRAY[4] = " ".join(RADIO_DATAARRAY[4][i:i+2] for i in range(0, len(RADIO_DATAARRAY[4]), 2))
					RADIO_DATAARRAY[4] = RADIO_DATAARRAY[4].split(' ')
					RADIO_DATAARRAY[4] = RADIO_DATAARRAY[4][::-1]
					RADIO_DATAARRAY[4] = "".join(RADIO_DATAARRAY[4])
					RADIO_DATAARRAY[4] = int(RADIO_DATAARRAY[4], 16)
					RADIO_DATAARRAY[5] = " ".join(RADIO_DATAARRAY[5][i:i+2] for i in range(0, len(RADIO_DATAARRAY[5]), 2))
					RADIO_DATAARRAY[5] = RADIO_DATAARRAY[5].split(' ')
					RADIO_DATAARRAY[5] = RADIO_DATAARRAY[5][::-1]
					RADIO_DATAARRAY[5] = "".join(RADIO_DATAARRAY[5])
					RADIO_DATAARRAY[5] = int(RADIO_DATAARRAY[5], 16)
					#print RADIO_DATAARRAY
					RADIO_DATA = " ".join(RADIO_DATA[i:i+2] for i in range(0, len(RADIO_DATA), 2))
					ANTS_DATA = self.pkt1[196:212]
					ANTS_DATAARRAY = [ANTS_DATA[0:4], ANTS_DATA[4:8], ANTS_DATA[8:12], ANTS_DATA[12:16]]
					ANTS_DATAARRAY[0] = " ".join(ANTS_DATAARRAY[0][i:i+2] for i in range(0, len(ANTS_DATAARRAY[0]), 2))
					ANTS_DATAARRAY[0] = ANTS_DATAARRAY[0].split(' ')
					ANTS_DATAARRAY[0] = ANTS_DATAARRAY[0][::-1]
					ANTS_DATAARRAY[0] = "".join(ANTS_DATAARRAY[0])
					ANTS_DATAARRAY[1] = " ".join(ANTS_DATAARRAY[1][i:i+2] for i in range(0, len(ANTS_DATAARRAY[1]), 2))
					ANTS_DATAARRAY[1] = ANTS_DATAARRAY[1].split(' ')
					ANTS_DATAARRAY[1] = ANTS_DATAARRAY[1][::-1]
					ANTS_DATAARRAY[1] = "".join(ANTS_DATAARRAY[1])
					#ANTS_DATAARRAY[2] = " ".join(ANTS_DATAARRAY[2][i:i+2] for i in range(0, len(ANTS_DATAARRAY[2]), 2))
					#ANTS_DATAARRAY[2] = ANTS_DATAARRAY[2].split(' ')
					#ANTS_DATAARRAY[2] = ANTS_DATAARRAY[2][::-1]
					#ANTS_DATAARRAY[2] = "".join(ANTS_DATAARRAY[2])
					ANTS_DATAARRAY[2] = __builtin__.bin(int(ANTS_DATAARRAY[2], 16))[2:].zfill(len(ANTS_DATAARRAY[2])*4)
					#ANTS_DATAARRAY[3] = " ".join(ANTS_DATAARRAY[3][i:i+2] for i in range(0, len(ANTS_DATAARRAY[3]), 2))
					#ANTS_DATAARRAY[3] = ANTS_DATAARRAY[3].split(' ')
					#ANTS_DATAARRAY[3] = ANTS_DATAARRAY[3][::-1]
					#ANTS_DATAARRAY[3] = "".join(ANTS_DATAARRAY[3])
					ANTS_DATAARRAY[3] = __builtin__.bin(int(ANTS_DATAARRAY[3], 16))[2:].zfill(len(ANTS_DATAARRAY[3])*4)
					#print ANTS_DATAARRAY
					ANTS_DATA = " ".join(ANTS_DATA[i:i+2] for i in range(0, len(ANTS_DATA), 2))

					self.tlmSeparated = self.tlmDecode(self.pkt1)
					self.emit(SIGNAL('latestPkt(PyQt_PyObject)'), [pktNumDec, timeStampDec, self.tlmSeparated, RADIO_DATAARRAY, ANTS_DATAARRAY])
					self.emit(SIGNAL('latestPktLog(PyQt_PyObject)'), [0, pktfrmtd, pktNumDec, timeStampDec, self.tlmSeparated, EPS_DATA, RADIO_DATA, ANTS_DATA])
					self.emit(SIGNAL('latestPktUpdate(PyQt_PyObject)'), [0, pktfrmtd, pktNumDec, timeStampDec, self.tlmSeparated, EPS_DATA, RADIO_DATA, ANTS_DATA])

					self.cmdDecodeArray = []
					self.cmdDecodeString = ''

		###
		### Check for incoming bytes with 'bb66' value
		###
		if offset_beacon2 != -1:
			self.statdlString = self.cmdDecodeString[offset_beacon2:]
			#print self.statdlString
			if len(self.statdlString) == 80:
				tempMarks = ['?' for i in xrange(72)]
				tempMarks = ''.join(str(x) for x in tempMarks)
				if fnmatch.fnmatch(self.statdlString, 'bb66' + '%s' %tempMarks + 'bb66'):
					self.pkt2 = self.statdlString
					pktfrmtd = " ".join(self.pkt2[i:i+2] for i in range(0, len(self.pkt2), 2))

					pktNumDec =  int(self.pkt2[4:8], 16)
					timeStamp = self.pkt2[8:16]
					timeStampDec = '%i' %int(timeStamp, 16)
					formattedTime = strftime("%Y-%m-%d %H:%M:%S", localtime(int(timeStampDec)))

					DAVE_DATA = self.pkt2[20:24]
					DAVE_DATA = " ".join(DAVE_DATA[i:i+2] for i in range(0, len(DAVE_DATA), 2))
					UTEP_DATA = self.pkt2[28:76]
					UTEP_DATA = " ".join(UTEP_DATA[i:i+2] for i in range(0, len(UTEP_DATA), 2))

					self.tlmSeparated = ''
					#self.emit(SIGNAL('latestPkt(PyQt_PyObject)'), [pktNumDec, timeStampDec, formattedTime, self.tlmSeparated])
					self.emit(SIGNAL('latestPktLog(PyQt_PyObject)'), [1, pktfrmtd, pktNumDec, timeStampDec, self.tlmSeparated, DAVE_DATA, UTEP_DATA])
					self.emit(SIGNAL('latestPktUpdate(PyQt_PyObject)'), [1, pktfrmtd, pktNumDec, timeStampDec, self.tlmSeparated, DAVE_DATA, UTEP_DATA])

					self.cmdDecodeArray = []
					self.cmdDecodeString = ''