rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
saved = no_magic() try: f1 = getcompiled(testfn, [int]) res = f1(0) assert res is None, repr(res) res = f1(42) assert res is None, repr(res) py.test.raises(AssertionError, f1, -2) finally: restore_magic(saved) def no_magic(): import __builtin__ try: py.magic.revert(__builtin__, 'AssertionError') return True except Val... | f1 = getcompiled(testfn, [int]) res = f1(0) assert res is None, repr(res) res = f1(42) assert res is None, repr(res) e = py.test.raises(Exception, f1, -2) assert e.type.__name__ == 'AssertionError' | def testfn(n): assert n >= 0 |
raise wrap_oserror2(space, e, w_fname) | raise wrap_oserror2(space, e, w_name) | def descr_init(self, space, w_name, mode, closefd): if space.isinstance_w(w_name, space.w_float): raise OperationError(space.w_TypeError, space.wrap( "integer argument expected, got float")) try: fd = space.int_w(w_name) except OperationError, e: pass else: if fd < 0: raise OperationError(space.w_ValueError, space.wrap... |
[rffi.INT, rffi.CArrayPtr(lltype.Signed), rffi.SIZE_T], | [rffi.INT, llmemory.Address, rffi.SIZE_T], | def is_rpy_instance(gc, gcref): typeid = gc.get_type_id(llmemory.cast_ptr_to_adr(gcref)) return gc.is_rpython_class(typeid) |
self.writebuffer, | rffi.cast(llmemory.Address, self.writebuffer), | def flush(self): if self.buf_count > 0: bytes = self.buf_count * rffi.sizeof(rffi.LONG) count = raw_os_write(self.fd, self.writebuffer, rffi.cast(rffi.SIZE_T, bytes)) if rffi.cast(lltype.Signed, count) != bytes: raise OSError(rposix.get_errno(), "raw_os_write failed") self.buf_count = 0 |
self.writebuffer[x] = llmemory.raw_malloc_usage(value) | self.writebuffer[x] = value | def write(self, value): x = self.buf_count self.writebuffer[x] = llmemory.raw_malloc_usage(value) x += 1 self.buf_count = x if x == self.BUFSIZE: self.flush() |
if not self.gc.prebuilt_gc_objects_are_static_roots: self.gc.prebuilt_root_objects.foreach(self.gc._collect_obj, self.pending) | def add_roots(self): self.gc._heap_dumper = self if not self.gc.prebuilt_gc_objects_are_static_roots: self.gc.prebuilt_root_objects.foreach(self.gc._collect_obj, self.pending) self.gc.root_walker.walk_roots( _hd_add_root, _hd_add_root, _hd_add_root) self.gc._heap_dumper = None pendingroots = self.pending self.pending =... | |
if not we_are_translated() and not isinstance(descr, LoopToken): | if op.result and not we_are_translated() and not isinstance(descr, LoopToken): | def emit_op_call(self, op, regalloc, fcond, save_all_regs=False): adr = self.cpu.cast_adr_to_int(op.getarg(0).getint()) args = op.getarglist()[1:] cond = self._emit_call(adr, args, regalloc, fcond, save_all_regs, op.result) |
m.definition('SHARED_IMPORT_LIB', so_name.new(ext='lib').basename), | m.definition('SHARED_IMPORT_LIB', so_name.new(ext='lib').basename) m.definition('PYPY_MAIN_FUNCTION', "pypy_main_startup") | def pypyrel(fpath): rel = py.path.local(fpath).relto(pypypath) if rel: return os.path.join('$(PYPYDIR)', rel) else: return fpath |
assert not in_text, "unexpected repeated .text start: %d" % n in_text = True elif self.r_sectionstart.match(line): if in_function: yield in_function, functionlines functionlines = [] in_text = False in_function = False elif in_text and self.FunctionGcRootTracker.r_functionstart.match(line): yield in_function, functionl... | def find_functions(self, iterlines): functionlines = [] in_text = False in_function = False for n, line in enumerate(iterlines): if self.r_textstart.match(line): assert not in_text, "unexpected repeated .text start: %d" % n in_text = True elif self.r_sectionstart.match(line): if in_function: yield in_function, function... | |
mant = Q & ((1 << MANT_DIG - 1) - 1) | mant = Q & ((one << MANT_DIG - 1) - 1) | def float_unpack(Q, size): """Convert a 32-bit or 64-bit integer created by float_pack into a Python float.""" if size == 8: MIN_EXP = -1021 # = sys.float_info.min_exp MAX_EXP = 1024 # = sys.float_info.max_exp MANT_DIG = 53 # = sys.float_info.mant_dig BITS = 64 elif size == 4: MIN_EXP = -125 # C's FLT_MIN_EXP ... |
mant += 1 << MANT_DIG - 1 | mant += one << MANT_DIG - 1 | def float_unpack(Q, size): """Convert a 32-bit or 64-bit integer created by float_pack into a Python float.""" if size == 8: MIN_EXP = -1021 # = sys.float_info.min_exp MAX_EXP = 1024 # = sys.float_info.max_exp MANT_DIG = 53 # = sys.float_info.mant_dig BITS = 64 elif size == 4: MIN_EXP = -125 # C's FLT_MIN_EXP ... |
res = genop_guard_list[dispatch_opnum](self, op, guard_op, guard_token, arglocs, resloc) faildescr._x86_adr_jump_offset = res | genop_guard_list[dispatch_opnum](self, op, guard_op, guard_token, arglocs, resloc) if not we_are_translated(): assert hasattr(faildescr, '_x86_adr_jump_offset') | def regalloc_perform_with_guard(self, op, guard_op, faillocs, arglocs, resloc, current_depths): faildescr = guard_op.getdescr() assert isinstance(faildescr, AbstractFailDescr) faildescr._x86_current_depths = current_depths failargs = guard_op.getfailargs() guard_opnum = guard_op.getopnum() guard_token = self.implement_... |
return self.implement_guard(guard_token, rev_cond) | self.implement_guard(guard_token, rev_cond) | def genop_cmp_guard(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() if isinstance(op.getarg(0), Const): self.mc.CMP(arglocs[1], arglocs[0]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, rev_cond) else: return self.implement_guard(guard_token, false_... |
return self.implement_guard(guard_token, false_rev_cond) | self.implement_guard(guard_token, false_rev_cond) | def genop_cmp_guard(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() if isinstance(op.getarg(0), Const): self.mc.CMP(arglocs[1], arglocs[0]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, rev_cond) else: return self.implement_guard(guard_token, false_... |
return self.implement_guard(guard_token, cond) | self.implement_guard(guard_token, cond) | def genop_cmp_guard(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() if isinstance(op.getarg(0), Const): self.mc.CMP(arglocs[1], arglocs[0]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, rev_cond) else: return self.implement_guard(guard_token, false_... |
return self.implement_guard(guard_token, false_cond) | self.implement_guard(guard_token, false_cond) | def genop_cmp_guard(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() if isinstance(op.getarg(0), Const): self.mc.CMP(arglocs[1], arglocs[0]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, rev_cond) else: return self.implement_guard(guard_token, false_... |
return self.implement_guard(guard_token, cond) | self.implement_guard(guard_token, cond) | def genop_cmp_guard_float(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() self.mc.UCOMISD(arglocs[0], arglocs[1]) # 16 is enough space for the rel8 jumps below and the rel32 # jump in implement_guard self.mc.ensure_bytes_available(16 + guard_token.recovery_stub_size()) if guard_... |
return self.implement_guard(guard_token) return self.implement_guard(guard_token, false_cond) | self.implement_guard(guard_token) else: self.implement_guard(guard_token, false_cond) | def genop_cmp_guard_float(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() self.mc.UCOMISD(arglocs[0], arglocs[1]) # 16 is enough space for the rel8 jumps below and the rel32 # jump in implement_guard self.mc.ensure_bytes_available(16 + guard_token.recovery_stub_size()) if guard_... |
return self.implement_guard(guard_token, 'E') | self.implement_guard(guard_token, 'E') | def genop_guard_float_ne(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() self.mc.UCOMISD(arglocs[0], arglocs[1]) # 16 is enough space for the rel8 jumps below and the rel32 # jump in implement_guard self.mc.ensure_bytes_available(16 + guard_token.recovery_stub_size()) if guard_o... |
return self.implement_guard(guard_token) | self.implement_guard(guard_token) | def genop_guard_float_ne(self, op, guard_op, guard_token, arglocs, result_loc): guard_opnum = guard_op.getopnum() self.mc.UCOMISD(arglocs[0], arglocs[1]) # 16 is enough space for the rel8 jumps below and the rel32 # jump in implement_guard self.mc.ensure_bytes_available(16 + guard_token.recovery_stub_size()) if guard_o... |
return self.implement_guard(guard_token, 'Z') else: return self.implement_guard(guard_token, 'NZ') | self.implement_guard(guard_token, 'Z') else: self.implement_guard(guard_token, 'NZ') | def genop_guard_int_is_true(self, op, guard_op, guard_token, arglocs, resloc): guard_opnum = guard_op.getopnum() self.mc.CMP(arglocs[0], imm0) if guard_opnum == rop.GUARD_TRUE: return self.implement_guard(guard_token, 'Z') else: return self.implement_guard(guard_token, 'NZ') |
return self.implement_guard(guard_token, 'NZ') else: return self.implement_guard(guard_token, 'Z') | self.implement_guard(guard_token, 'NZ') else: self.implement_guard(guard_token, 'Z') | def genop_guard_int_is_zero(self, op, guard_op, guard_token, arglocs, resloc): guard_opnum = guard_op.getopnum() self.mc.CMP(arglocs[0], imm0) if guard_opnum == rop.GUARD_TRUE: return self.implement_guard(guard_token, 'NZ') else: return self.implement_guard(guard_token, 'Z') |
return self.implement_guard(guard_token, 'Z') | self.implement_guard(guard_token, 'Z') | def genop_guard_guard_true(self, ign_1, guard_op, guard_token, locs, ign_2): loc = locs[0] self.mc.TEST(loc, loc) return self.implement_guard(guard_token, 'Z') |
return self.implement_guard(guard_token, 'NZ') | self.implement_guard(guard_token, 'NZ') | def genop_guard_guard_no_exception(self, ign_1, guard_op, guard_token, locs, ign_2): self.mc.CMP(heap(self.cpu.pos_exception()), imm0) return self.implement_guard(guard_token, 'NZ') |
addr = self.implement_guard(guard_token, 'NE') | self.implement_guard(guard_token, 'NE') | def genop_guard_guard_exception(self, ign_1, guard_op, guard_token, locs, resloc): loc = locs[0] loc1 = locs[1] self.mc.MOV(loc1, heap(self.cpu.pos_exception())) self.mc.CMP(loc1, loc) addr = self.implement_guard(guard_token, 'NE') if resloc is not None: self.mc.MOV(resloc, heap(self.cpu.pos_exc_value())) self.mc.MOV(h... |
return addr | def genop_guard_guard_exception(self, ign_1, guard_op, guard_token, locs, resloc): loc = locs[0] loc1 = locs[1] self.mc.MOV(loc1, heap(self.cpu.pos_exception())) self.mc.CMP(loc1, loc) addr = self.implement_guard(guard_token, 'NE') if resloc is not None: self.mc.MOV(resloc, heap(self.cpu.pos_exc_value())) self.mc.MOV(h... | |
return self.implement_guard(guard_token, 'O') | self.implement_guard(guard_token, 'O') | def _gen_guard_overflow(self, guard_op, guard_token): guard_opnum = guard_op.getopnum() if guard_opnum == rop.GUARD_NO_OVERFLOW: return self.implement_guard(guard_token, 'O') elif guard_opnum == rop.GUARD_OVERFLOW: return self.implement_guard(guard_token, 'NO') else: not_implemented("int_xxx_ovf followed by %s" % guard... |
return self.implement_guard(guard_token, 'NO') | self.implement_guard(guard_token, 'NO') | def _gen_guard_overflow(self, guard_op, guard_token): guard_opnum = guard_op.getopnum() if guard_opnum == rop.GUARD_NO_OVERFLOW: return self.implement_guard(guard_token, 'O') elif guard_opnum == rop.GUARD_OVERFLOW: return self.implement_guard(guard_token, 'NO') else: not_implemented("int_xxx_ovf followed by %s" % guard... |
return self.implement_guard(guard_token, 'NZ') | self.implement_guard(guard_token, 'NZ') | def genop_guard_guard_false(self, ign_1, guard_op, guard_token, locs, ign_2): loc = locs[0] self.mc.TEST(loc, loc) return self.implement_guard(guard_token, 'NZ') |
return self.implement_guard(guard_token, 'NE') | self.implement_guard(guard_token, 'NE') | def genop_guard_guard_value(self, ign_1, guard_op, guard_token, locs, ign_2): if guard_op.getarg(0).type == FLOAT: assert guard_op.getarg(1).type == FLOAT self.mc.UCOMISD(locs[0], locs[1]) else: self.mc.CMP(locs[0], locs[1]) return self.implement_guard(guard_token, 'NE') |
return self.implement_guard(guard_token, 'NE') | self.implement_guard(guard_token, 'NE') | def genop_guard_guard_class(self, ign_1, guard_op, guard_token, locs, ign_2): self.mc.ensure_bytes_available(256) self._cmp_guard_class(locs) return self.implement_guard(guard_token, 'NE') |
return self.implement_guard(guard_token, 'NE') | self.implement_guard(guard_token, 'NE') | def genop_guard_guard_nonnull_class(self, ign_1, guard_op, guard_token, locs, ign_2): self.mc.ensure_bytes_available(256) self.mc.CMP(locs[0], imm1) # Patched below self.mc.J_il8(rx86.Conditions['B'], 0) jb_location = self.mc.get_relative_pos() self._cmp_guard_class(locs) # patch the JB above offset = self.mc.get_relat... |
mc = self.mc._mc | def implement_guard(self, guard_token, condition=None): self.mc.reserve_bytes(guard_token.recovery_stub_size()) self.pending_guard_tokens.append(guard_token) # XXX: These jumps are patched later, the self.mc.tell() are just # dummy values if condition: self.mc.J_il(rx86.Conditions[condition], self.mc.tell()) else: self... | |
self.mc.J_il(rx86.Conditions[condition], self.mc.tell()) else: self.mc.JMP_l(self.mc.tell()) return self.mc.tell() - 4 | mc.J_il(rx86.Conditions[condition], mc.tell()) else: mc.JMP_l(mc.tell()) guard_token.faildescr._x86_adr_jump_offset = mc.tell() - 4 | def implement_guard(self, guard_token, condition=None): self.mc.reserve_bytes(guard_token.recovery_stub_size()) self.pending_guard_tokens.append(guard_token) # XXX: These jumps are patched later, the self.mc.tell() are just # dummy values if condition: self.mc.J_il(rx86.Conditions[condition], self.mc.tell()) else: self... |
return self.implement_guard(guard_token, 'L') | self.implement_guard(guard_token, 'L') | def genop_guard_call_may_force(self, op, guard_op, guard_token, arglocs, result_loc): faildescr = guard_op.getdescr() fail_index = self.cpu.get_fail_descr_number(faildescr) self.mc.MOV_bi(FORCE_INDEX_OFS, fail_index) self.genop_call(op, arglocs, result_loc) self.mc.CMP_bi(FORCE_INDEX_OFS, 0) return self.implement_guard... |
return self.implement_guard(guard_token, 'L') | self.implement_guard(guard_token, 'L') | def genop_guard_call_assembler(self, op, guard_op, guard_token, arglocs, result_loc): faildescr = guard_op.getdescr() fail_index = self.cpu.get_fail_descr_number(faildescr) self.mc.MOV_bi(FORCE_INDEX_OFS, fail_index) descr = op.getdescr() assert isinstance(descr, LoopToken) assert len(arglocs) - 2 == len(descr._x86_arg... |
self.check_tree_loop_count(2) | if self.optimizer == OPTIMIZER_SIMPLE: self.check_tree_loop_count(1) else: self.check_tree_loop_count(2) | def f(y): x = Int1(0) while y > 0: myjitdriver.can_enter_jit(x=x, y=y) myjitdriver.jit_merge_point(x=x, y=y) y -= 1 value = x.value + 1 if cases[y]: x = Int1(value) else: x = Int2(value) return x.value |
self.check_tree_loop_count(2) | if self.optimizer == OPTIMIZER_SIMPLE: self.check_tree_loop_count(1) else: self.check_tree_loop_count(2) | def f(n): node = Node(n) while node.x > 0: myjitdriver.can_enter_jit(node=node) myjitdriver.jit_merge_point(node=node) if node.x < 40: if node.x < 20: node = Node(node.x - 1) node = Node(node.x - 1) node = Node(node.x - 1) return node.x |
self.check_tree_loop_count(2) | if self.optimizer == OPTIMIZER_SIMPLE: self.check_tree_loop_count(1) else: self.check_tree_loop_count(2) | def f(n): while n > 0: myjitdriver.can_enter_jit(n=n) myjitdriver.jit_merge_point(n=n) n -= extern(n).f() return n |
bigvalue = sys.maxint + 17 | bigvalue = r_uint(sys.maxint + 17) | def test_unsigned(self): bigvalue = sys.maxint + 17 def dummy(i): i = r_uint(i) j = r_uint(bigvalue) return i < j |
j = r_uint(bigvalue) | j = bigvalue | def dummy(i): i = r_uint(i) j = r_uint(bigvalue) return i < j |
expected = """ | preamble = """ | def test_remove_duplicate_pure_op_with_descr(self): ops = """ [p1] i0 = arraylen_gc(p1, descr=arraydescr) i1 = int_gt(i0, 0) guard_true(i1) [] i2 = arraylen_gc(p1, descr=arraydescr) i3 = int_gt(i0, 0) guard_true(i3) [] jump(p1) """ expected = """ [p1] i0 = arraylen_gc(p1, descr=arraydescr) i1 = int_gt(i0, 0) guard_true... |
self.optimize_loop(ops, expected) | expected = """ [p1] jump(p1) """ self.optimize_loop(ops, expected, preamble) | def test_remove_duplicate_pure_op_with_descr(self): ops = """ [p1] i0 = arraylen_gc(p1, descr=arraydescr) i1 = int_gt(i0, 0) guard_true(i1) [] i2 = arraylen_gc(p1, descr=arraydescr) i3 = int_gt(i0, 0) guard_true(i3) [] jump(p1) """ expected = """ [p1] i0 = arraylen_gc(p1, descr=arraydescr) i1 = int_gt(i0, 0) guard_true... |
expected = """ | preamble = """ | def test_remove_duplicate_pure_op_ovf(self): ops = """ [i1] i3 = int_add_ovf(i1, 1) guard_no_overflow() [] i3b = int_is_true(i3) guard_true(i3b) [] i4 = int_add_ovf(i1, 1) guard_no_overflow() [] i4b = int_is_true(i4) guard_true(i4b) [] escape(i3) escape(i4) jump(i1) """ expected = """ [i1] i3 = int_add_ovf(i1, 1) guard... |
jump(i1) """ self.optimize_loop(ops, expected) | jump(i1, i3) """ expected = """ [i1, i3] escape(i3) escape(i3) jump(i1, i3) """ self.optimize_loop(ops, expected, preamble) | def test_remove_duplicate_pure_op_ovf(self): ops = """ [i1] i3 = int_add_ovf(i1, 1) guard_no_overflow() [] i3b = int_is_true(i3) guard_true(i3b) [] i4 = int_add_ovf(i1, 1) guard_no_overflow() [] i4b = int_is_true(i4) guard_true(i4b) [] escape(i3) escape(i4) jump(i1) """ expected = """ [i1] i3 = int_add_ovf(i1, 1) guard... |
self.optimize_loop(ops, expected) | self.optimize_loop(ops, expected, expected) | def test_bound_lt_noguard(self): ops = """ [i0] i1 = int_lt(i0, 4) i2 = int_lt(i0, 5) jump(i2) """ expected = """ [i0] i1 = int_lt(i0, 4) i2 = int_lt(i0, 5) jump(i2) """ self.optimize_loop(ops, expected) |
expected = """ | preamble = """ | def test_bound_lt_noopt(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] i2 = int_lt(i0, 5) guard_true(i2) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] i2 = int_lt(i0, 5) guard_true(i2) [] jump(4) """ self.optimize_loop(ops, expected) |
jump(4) """ self.optimize_loop(ops, expected) | jump() """ expected = """ [] jump() """ self.optimize_loop(ops, expected, preamble) | def test_bound_lt_noopt(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] i2 = int_lt(i0, 5) guard_true(i2) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] i2 = int_lt(i0, 5) guard_true(i2) [] jump(4) """ self.optimize_loop(ops, expected) |
expected = """ | preamble = """ | def test_bound_lt_rev(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] i2 = int_gt(i0, 3) guard_true(i2) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] jump(i0) """ self.optimize_loop(ops, expected) |
self.optimize_loop(ops, expected) | expected = """ [i0] jump(i0) """ self.optimize_loop(ops, expected, preamble) | def test_bound_lt_rev(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] i2 = int_gt(i0, 3) guard_true(i2) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_false(i1) [] jump(i0) """ self.optimize_loop(ops, expected) |
expected = """ | preamble = """ | def test_bound_lt_tripple(self): ops = """ [i0] i1 = int_lt(i0, 0) guard_true(i1) [] i2 = int_lt(i0, 7) guard_true(i2) [] i3 = int_lt(i0, 5) guard_true(i3) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 0) guard_true(i1) [] jump(i0) """ self.optimize_loop(ops, expected) |
self.optimize_loop(ops, expected) | expected = """ [i0] jump(i0) """ self.optimize_loop(ops, expected, preamble) | def test_bound_lt_tripple(self): ops = """ [i0] i1 = int_lt(i0, 0) guard_true(i1) [] i2 = int_lt(i0, 7) guard_true(i2) [] i3 = int_lt(i0, 5) guard_true(i3) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 0) guard_true(i1) [] jump(i0) """ self.optimize_loop(ops, expected) |
expected = """ | preamble = """ | def test_bound_lt_add(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add(i0, 10) i3 = int_lt(i2, 15) guard_true(i3) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add(i0, 10) jump(i0) """ self.optimize_loop(ops, expected) |
self.optimize_loop(ops, expected) | expected = """ [i0] jump(i0) """ self.optimize_loop(ops, expected, preamble) | def test_bound_lt_add(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add(i0, 10) i3 = int_lt(i2, 15) guard_true(i3) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add(i0, 10) jump(i0) """ self.optimize_loop(ops, expected) |
expected = """ | preamble = """ | def test_bound_lt_add_before(self): ops = """ [i0] i2 = int_add(i0, 10) i3 = int_lt(i2, 15) guard_true(i3) [] i1 = int_lt(i0, 6) guard_true(i1) [] jump(i0) """ expected = """ [i0] i2 = int_add(i0, 10) i3 = int_lt(i2, 15) guard_true(i3) [] jump(i0) """ self.optimize_loop(ops, expected) |
self.optimize_loop(ops, expected) | expected = """ [i0] jump(i0) """ self.optimize_loop(ops, expected, preamble) | def test_bound_lt_add_before(self): ops = """ [i0] i2 = int_add(i0, 10) i3 = int_lt(i2, 15) guard_true(i3) [] i1 = int_lt(i0, 6) guard_true(i1) [] jump(i0) """ expected = """ [i0] i2 = int_add(i0, 10) i3 = int_lt(i2, 15) guard_true(i3) [] jump(i0) """ self.optimize_loop(ops, expected) |
expected = """ | preamble = """ | def test_bound_lt_add_ovf(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add_ovf(i0, 10) guard_no_overflow() [] i3 = int_lt(i2, 15) guard_true(i3) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add(i0, 10) jump(i0) """ self.optimize_loop(ops, expected) |
self.optimize_loop(ops, expected) | expected = """ [i0] jump(i0) """ self.optimize_loop(ops, expected, preamble) | def test_bound_lt_add_ovf(self): ops = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add_ovf(i0, 10) guard_no_overflow() [] i3 = int_lt(i2, 15) guard_true(i3) [] jump(i0) """ expected = """ [i0] i1 = int_lt(i0, 4) guard_true(i1) [] i2 = int_add(i0, 10) jump(i0) """ self.optimize_loop(ops, expected) |
return space.newbool(self.seekable) | return space.newbool(self.seekable == 1) | def seekable_w(self, space): self._check_closed(space) if self.seekable < 0: try: pos = os.lseek(self.fd, 0, os.SEEK_CUR) except OSError: self.seekable = 0 else: self.seekable = 1 return space.newbool(self.seekable) |
if (!PyErr_Occurred()) Py_RETURN_FALSE; | PyErr_Clear(); | def test_normalize(self): module = self.import_extension('foo', [ ("check_error", "METH_NOARGS", ''' PyObject *type, *val, *tb; PyErr_SetString(PyExc_TypeError, "message"); |
from pypy.rlib import rpoll | def do_poll(self, space, timeout): from pypy.rlib import rpoll if not self._check_fd(): raise OperationError(space.w_IOError, space.wrap( "handle out of range in select()")) | |
if not os.path.isfile(os.path.join(os.path.split(testfile)[0], os.path.split(cmd)[1], test + "-expected.txt")): | if not os.path.isfile(os.path.join(os.path.split(testfile)[0], os.path.split(cmd)[1], test + "-expected" + options.suffix)): | def verify_test(cmd, testfile): basename = os.path.splitext(testfile)[0] path, test = os.path.split(basename) if not options.generate: if not os.path.isfile(os.path.join(os.path.split(testfile)[0], os.path.split(cmd)[1], test + "-expected.txt")): print >> sys.stderr, "Error: test '%s' is missing expected output" % (tes... |
actualfilename = os.path.join(outputdir, test + "-actual.txt") | actualfilename = os.path.join(outputdir, test + "-actual" + options.suffix) | def run_test(cmd, testfile): cmdname = os.path.split(options.cmd)[1] testdir,testname = os.path.split(testfile) test = os.path.splitext(testname)[0] outputdir = os.path.join(os.getcwd(), cmdname) actualfilename = os.path.join(outputdir, test + "-actual.txt") expecteddir = os.path.join(testdir, cmdname) expectedfilenam... |
expectedfilename = os.path.join(expecteddir, test + "-expected.txt") | expectedfilename = os.path.join(expecteddir, test + "-expected" + options.suffix) | def run_test(cmd, testfile): cmdname = os.path.split(options.cmd)[1] testdir,testname = os.path.split(testfile) test = os.path.splitext(testname)[0] outputdir = os.path.join(os.getcwd(), cmdname) actualfilename = os.path.join(outputdir, test + "-actual.txt") expecteddir = os.path.join(testdir, cmdname) expectedfilenam... |
print >> sys.stderr, " -g (--generate) Generate expected output for the given tests " | print >> sys.stderr, " -g, --generate Generate expected output for the given tests " print >> sys.stderr, " -s, --suffix=<suffix> Write -expected and -actual files with the given suffix instead of .txt " | def usage(): print >> sys.stderr, "Usage: " + sys.argv[0] + " [<options>] <cmdline-tool> <argument>" print >> sys.stderr, "Options:" print >> sys.stderr, " -g (--generate) Generate expected output for the given tests " |
opts, args = getopt.getopt(sys.argv[1:], "g", ["generate"]) | opts, args = getopt.getopt(sys.argv[1:], "gs:", ["generate", "suffix="]) | def usage(): print >> sys.stderr, "Usage: " + sys.argv[0] + " [<options>] <cmdline-tool> <argument>" print >> sys.stderr, "Options:" print >> sys.stderr, " -g (--generate) Generate expected output for the given tests " |
if o in ("-s", "--suffix"): if a[0] == '.': options.suffix = "" else: options.suffix = "." options.suffix += a | def usage(): print >> sys.stderr, "Usage: " + sys.argv[0] + " [<options>] <cmdline-tool> <argument>" print >> sys.stderr, "Options:" print >> sys.stderr, " -g (--generate) Generate expected output for the given tests " | |
if self.__class__ == getClass("editors.resourceeditor.ResourceEditor"): | if self.__class__ == getClass("ginkgo.editors.resourceeditor.ResourceEditor"): | def __init__(self, mainWindow=False, resource=None, nepomukType=None): super(ResourceEditor, self).__init__() self.mainWindow = mainWindow self.defaultIcon = ":/nepomuk-large" self.resource = resource self.nepomukType = nepomukType if self.__class__ == getClass("editors.resourceeditor.ResourceEditor"): self.ui = Resou... |
if self.__class__ == getClass("editors.resourceeditor.ResourceEditor"): | if self.__class__ == getClass("ginkgo.editors.resourceeditor.ResourceEditor"): | def save(self): #self.mainWindow.workarea.setCursor(Qt.WaitCursor) self.setCursor(Qt.WaitCursor) if self.resource is None: self.resource = self.mainWindow.createResource(self.ui.resourceLabel(), self.nepomukType) else: #TODO: remove an editor when the edited resource was deleted externally if len(self.resource.types()... |
query = Nepomuk.Query.Query(orTerm) | ttype = Nepomuk.Types.Class(Soprano.Vocabulary.NRL.Ontology()) tterm = Nepomuk.Query.ResourceTypeTerm(ttype) query = Nepomuk.Query.Query(tterm) | def findOntologies(): ontologyType = Nepomuk.Types.Class(Soprano.Vocabulary.NRL.Ontology()) term1 = Nepomuk.Query.ResourceTypeTerm(ontologyType) kbType = Nepomuk.Types.Class(Soprano.Vocabulary.NRL.KnowledgeBase()) term2 = Nepomuk.Query.ResourceTypeTerm(kbType) orTerm = Nepomuk.Query.OrTerm(term1, term2) query = Nep... |
ontology = abbrevToOntology("bibtex") namespace = ontology.property(Soprano.Vocabulary.NAO.hasDefaultNamespace()).toString() print namespace | ontologies = findOntologies() | def slotOntologyUpdateFailed(message, messa): print "failed" |
kurl = KUrl("file:///usr/share/icons/oxygen/48x48/actions/document-edit.png") krun(kurl, self, True) | def newTab(self): """ Create a new tab """ self.addTab(QWidget(), "Ginkgo", True, False) kurl = KUrl("file:///usr/share/icons/oxygen/48x48/actions/document-edit.png") krun(kurl, self, True) | |
self.label.setText(str(self.firstname.text()).strip()+" "+str(self.lastname.text()).strip()) | if not self.labelEdited: self.label.setText(str(self.firstname.text()).strip()+" "+str(self.lastname.text()).strip()) | def nameTextEditedSlot(self, text): self.label.setText(str(self.firstname.text()).strip()+" "+str(self.lastname.text()).strip()) |
if not self.labelEdited and (self.editor.resource is None or len(self.editor.resource.property(Soprano.Vocabulary.NAO.prefLabel()).toString()) == 0): | if self.editor.resource is None or len(self.editor.resource.property(Soprano.Vocabulary.NAO.prefLabel()).toString()) == 0: | def createMainPropertiesWidget(self, parent): |
action.setProperty("key", QVariant(NEW_SUB_TYPE)) | action.setProperty("key", QVariant(NEW_SUBTYPE)) | def createActions(self): if self.selectedUris[0] == PIMO.Thing: action = QAction(i18n("&New type"), self) action.setProperty("key", QVariant(NEW_TYPE)) self.addAction(action) else: action = QAction(i18n("New &instance"), self) action.setProperty("key",QVariant(NEW_INSTANCE)) self.addAction(action) self.addSeparator() s... |
self.parent.processAction(key, self.selectedUris) | self.parent.processAction(key, self.propvalue) | def actionTriggered(self, action): key = action.property("key").toString() self.parent.processAction(key, self.selectedUris) |
places.append(unicode(str(place[index]))) | places.append(unicode(place[index])) | def savePlacesSettings(self, ggroup, index, label): places = QStringList() for place in self.placesData: #place[0] is of type QUrl if index == 0: places.append(unicode(place[index].toString())) else: places.append(unicode(str(place[index]))) ggroup.writeEntry(label, QVariant(places)) |
action = QAction(i18n(text), self) | action = QAction(text, self) | def createAction(self, text, slot=None, shortcut=None, icon=None, tip=None, key=None, iconSize=16, checkable=False, signal="triggered()"): action = QAction(i18n(text), self) if icon is not None: action.setIcon(KIcon(icon)) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(i1... |
action.setToolTip(i18n(tip)) action.setStatusTip(i18n(tip)) | action.setToolTip(tip) action.setStatusTip(tip) | def createAction(self, text, slot=None, shortcut=None, icon=None, tip=None, key=None, iconSize=16, checkable=False, signal="triggered()"): action = QAction(i18n(text), self) if icon is not None: action.setIcon(KIcon(icon)) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(i1... |
settings = QSettings() settings.setValue("Ginkgo/Size", QVariant(self.size())) settings.setValue("Ginkgo/Position", QVariant(self.pos())) settings.setValue("Ginkgo/State", QVariant(self.saveState())) | config = KConfig("ginkgo") ggroup = KConfigGroup(config, "general" ) ggroup.writeEntry( "size", QVariant(self.size() )) ggroup.writeEntry("position", QVariant(self.pos())) ggroup.writeEntry("state", QVariant(self.saveState())) | def saveSettings(self): settings = QSettings() settings.setValue("Ginkgo/Size", QVariant(self.size())) settings.setValue("Ginkgo/Position", QVariant(self.pos())) settings.setValue("Ginkgo/State", QVariant(self.saveState())) currentResourcesUris = QStringList() for i in range(self.workarea.count()): editor = self.workar... |
settings.setValue("Ginkgo/Resources", QVariant(currentResourcesUris)) settings.setValue("Ginkgo/Places", QVariant(self.placesData)) | ggroup.writeEntry("active-resources", QVariant(currentResourcesUris)) ggroup.writeEntry("places", QVariant(self.placesData)) config.sync() | def saveSettings(self): settings = QSettings() settings.setValue("Ginkgo/Size", QVariant(self.size())) settings.setValue("Ginkgo/Position", QVariant(self.pos())) settings.setValue("Ginkgo/State", QVariant(self.saveState())) currentResourcesUris = QStringList() for i in range(self.workarea.count()): editor = self.workar... |
settings = QSettings() size = settings.value("Ginkgo/Size", QVariant(QSize(600, 500))).toSize() | config = KConfig("general") ggroup = KConfigGroup(config, "ginkgo" ) size = ggroup.readEntry("size", QSize(800, 500)).toSize() | def restoreSettings(self): settings = QSettings() size = settings.value("Ginkgo/Size", QVariant(QSize(600, 500))).toSize() self.resize(size) position = settings.value("Ginkgo/Position", QVariant(QPoint(200, 100))).toPoint() self.move(position) self.restoreState(settings.value("Ginkgo/State").toByteArray()) |
position = settings.value("Ginkgo/Position", QVariant(QPoint(200, 100))).toPoint() | position = ggroup.readEntry("position", QPoint(200, 100)).toPoint() | def restoreSettings(self): settings = QSettings() size = settings.value("Ginkgo/Size", QVariant(QSize(600, 500))).toSize() self.resize(size) position = settings.value("Ginkgo/Position", QVariant(QPoint(200, 100))).toPoint() self.move(position) self.restoreState(settings.value("Ginkgo/State").toByteArray()) |
self.restoreState(settings.value("Ginkgo/State").toByteArray()) resourcesUris = settings.value("Ginkgo/Resources").toStringList() | self.restoreState(ggroup.readEntry("state", QByteArray()).toByteArray()) resourcesUris = ggroup.readEntry("active-resources", QStringList()).toStringList() | def restoreSettings(self): settings = QSettings() size = settings.value("Ginkgo/Size", QVariant(QSize(600, 500))).toSize() self.resize(size) position = settings.value("Ginkgo/Position", QVariant(QPoint(200, 100))).toPoint() self.move(position) self.restoreState(settings.value("Ginkgo/State").toByteArray()) |
self.saveSettings() | try: self.saveSettings() except Exception, e: print "[Ginkgo] An error occurred while saving the preferences: '%s.'" % str(e) | def closeEvent(self, event): self.saveSettings() |
places.append(str(place[index].toString())) | places.append(unicode(place[index].toString())) | def savePlacesSettings(self, ggroup, index, label): places = QStringList() for place in self.placesData: #place[0] is of type QUrl if index == 0: places.append(str(place[index].toString())) else: places.append(str(place[index])) ggroup.writeEntry(label, QVariant(places)) |
places.append(str(place[index])) | places.append(unicode(str(place[index]))) | def savePlacesSettings(self, ggroup, index, label): places = QStringList() for place in self.placesData: #place[0] is of type QUrl if index == 0: places.append(str(place[index].toString())) else: places.append(str(place[index])) ggroup.writeEntry(label, QVariant(places)) |
config = KConfig("ginkgo") ggroup = KConfigGroup(config, "general") size = ggroup.readEntry("size", QSize(800, 500)).toSize() self.resize(size) position = ggroup.readEntry("position", QPoint(200, 100)).toPoint() self.move(position) self.restoreState(ggroup.readEntry("state", QByteArray()).toByteArray()) self.descript... | try: config = KConfig("ginkgo") ggroup = KConfigGroup(config, "general") size = ggroup.readEntry("size", QSize(800, 500)).toSize() self.resize(size) position = ggroup.readEntry("position", QPoint(200, 100)).toPoint() self.move(position) self.restoreState(ggroup.readEntry("state", QByteArray()).toByteArray()) self.des... | def restoreSettings(self): config = KConfig("ginkgo") ggroup = KConfigGroup(config, "general") size = ggroup.readEntry("size", QSize(800, 500)).toSize() self.resize(size) position = ggroup.readEntry("position", QPoint(200, 100)).toPoint() self.move(position) self.restoreState(ggroup.readEntry("state", QByteArray()).t... |
print editor | def openResource(self, uri=False, newTab=False, inBackground=True): | |
print className | def openResource(self, uri=False, newTab=False, inBackground=True): | |
print newEditor | def openResource(self, uri=False, newTab=False, inBackground=True): | |
u'Ask "what can you do" to browse my features') | u'Ask "what can you do" to browse my features.') | def _usage_search(self, event, terms, features): terms = frozenset(self.stemmer.stemWord(term) for term in terms) results = set() for name, feat in features.iteritems(): if terms.issubset(feat['usage_keywords']): results.add(name) results = sorted(results) if len(results) == 1: self._describe_feature(event, features[re... |
event.addresponse(u"I'm afraid I don't know what you are asking about" u'Ask "what can you do" to browse my features') | event.addresponse(u"I'm afraid I don't know what you are asking about. " u'Ask "what can you do" to browse my features.') | def describe_category(self, event, terms): categories, features = self._get_features() termset = frozenset(self.stemmer.stemWord(term) for term in terms.lower().split()) |
@match(r'^airports?\s+(in\s+)?(.+)$') | @match(r'^airports?\s+((?:in|for)\s+)?(.+)$') | def repr_airport(id): airport = airports[id] code = '' if airport[3] or airport[4]: code = ' (%s)' % u'/'.join(filter(lambda c: c, airport[3:5])) return '%s%s' % (airport[0], code) |
if isinstance(response, basestring): response = {'reply': response, 'target': event.redirect_target} if 'redirect_source' in event: response['source'] = event.redirect_source | response['target'] = event.redirect_target if 'redirect_source' in event: response['source'] = event.redirect_source | def redirect(self, event): if 'redirect_target' in event: responses = [] for response in event.responses: if isinstance(response, basestring): response = {'reply': response, 'target': event.redirect_target} if 'redirect_source' in event: response['source'] = event.redirect_source responses.append(response) event.respon... |
class Exchange(Processor): usage = u"""have <object> | class ExchangeAction(Processor): feature = ('exchange',) event_types = (u'action',) addressed = False @match(r"^gives\s+(\S+)\s+" r"(?:(his|her|my|\S+(?:'s|s')|the|a|an|this|these)\s+)?(.*)$") def give(self, event, addressee, determiner, object): if addressee in ibid.config.plugins['core']['names']: return exchange(e... | def swear(self, event, insultee): swearage = [] for i in range(self.swearlength): if random() > 0.7: swearage.append(choice(self.loneadjectives)) else: swearage.append(choice(self.swearnouns) + choice(self.swearadjectives)) if insultee is not None: swearage.append(insultee) else: swearage.append(choice(self.swearnouns)... |
addressed = False event_types = (u'message', u'action') def setup (self): self.carrying = None @match(r"^gives\s+(\S+)\s+(?:(his|her|my|\S+(?:'s|s')|the|a|an|this|these)\s+)?(.*)$") def give(self, event, addressee, determiner, object): if addressee in ibid.config.plugins['core']['names'] or event.type == 'message': r... | @match(r"^(?:have|take)\s+" r"(?:(his|her|my|\S+(?:'s|s')|the|a|an|this|these)\s+)?(.*)$") | def swear(self, event, insultee): swearage = [] for i in range(self.swearlength): if random() > 0.7: swearage.append(choice(self.loneadjectives)) else: swearage.append(choice(self.swearnouns) + choice(self.swearadjectives)) if insultee is not None: swearage.append(insultee) else: swearage.append(choice(self.swearnouns)... |
if event.type == 'action' or \ event.message['deaddressed'] == event.message['raw']: return False return self.exchange(event, determiner, object) def exchange(self, event, determiner, object): who = event.sender['nick'] if determiner is None: determiner = '' if determiner == 'the': taken = u'the ' + object elif "'" i... | return exchange(event, determiner, object) | def have(self, event, determiner, object): if event.type == 'action' or \ event.message['deaddressed'] == event.message['raw']: return False return self.exchange(event, determiner, object) |
if event.type == 'action' or \ event.message['deaddressed'] == event.message['raw']: return False if self.carrying is None: | carrying_lock.acquire() if carrying is None: | def query_carrying(self, event): if event.type == 'action' or \ event.message['deaddressed'] == event.message['raw']: return False |
event.addresponse(u"I'm carrying %s", self.carrying) | event.addresponse(u"I'm carrying %s", carrying) carrying_lock.release() def exchange(event, determiner, object): global carrying, carrying_lock who = event.sender['nick'] if determiner is None: determiner = '' if determiner == 'the': taken = u'the ' + object elif "'" in determiner: taken = determiner + ' ' + object... | def query_carrying(self, event): if event.type == 'action' or \ event.message['deaddressed'] == event.message['raw']: return False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.