Disassemble the data into an instruction.
195026
def disassemble(self, data, address, architecture_mode=None):
        
        # TODO: Improve this code!
        if architecture_mode is None:
            if self._arch_mode is None:
                architecture_mode = ARCH_ARM_MODE_THUMB
            else:
                architecture_mode = self._arch_mode

        self._disassembler = self._available_disassemblers[architecture_mode]

        disasm = self._cs_disassemble_one(data, address)

        instr = self._cs_translate_insn(disasm)

        if instr:
            instr.address = address
            instr.size = disasm.size
            instr.bytes = data[0:disasm.size]
        else:
            raise DisassemblerError()

        return instr
727416
def assemble
      parts = [id]
      data.each do |k, v|
        # Characters ", ] and \ must be escaped to prevent any parsing errors
        v = v.gsub(/(\"|\]|\\)/) { |match| '\\' + match }
        parts << "#{k}=\"#{v}\""
      end
      "[#{parts.join(' ')}]"
    end
924359
def fixup(p, data_bits, ptr_bits, bits_set):
    
    for i in range(ptr_bits):
        if 0 != bits_set & (1 << i):
            p.inst(X(data_bits + i))
971526
function Instruction(pi) {
  _classCallCheck(this, Instruction);

  this.tag = pi.split('<?')[1].split(' ')[0];
  this.att = Object.create(null);
  var hit,
      atexp = Instruction._ATEXP;

  while (hit = atexp.exec(pi)) {
    var n = hit[1],
        v = hit[2];
    this.att[n] = cast(v);
  }
}
972298
def _clean_data(data):
    '''
    
    '''
    for key in list(data):
        if key.startswith('__pub'):
            del data[key]
    return data
1374700
protected function assemble()
    {
        $this->push($this->replace ? 'REPLACE' : 'INSERT');
        $this->pushIgnoreDelayed();
        $this->push('INTO');
        $this->pushTable();
        $this->push('SET');
        $this->pushValues();
        $this->pushOnDuplicateKeyUpdate();
    }
79327
def assemble(cls):
        """"""
        document = {}
        for field_name, maker in cls._instructions.items():
            with maker.target(document):
                document[field_name] = maker()
        return document
618342
def execute_lite(self, instructions, context=None):
        
        if context:
            self.__cpu.registers = dict(context)

        for instr in instructions:
            self.__execute_one(instr)

        return dict(self.__cpu.registers), self.__mem
1075060
def step(self):
        """"""
        op = self.code[self.instruction_pointer]
        self.instruction_pointer += 1
        op(self)
1084197
def parse_instruction(string, location, tokens):
    
    mnemonic_str = ReilMnemonic.from_string(tokens["mnemonic"])

    oprnd1 = tokens["fst_operand"][0]
    oprnd2 = tokens["snd_operand"][0]
    oprnd3 = tokens["trd_operand"][0]

    ins_builder = ReilBuilder()

    return ins_builder.build(mnemonic_str, oprnd1, oprnd2, oprnd3)
289557
def consume(self):
        '''
        
        '''
        generic_consume = getattr(self, 'generic_consume', None)
        
        for instr in disassembler(self.code):
            method_name = 'consume_%s' % (instr.opname)
            method = getattr(self, method_name, generic_consume)
            if not method:
                raise AttributeError("class %r has no method %r" % (type(self).__name__, method_name))
            
            self.instruction_pre(instr)
            method(instr)
            self.instruction_post(instr)
130342
def distb(self, tb=None, file=None):
        """"""
        if tb is None:
            try:
                tb = sys.last_traceback
            except AttributeError:
                raise RuntimeError("no last traceback to disassemble")
            while tb.tb_next: tb = tb.tb_next
        self.disassemble(tb.tb_frame.f_code, tb.tb_lasti, file=file)
1131083
protected void instructionImpl(String target, String data) {
        xmlNode.appendChild(getDocument().createProcessingInstruction(target, data));
    }
304450
def do_disassemble(self, arg):
        
        if not arg:
            arg = self.default_disasm_target
        token_list      = self.split_tokens(arg, 1, 1)
        pid, tid        = self.get_process_and_thread_ids_from_prefix()
        process         = self.get_process(pid)
        address         = self.input_address(token_list[0], pid, tid)
        try:
            code = process.disassemble(address, 15*8)[:8]
        except Exception:
            msg = "can't disassemble address %s"
            msg = msg % HexDump.address(address)
            raise CmdError(msg)
        if code:
            label        = process.get_label_at_address(address)
            last_code    = code[-1]
            next_address = last_code[0] + last_code[1]
            next_address = HexOutput.integer(next_address)
            self.default_disasm_target = next_address
            print("%s:" % label)
##            print(CrashDump.dump_code(code))
            for line in code:
                print(CrashDump.dump_code_line(line, bShowDump = False))
967529
def merge_specific_instructions(chunks, join_preamble=True, join_raster=True):
    
    new_instructions = []
    last_opcode = None
    instruction_buffer = b''
    for instruction in chunks:
        opcode = match_opcode(instruction)
        if   join_preamble and OPCODES[opcode][0] == 'preamble' and last_opcode == 'preamble':
            instruction_buffer += instruction
        elif join_raster   and 'raster' in OPCODES[opcode][0] and 'raster' in last_opcode:
            instruction_buffer += instruction
        else:
            if instruction_buffer:
                new_instructions.append(instruction_buffer)
            instruction_buffer = instruction
        last_opcode = OPCODES[opcode][0]
    if instruction_buffer:
        new_instructions.append(instruction_buffer)
    return new_instructions
1119106
def start_smart_disassemble(self, start_address, callback):
        
        _opcodes.start_smart_disassemble(self._ptr, start_address, callback)
327114
def p_simple_instruction(p):
    
    p[0] = make_sentence(p[1], make_typecast(TYPE.ubyte, p[2], p.lineno(1)))