DisasmViewMode.py

from ViewMode import *
from cemu import *
import TextSelection

from PyQt5 import QtGui, QtCore, QtWidgets
from time import time 
import sys
import threading
import re
import binascii

import capstone
import capstone.x86

import ply.lex as lex


MNEMONIC_COLUMN = 30
MNEMONIC_WIDTH = 15


Disasm_x86_16bit = (capstone.CS_ARCH_X86, capstone.CS_MODE_16)
Disasm_x86_32bit = (capstone.CS_ARCH_X86, capstone.CS_MODE_32)
Disasm_x86_64bit = (capstone.CS_ARCH_X86, capstone.CS_MODE_64)

#Disasm_ARM = (capstone.CS_ARCH_ARM, capstone.CS_MODE_ARM)
Disasm_ARM = (capstone.CS_ARCH_ARM, capstone.CS_MODE_THUMB)

Disasm_ARM_Thumb = (capstone.CS_ARCH_ARM, capstone.CS_MODE_THUMB)
Disasm_ARM64 = (capstone.CS_ARCH_ARM64, capstone.CS_MODE_ARM)

class ASMLexer(object):
    def __init__(self):
        pass

    def set(self, name, value):
        setattr(self, name, value)

    # Build the lexer
    def build(self,**kwargs):
        self._lexer = lex.lex(module=self, **kwargs)

    def lexer(self):
        return self._lexer


class ARM_Lexer(ASMLexer):
    def __init__(self):

        self._loaded = True

        my_t_REGISTER = r'[pcdr][0-9][1-9]*|sb|sl|fp|ip|sp|lr|pc!?|lsr|lsl|asr|apsr_nzcv'
        my_t_NUMBER = r'\#?-?(0x)?[0-9a-f]+|[0-9]+'
        my_t_PTR = r'qword|dword|word|byte|ptr|xmmword|ror'
        my_t_ignore = r' [],+:*{}^!-'

        self.set('t_REGISTER', my_t_REGISTER)
        self.set('t_NUMBER', my_t_NUMBER)
        self.set('t_PTR', my_t_PTR)
        self.set('t_ignore', my_t_ignore)
        self.set('t_error', self.my_t_error)

    tokens = ('REGISTER', 'NUMBER', 'PTR')

    def my_t_error(self, t):
        t.type = t.value[0]
        t.value = t.value[0]
        t.lexer.skip(1)
        #print t.value
        #print 'LEXER ERROR'
        return t


class ARM64_Lexer(ASMLexer):
    def __init__(self):
        self._loaded = True

        my_t_REGISTER = r'[pcdr][0-9][1-9]+|sb|sl|fp|ip|sp|lr|pc!?|lsr|lsl|asr|wzr|xzr|[xw][0-9]+|v[0-9]+(\.16b)?'
        my_t_NUMBER = r'\#-?0x[0-9a-f]+|[0-9]+|\#[0-9]+'
        my_t_PTR = r'qword|dword|word|byte|ptr|xmmword'
        my_t_ignore = r' [],+:*{}^'

        self.set('t_REGISTER', my_t_REGISTER)
        self.set('t_NUMBER', my_t_NUMBER)
        self.set('t_PTR', my_t_PTR)
        self.set('t_ignore', my_t_ignore)
        self.set('t_error', self.my_t_error)

    tokens = ('REGISTER', 'NUMBER', 'PTR')

    def my_t_error(self, t):
        t.type = t.value[0]
        t.value = t.value[0]
        t.lexer.skip(1)
        return t


class X86_Lexer(ASMLexer):
    def __init__(self):

        self._loaded = True
        my_t_REGISTER = r'e?r?[abcde]x|ebp|bp|esp|rip|rbp|rsp|r[1-9][0-9]*d?b?w?|si|di|rsi|rdi|edi|esi?|gs|fs|ss|cs|ds|xmm[0-9]|[abcd][lh]|cr[0-9]|ymm[0-9]|dr[0-7]|fp[0-7]|mm[0-7]|dil|st'
        my_t_NUMBER = r'0x[0-9a-f]+|[0-9]+'
        my_t_PTR = r'qword|dword|word|byte|ptr|xmmword'
        my_t_ignore = r' []-,+:*()'

        self.set('t_REGISTER', my_t_REGISTER)
        self.set('t_NUMBER', my_t_NUMBER)
        self.set('t_PTR', my_t_PTR)
        self.set('t_ignore', my_t_ignore)
        self.set('t_error', self.my_t_error)

        
    tokens = ('REGISTER', 'NUMBER', 'PTR')
    

    def my_t_error(self, t):
        t.type = t.value[0]
        t.value = t.value[0]
        t.lexer.skip(1)
        return t


class ASMLine(object):
    def __init__(self, d, plugin, lexer):
        self._hexstr = self.hexlify(d.bytes)
        self._instruction = d.op_str
        self._operands = d.op_str
        self._size = d.size
        self._addr = d.address
        self._mnemonic = d.mnemonic
        self._computed = False
        self.Lexer = lexer

        self._d = d
        self._asm = d

        self._symbol = None
        self._refString = None
        self._indexTable = []
        self._loaded = False

        self._plugin = plugin


    def iterTokens(self):
        self.full_load()
        return self.lexer

    def full_load(self):
        if self._loaded:
            return

        self._lexer = self.Lexer
        self._lexer.input(self._asm.op_str)

        self.lexer = list(self._lexer)


        # compute index table

        # add hex bytes as tokens
        H = self.hex.split(b' ')
        for i, h in enumerate(H):
            self._indexTable += [(i*3, len(h), h)]

        # add mnemonic as token
        self._indexTable += [(MNEMONIC_COLUMN, len(self.mnemonic), self.mnemonic)]

        # add symbol as token
        if self.symbol:
            t = (MNEMONIC_COLUMN + MNEMONIC_WIDTH + 1, len(self.symbol), self.symbol)
            self._indexTable += [t]
        else:
            for tok in self.lexer:
                t = (tok.lexpos + MNEMONIC_COLUMN + MNEMONIC_WIDTH, len(tok.value), tok.value)
                self._indexTable += [t]

        self._loaded = True

    @property
    def referencedString(self):
        raise "not implemented"

    @property
    def symbol(self):
        raise "not implemented"
    
    @property
    def indexTable(self):
        return self._indexTable
    
    def tokens(self):
        return self._indexTable

    def getSelectedToken(self, cx):
        for i, t in enumerate(self.indexTable):
            idx, length, value = t
            if cx == idx:
                return t

        return self.indexTable[0]

    def getSelectionWidth(self, cx):
        self.full_load()
        for i, t in enumerate(self.indexTable):
            idx, length, value = t
            if cx == idx:
                return length

        return 0

    def getEndCursor(self):
        self.full_load()
        idx, length, value = self.indexTable[-1]
        return idx

    def getNearestCursor(self, cx):
        if cx > self.getEndCursor():
            return self.getEndCursor()

        i = len(self.indexTable) - 1
        while i > 0:
            idx, length, value = self.indexTable[i]
            if cx >= idx:
                return idx
            i -= 1

        return 0

    def getNextCursor(self, cx, direction=''):
        for i, t in enumerate(self.indexTable):
            idx, length, value = t
            if cx == idx:
                break

        if direction == Directions.Right:
            if i < len(self.indexTable) - 1:
                idx, length, value = self.indexTable[i + 1]
            else:
                return 0, 1

        if direction == Directions.Left:
            if i > 0:
                idx, length, value = self.indexTable[i - 1]
            else:
                return 0, -1

        return idx, 0


    def ingroup(self, group):
        if len(self._d.groups) > 0:
            for g in self._d.groups:
                for x in group:
                    if x == g:
                        return True

        return False


    def hexlify(self, sb):
        hexstr = binascii.hexlify(sb)
        hexstr = b' '.join([hexstr[i:i+2] for i in range(0, len(hexstr), 2)])
        return hexstr

    @property
    def size(self):
        return self._size

    @property
    def offset(self):
        return self._addr

    @property
    def hex(self):
        return self._hexstr    

    @property
    def mnemonic(self):
        return self._mnemonic#.upper()

    @property
    def operands(self):
        return self._operands
    
    @property
    def obj(self):
        return self._d

    def isBranch(self):
        raise "not implemented"

    def branchAddress(self):
        raise "not implemented"

# represents x86 asm line
class ASMx86Line(ASMLine):
    def __init__(self, d, plugin, lexer):
        super(ASMx86Line, self).__init__(d, plugin, lexer)

    @property
    def referencedString(self):

        # get referenced string
        if self._refString != None:
            return self._refString

        asm = self._asm

        self._refString = ''

        # PUSH <imm>
        if asm.id == capstone.x86.X86_INS_PUSH:
            if len(asm.operands) == 1:
                o = asm.operands[0]

                if o.type == capstone.x86.X86_OP_IMM:
                    value = o.imm
                    self._refString = self._plugin.stringFromVA(value)

        # [RIP + <imm>]
        if len(asm.operands) > 1:
            o = asm.operands[1]

            if o.type == capstone.x86.X86_OP_MEM:
                if o.mem.base == capstone.x86.X86_REG_RIP:
                    x =  asm.address + asm.size + o.mem.disp
                    self._refString = self._plugin.stringFromVA(x)

        return self._refString

    @property
    def symbol(self):
            
        # get symbol from plugin (for API calls for eg.)
        if self._symbol != None:
            return self._symbol

        # get symbol
        if self.ingroup([capstone.x86.X86_GRP_CALL]):
            value = None
            asm = self._asm

            for o in asm.operands:
                if o.type == capstone.x86.X86_OP_IMM:
                    value = o.imm

                if o.type == capstone.x86.X86_OP_MEM:
                    # todo: should we consider other reg relative ??
                    if o.mem.base == capstone.x86.X86_REG_RIP:
                        value = o.mem.disp + asm.size + asm.address

                    # mainly 32bit
                    if o.mem.base == capstone.x86.X86_REG_INVALID:
                        value = o.mem.disp

            if value:
                sym = self._plugin.disasmSymbol(value)

                if sym:
                    self._symbol = sym

        return self._symbol

    def isBranch(self):
        return self.ingroup([capstone.x86.X86_GRP_JUMP, capstone.x86.X86_GRP_CALL])

    def branchAddress(self):
        if not self.isBranch():
            return None

        asm = self.obj
        if len(asm.operands) == 1:
            o = asm.operands[0]

            if o.type == capstone.x86.X86_OP_MEM:
                x = asm.address + asm.size + o.mem.disp
                return x

            if o.type == capstone.x86.X86_OP_IMM:
                x = o.imm
                return x


class DisasmViewMode(ViewMode):
    def __init__(self, width, height, data, cursor, widget=None, plugin=None):
        super(DisasmViewMode, self).__init__()

        self.plugin = plugin

        self.dataModel = data
        self.addHandler(self.dataModel)


        self.width = width
        self.height = height

        self.cursor = cursor
        self.widget = widget

        self.refresh = True

        self.selector = TextSelection.DefaultSelection(self)

        # background brush
        self.backgroundBrush = QtGui.QBrush(QtGui.QColor(0, 0, 128))

        # text font
        self.font = QtGui.QFont('Terminus', 11, QtGui.QFont.Light)

        # font metrics. assume font is monospaced
        self.font.setKerning(False)
        self.font.setFixedPitch(True)
        fm = QtGui.QFontMetrics(self.font)
        self._fontWidth  = fm.width('a')
        self._fontHeight = fm.height()

        self.textPen = QtGui.QPen(QtGui.QColor(192, 192, 192), 0, QtCore.Qt.SolidLine)
        self.resize(width, height)

        self.Paints = {}

        self.Ops = []
        self.newPix = None

        self.FlowHistory = []
        self.OPCODES = []

        self.selector = TextSelection.DisasmSelection(self)

        self.init_disassembler_engine()

    def init_disassembler_engine(self):
        # init state for disasambler
        # set capstone, lexer, asmline

        arch, mode = self.plugin.hintDisasm()

        self.disasm_engine = capstone.Cs(arch, mode)
        self.disasm_engine.detail = True

        if arch == capstone.CS_ARCH_X86:
            Lexer = X86_Lexer()

        if arch == capstone.CS_ARCH_ARM and mode in [capstone.CS_MODE_ARM, capstone.CS_MODE_THUMB]:
            Lexer = ARM_Lexer()

        if arch == capstone.CS_ARCH_ARM64:
            Lexer = ARM64_Lexer()

        # todo: ASM_ARM_Line?
        self.ASMLine = ASMx86Line
        Lexer.build()
        self.lexer = Lexer.lexer()

    @property
    def fontWidth(self):
        return self._fontWidth

    @property
    def fontHeight(self):
        return self._fontHeight

    def setTransformationEngine(self, engine):
        self.transformationEngine = engine

    def resize(self, width, height):
        self.width = width - width%self.fontWidth
        self.height = height - height%self.fontHeight
        self.computeTextArea()
        self.qpix = self._getNewPixmap(self.width, self.height + self.SPACER)
        self.refresh = True

    def computeTextArea(self):
        self.COLUMNS = self.width//self.fontWidth
        self.ROWS    = self.height//self.fontHeight
        self.notify(self.ROWS, self.COLUMNS)

    def getPixmap(self):
        for t in self.Ops:
            if len(t) == 1:
                t[0]()

            else:
                t[0](*t[1:])

        self.Ops = []
        
        if not self.newPix:
            self.draw()

        return self.newPix


    def getPageOffset(self):
        return self.dataModel.getOffset()

    def getGeometry(self):
        return self.COLUMNS, self.ROWS

    def getDataModel(self):
        return self.dataModel

    def startSelection(self):
        self.selector.startSelection()

    def stopSelection(self):
        self.selector.stopSelection()

    def getCursorOffsetInPage(self):
        x, y = self.cursor.getPosition()

        preY = sum([asm.size for asm in self.OPCODES[:y]])

        if len(self.OPCODES) - 1 < y:
            return 0

        asm = self.OPCODES[y]

        if x < len(asm.hex):
            postY = x//3
        else:
            postY = asm.size

        return preY + postY

    def getCursorAbsolutePosition(self):
        offset = self.getCursorOffsetInPage()
        return self.dataModel.getOffset() + offset

    def drawCursor(self, qp):
        cursorX, cursorY = self.cursor.getPosition()

        asm = self.OPCODES[cursorY]

        xstart = cursorX
        width = asm.getSelectionWidth(xstart)

        qp.setBrush(QtGui.QColor(255, 255, 0))

        qp.setOpacity(0.5)
        qp.drawRect(xstart*self.fontWidth, cursorY*self.fontHeight + 1, width*self.fontWidth, self.fontHeight + 1)
        qp.setOpacity(1)



    def drawSelected(self, qp):
        qp.setFont(self.font)

        cursorX, cursorY = self.cursor.getPosition()

        if len(self.OPCODES) - 1 < cursorY:
            return

        asm = self.OPCODES[cursorY]
        cx, width, text = asm.getSelectedToken(cursorX)

        cemu = ConsoleEmulator(qp, self.ROWS, self.COLUMNS)

        for i, asm in enumerate(self.OPCODES):
            for idx, length, value in asm.tokens():
                # skip current cursor position
                if cursorY == i and cursorX == idx:
                    continue

                # check every line, if match, select it
                if value == text:
                    qp.setOpacity(0.4)
                    brush=QtGui.QBrush(QtGui.QColor(0, 255, 0))
                    qp.fillRect(idx*self.fontWidth, i*self.fontHeight + 2 , width*self.fontWidth, self.fontHeight, brush)
                    qp.setOpacity(1)


    def drawBranch(self, qp):

        qp.fillRect(-50, 0, 50,  self.ROWS * self.fontHeight, self.backgroundBrush)

        cursorX, cursorY = self.cursor.getPosition()

        if len(self.OPCODES) - 1 < cursorY:
            return

        asm = self.OPCODES[cursorY]

        if asm.isBranch():

            tsize = sum([o.size for o in self.OPCODES])
            msize = sum([o.size for o in self.OPCODES[:cursorY]])

            half = self.fontHeight//2

            # branch address
            target = asm.branchAddress()
            if target == None:
                return

            screenVA = self._getVA(self.dataModel.getOffset())
            if target >  screenVA and target < self._getVA(self.dataModel.getOffset()) + tsize - self.OPCODES[-1].size:
                # branch target is in screen

                sz = 0
                for i, t in enumerate(self.OPCODES):
                    sz += t.size
                    if sz+self._getVA(self.dataModel.getOffset()) >= target:
                        break

                qp.setPen(QtGui.QPen(QtGui.QColor(0, 192, 0), 1, QtCore.Qt.SolidLine))

                # draw the three lines

                qp.drawLine(-5, cursorY*self.fontHeight + self.fontHeight//2, -30, cursorY*self.fontHeight + half)

                qp.drawLine(-30, cursorY*self.fontHeight + self.fontHeight//2, -30, (i + 1)*self.fontHeight + half)

                qp.drawLine(-30, (i + 1)*self.fontHeight + half, -15, (i + 1)*self.fontHeight + half)

                # draw arrow
                points = [QtCore.QPoint(-15, (i + 1)*self.fontHeight + half - 5), 
                          QtCore.QPoint(-15, (i + 1)*self.fontHeight + half + 5), 
                          QtCore.QPoint(-5, (i + 1)*self.fontHeight + half), ]
                needle = QtGui.QPolygon(points)
                qp.setBrush(QtGui.QBrush(QtGui.QColor(0, 128, 0)))
                qp.drawPolygon(needle)



            elif target > screenVA:
                # branch is at greater address, out of screen

                qp.setPen(QtGui.QPen(QtGui.QColor(0, 192, 0), 1, QtCore.Qt.DotLine))

                # draw the two lines
                qp.drawLine(-5, cursorY*self.fontHeight + self.fontHeight//2, -30, cursorY*self.fontHeight + half)
                qp.drawLine(-30, cursorY*self.fontHeight + self.fontHeight//2, -30, (self.ROWS - 2)*self.fontHeight + half)

                # draw arrow
                points = [QtCore.QPoint(-25, (self.ROWS - 2)*self.fontHeight + half), 
                          QtCore.QPoint(-35, (self.ROWS - 2)*self.fontHeight + half), 
                          QtCore.QPoint(-30, (self.ROWS - 2)*self.fontHeight + 2*half), ]
                needle = QtGui.QPolygon(points)
                qp.setBrush(QtGui.QBrush(QtGui.QColor(0, 128, 0)))
                qp.drawPolygon(needle)

            else:
                # upper arrow
                # branch is at lower address, out of screen

                qp.setPen(QtGui.QPen(QtGui.QColor(0, 192, 0), 1, QtCore.Qt.DotLine))

                # draw the two lines
                qp.drawLine(-5, cursorY*self.fontHeight + self.fontHeight//2, -30, cursorY*self.fontHeight + half)
                qp.drawLine(-30, cursorY*self.fontHeight + self.fontHeight//2, -30, (1)*self.fontHeight + half)

                # draw arrow
                points = [QtCore.QPoint(-25, (1)*self.fontHeight + half), 
                          QtCore.QPoint(-35, (1)*self.fontHeight + half), 
                          QtCore.QPoint(-30, (1)*self.fontHeight), ]
                needle = QtGui.QPolygon(points)
                qp.setBrush(QtGui.QBrush(QtGui.QColor(0, 128, 0)))
                qp.drawPolygon(needle)



    def draw(self, refresh=False):
        if self.dataModel.getOffset() in self.Paints:
            self.refresh = False
            self.qpix = QtGui.QPixmap(self.Paints[self.dataModel.getOffset()])
            #print 'hit'
            self.drawAdditionals()
            return

        if self.refresh or refresh:
            qp = QtGui.QPainter()
            qp.begin(self.qpix)
            # viewport
            #qp.fillRect(0, 0, self.COLUMNS * self.fontWidth,  self.ROWS * self.fontHeight, self.backgroundBrush)

            #start = time()
            self.drawTextMode(qp)
            #end = time() - start
            #print 'Time ' + str(end)
            self.refresh = False
            qp.end()

#        self.Paints[self.dataModel.getOffset()] = QtGui.QPixmap(self.qpix)
        self.drawAdditionals()

    def drawAdditionals(self):
        self.newPix = self._getNewPixmap(self.width, self.height + self.SPACER)
        qp = QtGui.QPainter()
        qp.begin(self.newPix)
        qp.setWindow(-50, 0, self.COLUMNS * self.fontWidth,  self.ROWS * self.fontHeight)

        qp.drawPixmap(0, 0, self.qpix)

        #self.transformationEngine.decorateText()

        # highlight selected text
        self.selector.highlightText()

        # draw other selections
        self.selector.drawSelections(qp)

        # draw our cursor
        self.drawCursor(qp)

        #qp.setViewport(0, 0, 50,  self.ROWS * self.fontHeight)
        """
        self.newPix = self._getNewPixmap(50, self.height)
        qp = QtGui.QPainter()
        qp.begin(self.newPix)

        qp.setViewport(0, 0, 50,  self.ROWS * self.fontHeight)
        """
        self.drawBranch(qp)
        self.drawSelected(qp)
        qp.end()

    def _getNewPixmap(self, width, height):
        return QtGui.QPixmap(width, height)

    def getColumnsbyRow(self, row):
        if row < len(self.OPCODES):
            obj = self.OPCODES[row]
            return obj.size
        else:
            return 0
        
    def _getVA(self, offset):
        if self.plugin:
            return self.plugin.hintDisasmVA(offset)

        return 0

    def _getOpcodes(self, ofs, code, dt, count):
        md = self.disasm_engine
        
        cnt = 0
        offset = 0
        OPCODES = []

        # how ugly ... don't like capstone on this one..
        while cnt < count and offset < len(code):
            buffer = bytes(code[offset:])
            Disasm = md.disasm(buffer, self._getVA(ofs) + offset, count=count)

            # disasamble as much as we can
            for d in Disasm:
                cnt += 1
                offset += d.size
                OPCODES.append(self.ASMLine(d, self.plugin, self.lexer))

            # when we are stopped with errors, inject fake isntructions
            if cnt < self.ROWS and offset < len(code):
                class D:
                    mnemonic = 'db'
                    bytes = ''
                    op_str = ''
                    size = 1
                    id = 0
                    address = 0
                    operands = []
                    groups = []

                d = D()
                d.mnemonic = 'db ' + '0x{:02x}'.format(code[offset])
                d.bytes = bytes([code[offset]])

                d.address = self._getVA(ofs) + offset

                OPCODES.append(self.ASMLine(d, self.plugin, self.lexer))
                cnt += 1
                offset += 1


        return OPCODES


    def _drawRow(self, qp, cemu, row, asm):
        qp.setPen(QtGui.QPen(QtGui.QColor(192, 192, 192), 1, QtCore.Qt.SolidLine))

        # write hexdump
        cemu.writeAt(0, row, asm.hex)

        # fill with spaces
        cemu.write((MNEMONIC_COLUMN - len(asm.hex))*' ')

        # let's color some branch instr
        if asm.isBranch():
            qp.setPen(QtGui.QPen(QtGui.QColor(255, 80, 0)))
        else:
            qp.setPen(QtGui.QPen(QtGui.QColor(192, 192, 192), 1, QtCore.Qt.SolidLine))

        cemu.write(asm.mnemonic)

        # leave some spaces
        cemu.write((MNEMONIC_WIDTH-len(asm.mnemonic))*' ')

        if asm.symbol:
            qp.setPen(QtGui.QPen(QtGui.QColor(192, 192, 192), 1, QtCore.Qt.SolidLine))
            cemu.write_c('[')

            qp.setPen(QtGui.QPen(QtGui.QColor('yellow'), 1, QtCore.Qt.SolidLine))
            cemu.write(asm.symbol)

            qp.setPen(QtGui.QPen(QtGui.QColor(192, 192, 192), 1, QtCore.Qt.SolidLine))
            cemu.write_c(']')

            result = '[' + asm.symbol + ']'
        else:
            self._write_instruction(asm, qp, cemu)

        if len(asm.referencedString) > 4:
            cemu.write(30*' ')

            qp.setPen(QtGui.QPen(QtGui.QColor(82, 192, 192), 1, QtCore.Qt.SolidLine))
            cemu.write('; "{0}"'.format(asm.referencedString))


    def _write_instruction(self, asm, qp, cemu):
        asm.full_load()

        s = asm.operands
        idx = 0
        qp.setPen(QtGui.QPen(QtGui.QColor(192, 192, 192), 1, QtCore.Qt.SolidLine))

        for tok in asm.lexer:
            if tok.lexpos > idx:
                cemu.write(s[idx:tok.lexpos])
                idx = tok.lexpos

            qp.save()
            if tok.type == 'REGISTER':
                qp.setPen(QtGui.QPen(QtGui.QColor('white')))
            
            if tok.type == 'NUMBER':
                qp.setPen(QtGui.QPen(QtGui.QColor('green')))

            cemu.write(tok.value)

            qp.restore()
            idx = tok.lexpos + len(tok.value)

        if idx < len(s):
            cemu.write(s[idx:])

    def drawTextMode(self, qp):
        # draw background
        qp.fillRect(0, 0, self.COLUMNS * self.fontWidth,  self.ROWS * self.fontHeight, self.backgroundBrush)

        # set text pen&font
        qp.setFont(self.font)
        qp.setPen(self.textPen)
        
        cemu = ConsoleEmulator(qp, self.ROWS, self.COLUMNS)

        if len(self.OPCODES) == 0:
            self.OPCODES = self._getOpcodes(self.dataModel.getOffset(), self.getDisplayablePage(), self.plugin.hintDisasm(), count=self.ROWS)


        for i in range(self.ROWS):
            if i < len(self.OPCODES):
                asm = self.OPCODES[i]
                self._drawRow(qp, cemu, i, asm)


    def _getRowInPage(self, offset):

        offset -= self.dataModel.getOffset()
        size = 0
        for i, asm in enumerate(self.OPCODES):
            if size + asm.size > offset:
                return i
            size += asm.size

        return None

    def _getOffsetOfRow(self, row):
        # of course, it could be done nicely, not like this
        size = 0
        for i, asm in enumerate(self.OPCODES):
            if i == row:
                return size

            size += asm.size                

        return None

    def goTo(self, offset):
        tsize = sum([asm.size for asm in self.OPCODES])

        if offset < self.dataModel.getOffset() + tsize and offset > self.dataModel.getOffset():
            # if in current page, move cursor
            row = self._getRowInPage(offset)
            off_row = self._getOffsetOfRow(row)
            diff = offset - self.dataModel.getOffset() - off_row# self.OPCODES[row].size

            if row is not None:
                self.cursor.moveAbsolute((diff)*3, row)

            self.draw(refresh=False)
        else:
            # else, move page
            self.dataModel.goTo(offset)
            self.OPCODES = self._getOpcodes(offset, self.getDisplayablePage(), self.plugin.hintDisasm(), count=self.ROWS)
            self.cursor.moveAbsolute(0, 0)
            self.draw(refresh=True)

        #TODO: getDisplayablePage() won't contain what we want to disasm. we will use dataModel
        #      in this view, getDisplayablePage will contain disasm text, because that is what is displayed

        if self.widget:
            self.widget.update()


    def scrollPages(self, number, cachePix=None, pageOffset=None):
        self.scroll(0, -number*self.ROWS, cachePix=cachePix, pageOffset=pageOffset)

    def _disassamble_one(self, start, end, count=1):
        code = self.dataModel.getStream(start, end)
        Disasm = self._getOpcodes(start, code, 0, count)
        return Disasm

    def scroll_v(self, dy, cachePix=None, pageOffset=None):
        #start = time()        

        RowsToDraw = []


        factor = abs(dy)


        # repeat as many rows we have scrolled
        
        for row in range(factor):

            d = None
            if dy < 0:
                tsize = sum([asm.size for asm in self.OPCODES])

                #self.dataModel.slide(self.OPCODES[0].size)
                start = self.dataModel.getOffset() + tsize

                # let's say we decode maximum 50 bytes
                end = start + 50

                # make sure we won't jump off the limits
                if start > self.dataModel.getDataSize():
                    return

                if end > self.dataModel.getDataSize():
                    end = self.dataModel.getDataSize()

                if start == end:
                    return

                iterable = self._disassamble_one(start, end, count=1)
                #print iterable
                if len(iterable) > 0:
                    d = iterable[0]
                else:
                    #todo: what should we handle here
                    break

            if dy >= 0:
                # we try to decode from current offset - 50, in this case even if decoding is incorrect (will overlap),
                # in 50 (actually 64, arm hack, we have 4bytes/instr and instruction is almoast always decoded in something) 
                # bytes it is possible to correct itself, so hopefully last instruction it's decoded correctly and
                # followed correctly by current_offset instruction

                INST = 64
                if self.dataModel.getOffset() < INST:
                    start = 0
                else:
                    start = self.dataModel.getOffset() - INST


                end = self.dataModel.getOffset()
                iterable = self._disassamble_one(start, end, count=INST)
                #print iterable
                if len(iterable) > 0:
                    d = iterable[-1]
                else:
                    #todo: what should we handle here
                    break

            newasm = d

            if dy < 0:
                self.dataModel.slide(self.OPCODES[0].size)
                del self.OPCODES[0]


            if dy >= 0:
                self.dataModel.slide(-d.size)
                del self.OPCODES[len(self.OPCODES) - 1]

            if dy < 0:
                self.OPCODES.append(newasm)

            if dy > 0:
                self.OPCODES.insert(0, newasm)

            if dy < 0:
                #RowsToDraw.append((self.ROWS - factor + row, newasm))
                RowsToDraw.append((self.ROWS + row, newasm))

            if dy > 0:
                #RowsToDraw.append((factor - row - 1, newasm))
                RowsToDraw.append((-row - 1, newasm))

        # draw

        if len(RowsToDraw) < abs(dy):
            # maybe we couldn't draw dy rows (possible we reached the beginning of the data to early), recalculate dy
            dy = len(RowsToDraw)*dy//abs(dy)
            factor = abs(dy)

        if not cachePix:
            self.qpix.scroll(0, dy*self.fontHeight, self.qpix.rect())

        qp = QtGui.QPainter()
        if cachePix:
            qp.begin(cachePix)
        else:
            qp.begin(self.qpix)

        qp.setFont(self.font)
        qp.setPen(self.textPen)

        # erase rows that will disappear
        if dy < 0:
            qp.fillRect(0, (self.ROWS-factor)*self.fontHeight, self.fontWidth*self.COLUMNS, factor * self.fontHeight, self.backgroundBrush)

        if dy > 0:
            qp.fillRect(0, 0, self.fontWidth*self.COLUMNS, factor * self.fontHeight, self.backgroundBrush)

        cemu = ConsoleEmulator(qp, self.ROWS, self.COLUMNS)

        for row, asm in RowsToDraw:
            self._drawRow(qp, cemu, dy + row, asm)


        qp.end()

        #end = time() - start

    def scroll(self, dx, dy, cachePix=None, pageOffset=None):
        if dx != 0:
            if self.dataModel.inLimits((self.dataModel.getOffset() - dx)):
                self.dataModel.slide(dx)
                self.draw(refresh=True)
                #self.scroll_h(dx)

        if dy != 0:
            if dy > 0:
                if self.dataModel.getOffset() == 0:
                    return

            if dy < 0:
                tsize = sum([asm.size for asm in self.OPCODES])

                if self.dataModel.getOffset() + tsize ==  self.dataModel.getDataSize():
                    return

            self.scroll_v(dy, cachePix, pageOffset)


    def moveCursor(self, direction):
        cursorX, cursorY = self.cursor.getPosition()

        if direction == Directions.Left:
            asm = self.OPCODES[cursorY]

            if cursorX == 0:
                if cursorY == 0:
                    # if first line, scroll
                    self.scroll(0, 1)
                    self.cursor.moveAbsolute(0, 0)
                else:
                    # move to last token from previous line
                    asm_prev = self.OPCODES[cursorY - 1]
                    idx = asm_prev.getEndCursor()
                    self.cursor.moveAbsolute(idx, cursorY - 1)
            else:
                x, dy = asm.getNextCursor(cursorX, direction=Directions.Left)
                self.cursor.move(-(cursorX-x), dy)


        if direction == Directions.Right:
            asm = self.OPCODES[cursorY]
            x, dy = asm.getNextCursor(cursorX, direction=Directions.Right)

            if cursorY == self.ROWS-1 and dy > 0:
                self.scroll(0, -1)
                self.cursor.moveAbsolute(0, cursorY)

            else:
                if cursorY + dy >= len(self.OPCODES):
                    dy = 0

                self.cursor.move(x-cursorX, dy)

        if direction == Directions.Down:
            if cursorY == self.ROWS-1:
                # move cursor to first token
                self.scroll(0, -1)
                self.cursor.moveAbsolute(0, cursorY)
            else:
                # move next line, to nearest token on columns
                if cursorY + 1 < len(self.OPCODES):
                    asm = self.OPCODES[cursorY + 1]
                    x = asm.getNearestCursor(cursorX)
                    self.cursor.moveAbsolute(x, cursorY + 1)

        if direction == Directions.Up:
            if cursorY == 0:
                # move cursor to first token
                self.scroll(0, 1)
                self.cursor.moveAbsolute(0, cursorY)
            else:
                # move next line, to nearest token on columns
                asm = self.OPCODES[cursorY - 1]
                x = asm.getNearestCursor(cursorX)
                self.cursor.moveAbsolute(x, cursorY - 1)

        if direction == Directions.End:
            pass

        if direction == Directions.Home:
            self.cursor.moveAbsolute(0, 0)


        if direction == Directions.CtrlHome:
            self.goTo(0)

        if direction == Directions.CtrlEnd:
            self.dataModel.slideToLastPage()
            self.draw(refresh=True)
            self.cursor.moveAbsolute(self.COLUMNS-1, self.ROWS-1)

    def _followBranch(self):
        cursorX, cursorY = self.cursor.getPosition()
        asm = self.OPCODES[cursorY]

        if asm.isBranch():
            value = asm.branchAddress()
            if value:
                fofs = self.plugin.disasmVAtoFA(value)
                if fofs != None:
                    rowOfs = self._getOffsetOfRow(cursorY)
                    if rowOfs != None:
                        self.FlowHistory.append(rowOfs + self.dataModel.getOffset())
                        self.goTo(fofs)

    def _followBranchHistory(self):
        if len(self.FlowHistory) > 0:
            offset = self.FlowHistory[-1]
            del self.FlowHistory[-1]
            self.goTo(offset)

    def handleKeyEvent(self, modifiers, key, event=None):
        if event.type() == QtCore.QEvent.KeyRelease:
            if key == QtCore.Qt.Key_Shift:
                self.stopSelection()
                return True

        if event.type() == QtCore.QEvent.KeyPress:

            if modifiers == QtCore.Qt.ShiftModifier:
                keys = [QtCore.Qt.Key_Right, QtCore.Qt.Key_Left, QtCore.Qt.Key_Down, QtCore.Qt.Key_Up, QtCore.Qt.Key_End, QtCore.Qt.Key_Home]
                if key in keys:
                    self.startSelection()

            if modifiers == QtCore.Qt.ControlModifier:
                if key == QtCore.Qt.Key_Right:
                    self.dataModel.slide(1)
                    self.addop((self.scroll, -1, 0))

                if key == QtCore.Qt.Key_Left:
                    self.dataModel.slide(-1)
                    self.addop((self.scroll, 1, 0))

                if key == QtCore.Qt.Key_Down:
                    self.addop((self.scroll, 0, -1))
                    self.addop((self.draw,))

                if key == QtCore.Qt.Key_Up:
                    self.addop((self.scroll, 0, 1))
                    self.addop((self.draw,))

                if key == QtCore.Qt.Key_End:
                    # not supported
                    pass

                if key == QtCore.Qt.Key_Home:
                    self.moveCursor(Directions.CtrlHome)
                    self.addop((self.draw,))
                    #self.draw()

                return True

            else:#elif modifiers == QtCore.Qt.NoModifier:

                if key == QtCore.Qt.Key_Escape:
                    self.selector.resetSelections()
                    self.addop((self.draw,))

                if key == QtCore.Qt.Key_Left:
                    self.moveCursor(Directions.Left)
                    self.addop((self.draw,))
                    #self.draw()

                if key == QtCore.Qt.Key_Right:
                    self.moveCursor(Directions.Right)
                    self.addop((self.draw,))
                    #self.draw()
                    
                if key == QtCore.Qt.Key_Down:
                    self.moveCursor(Directions.Down)
                    self.addop((self.draw,))
                    #self.draw()
                    
                if key == QtCore.Qt.Key_End:
                    self.moveCursor(Directions.End)
                    self.addop((self.draw,))
                    #self.draw()
                    
                if key == QtCore.Qt.Key_Home:
                    self.moveCursor(Directions.Home)
                    self.addop((self.draw,))
                    #self.draw()

                if key == QtCore.Qt.Key_Up:
                    self.moveCursor(Directions.Up)
                    self.addop((self.draw,))
                    #self.draw()
                    
                if key == QtCore.Qt.Key_PageDown:
                    self.addop((self.scrollPages, 1))
                    self.addop((self.draw,))
        
                if key == QtCore.Qt.Key_PageUp:
                    self.addop((self.scrollPages, -1))
                    self.addop((self.draw,))

                if key == QtCore.Qt.Key_Return:
                    self.addop((self._followBranch,))
                    self.addop((self.draw,))

                if key == QtCore.Qt.Key_Escape:
                    self.addop((self._followBranchHistory,))
                    self.addop((self.draw,))

                return True

        return False

    def addop(self, t):
        self.Ops.append(t)

    def getHeaderInfo(self):
        return 'Disasm listing'