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 ValueError: return False def restore_magic(saved): if saved: py.magic.invoke(assertion=True)
|
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( "negative file descriptor"))
|
[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 = AddressStack() self.walk(pendingroots) pendingroots.delete() self.write_marker()
|
|
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, functionlines functionlines = [] in_function = True functionlines.append(line) if functionlines: yield in_function, functionlines def process_function(self, lines, entrypoint, filename): entrypoint = '_' + entrypoint return super(DarwinAssemblerParser, self).process_function( lines, entrypoint, filename) class DarwinAssemblerParser64(DarwinAssemblerParser): format = "darwin64" FunctionGcRootTracker = DarwinFunctionGcRootTracker64 class Mingw32AssemblerParser(DarwinAssemblerParser): format = "mingw32" FunctionGcRootTracker = Mingw32FunctionGcRootTracker def find_functions(self, iterlines): functionlines = [] in_text = False in_function = False for n, line in enumerate(iterlines): if self.r_textstart.match(line):
|
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, functionlines functionlines = [] in_text = False in_function = False elif in_text and self.FunctionGcRootTracker.r_functionstart.match(line): yield in_function, functionlines functionlines = [] in_function = True functionlines.append(line)
|
|
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 MAX_EXP = 128 # FLT_MAX_EXP MANT_DIG = 24 # FLT_MANT_DIG BITS = 32 else: raise ValueError("invalid size value") if not objectmodel.we_are_translated(): # This tests generates wrong code when translated: # with gcc, shifting a 64bit int by 64 bits does # not change the value. if Q >> BITS: raise ValueError("input out of range") # extract pieces one = r_ulonglong(1) sign = rarithmetic.intmask(Q >> BITS - 1) exp = rarithmetic.intmask((Q & ((one << BITS - 1) - (one << MANT_DIG - 1))) >> MANT_DIG - 1) mant = Q & ((1 << MANT_DIG - 1) - 1) if exp == MAX_EXP - MIN_EXP + 2: # nan or infinity result = float('nan') if mant else float('inf') elif exp == 0: # subnormal or zero result = math.ldexp(mant, MIN_EXP - MANT_DIG) else: # normal mant += 1 << MANT_DIG - 1 result = math.ldexp(mant, exp + MIN_EXP - MANT_DIG - 1) return -result if sign else result
|
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 MAX_EXP = 128 # FLT_MAX_EXP MANT_DIG = 24 # FLT_MANT_DIG BITS = 32 else: raise ValueError("invalid size value") if not objectmodel.we_are_translated(): # This tests generates wrong code when translated: # with gcc, shifting a 64bit int by 64 bits does # not change the value. if Q >> BITS: raise ValueError("input out of range") # extract pieces one = r_ulonglong(1) sign = rarithmetic.intmask(Q >> BITS - 1) exp = rarithmetic.intmask((Q & ((one << BITS - 1) - (one << MANT_DIG - 1))) >> MANT_DIG - 1) mant = Q & ((1 << MANT_DIG - 1) - 1) if exp == MAX_EXP - MIN_EXP + 2: # nan or infinity result = float('nan') if mant else float('inf') elif exp == 0: # subnormal or zero result = math.ldexp(mant, MIN_EXP - MANT_DIG) else: # normal mant += 1 << MANT_DIG - 1 result = math.ldexp(mant, exp + MIN_EXP - MANT_DIG - 1) return -result if sign else result
|
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_guard_recovery(guard_opnum, faildescr, failargs, faillocs) if op is None: dispatch_opnum = guard_opnum else: dispatch_opnum = op.getopnum() res = genop_guard_list[dispatch_opnum](self, op, guard_op, guard_token, arglocs, resloc) faildescr._x86_adr_jump_offset = res
|
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_rev_cond) else: self.mc.CMP(arglocs[0], arglocs[1]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, cond) else: return self.implement_guard(guard_token, false_cond)
|
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_rev_cond) else: self.mc.CMP(arglocs[0], arglocs[1]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, cond) else: return self.implement_guard(guard_token, false_cond)
|
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_rev_cond) else: self.mc.CMP(arglocs[0], arglocs[1]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, cond) else: return self.implement_guard(guard_token, false_cond)
|
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_rev_cond) else: self.mc.CMP(arglocs[0], arglocs[1]) if guard_opnum == rop.GUARD_FALSE: return self.implement_guard(guard_token, cond) else: return self.implement_guard(guard_token, false_cond)
|
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_opnum == rop.GUARD_FALSE: if need_jp: self.mc.J_il8(rx86.Conditions['P'], 6) return self.implement_guard(guard_token, cond) else: if need_jp: self.mc.J_il8(rx86.Conditions['P'], 2) self.mc.J_il8(rx86.Conditions[cond], 5) return self.implement_guard(guard_token) return self.implement_guard(guard_token, false_cond)
|
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_opnum == rop.GUARD_FALSE: if need_jp: self.mc.J_il8(rx86.Conditions['P'], 6) return self.implement_guard(guard_token, cond) else: if need_jp: self.mc.J_il8(rx86.Conditions['P'], 2) self.mc.J_il8(rx86.Conditions[cond], 5) return self.implement_guard(guard_token) return self.implement_guard(guard_token, false_cond)
|
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_opnum == rop.GUARD_TRUE: self.mc.J_il8(rx86.Conditions['P'], 6) return self.implement_guard(guard_token, 'E') else: self.mc.J_il8(rx86.Conditions['P'], 2) self.mc.J_il8(rx86.Conditions['E'], 5) return self.implement_guard(guard_token)
|
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_opnum == rop.GUARD_TRUE: self.mc.J_il8(rx86.Conditions['P'], 6) return self.implement_guard(guard_token, 'E') else: self.mc.J_il8(rx86.Conditions['P'], 2) self.mc.J_il8(rx86.Conditions['E'], 5) return self.implement_guard(guard_token)
|
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(heap(self.cpu.pos_exception()), imm0) self.mc.MOV(heap(self.cpu.pos_exc_value()), imm0) return addr
|
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(heap(self.cpu.pos_exception()), imm0) self.mc.MOV(heap(self.cpu.pos_exc_value()), imm0) return addr
|
|
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_op.getopname())
|
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_op.getopname())
|
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_relative_pos() - jb_location assert 0 < offset <= 127 self.mc.overwrite(jb_location-1, [chr(offset)]) # return self.implement_guard(guard_token, 'NE')
|
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.mc.JMP_l(self.mc.tell()) return self.mc.tell() - 4
|
|
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.mc.JMP_l(self.mc.tell()) return self.mc.tell() - 4
|
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(guard_token, 'L')
|
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_arglocs[0]) # # Write a call to the direct_bootstrap_code of the target assembler self._emit_call(imm(descr._x86_direct_bootstrap_code), arglocs, 2, tmp=eax) self.mc.ensure_bytes_available(256) if op.result is None: assert result_loc is None value = self.cpu.done_with_this_frame_void_v else: kind = op.result.type if kind == INT: assert result_loc is eax value = self.cpu.done_with_this_frame_int_v elif kind == REF: assert result_loc is eax value = self.cpu.done_with_this_frame_ref_v elif kind == FLOAT: value = self.cpu.done_with_this_frame_float_v else: raise AssertionError(kind) self.mc.CMP_ri(eax.value, value) # patched later self.mc.J_il8(rx86.Conditions['E'], 0) # goto B if we get 'done_with_this_frame' je_location = self.mc.get_relative_pos() # # Path A: use assembler_helper_adr jd = descr.outermost_jitdriver_sd assert jd is not None asm_helper_adr = self.cpu.cast_adr_to_int(jd.assembler_helper_adr) self._emit_call(imm(asm_helper_adr), [eax, arglocs[1]], 0, tmp=ecx) if IS_X86_32 and isinstance(result_loc, StackLoc) and result_loc.type == FLOAT: self.mc.FSTP_b(result_loc.value) #else: result_loc is already either eax or None, checked below self.mc.JMP_l8(0) # jump to done, patched later jmp_location = self.mc.get_relative_pos() # # Path B: fast path. Must load the return value, and reset the token offset = jmp_location - je_location assert 0 < offset <= 127 self.mc.overwrite(je_location - 1, [chr(offset)]) # # Reset the vable token --- XXX really too much special logic here:-( if jd.index_of_virtualizable >= 0: from pypy.jit.backend.llsupport.descr import BaseFieldDescr fielddescr = jd.vable_token_descr assert isinstance(fielddescr, BaseFieldDescr) ofs = fielddescr.offset self.mc.MOV(eax, arglocs[1]) self.mc.MOV_mi((eax.value, ofs), 0) # in the line above, TOKEN_NONE = 0 # if op.result is not None: # load the return value from fail_boxes_xxx[0] kind = op.result.type if kind == FLOAT: xmmtmp = X86XMMRegisterManager.all_regs[0] adr = self.fail_boxes_float.get_addr_for_num(0) self.mc.MOVSD(xmmtmp, heap(adr)) self.mc.MOVSD(result_loc, xmmtmp) else: assert result_loc is eax if kind == INT: adr = self.fail_boxes_int.get_addr_for_num(0) self.mc.MOV(eax, heap(adr)) elif kind == REF: adr = self.fail_boxes_ptr.get_addr_for_num(0) self.mc.XOR_rr(eax.value, eax.value) self.mc.XCHG(eax, heap(adr)) else: raise AssertionError(kind) # # Here we join Path A and Path B again offset = self.mc.get_relative_pos() - jmp_location assert 0 <= offset <= 127 self.mc.overwrite(jmp_location - 1, [chr(offset)]) self.mc.CMP_bi(FORCE_INDEX_OFS, 0) return self.implement_guard(guard_token, 'L')
|
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(i1) [] jump(p1) """ self.optimize_loop(ops, expected)
|
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(i1) [] jump(p1) """ self.optimize_loop(ops, expected)
|
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_no_overflow() [] i3b = int_is_true(i3) guard_true(i3b) [] escape(i3) escape(i3) jump(i1) """ self.optimize_loop(ops, expected)
|
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_no_overflow() [] i3b = int_is_true(i3) guard_true(i3b) [] escape(i3) escape(i3) jump(i1) """ self.optimize_loop(ops, expected)
|
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" % (test,) return False return True
|
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) expectedfilename = os.path.join(expecteddir, test + "-expected.txt") if options.generate: if not os.path.exists(expecteddir): os.makedirs(expecteddir) outputname = expectedfilename else: if not os.path.exists(outputdir): os.makedirs(outputdir) outputname = actualfilename outfile = open(outputname, "wb") proc = subprocess.Popen([cmd, testfile], stdout=outfile, stderr=subprocess.PIPE) errtext = proc.communicate()[1] if errtext != None and len(errtext) > 0: print >> sys.stderr, "Error output: " + errtext outfile.close() if proc.returncode != 0: print >> sys.stderr, "Error: %s failed with return code %d" % (cmdname, proc.returncode) return False if not options.generate: if not compare_text(expectedfilename, actualfilename): execute_and_redirect("diff", [expectedfilename, actualfilename], sys.stderr) return False return True
|
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) expectedfilename = os.path.join(expecteddir, test + "-expected.txt") if options.generate: if not os.path.exists(expecteddir): os.makedirs(expecteddir) outputname = expectedfilename else: if not os.path.exists(outputdir): os.makedirs(outputdir) outputname = actualfilename outfile = open(outputname, "wb") proc = subprocess.Popen([cmd, testfile], stdout=outfile, stderr=subprocess.PIPE) errtext = proc.communicate()[1] if errtext != None and len(errtext) > 0: print >> sys.stderr, "Error output: " + errtext outfile.close() if proc.returncode != 0: print >> sys.stderr, "Error: %s failed with return code %d" % (cmdname, proc.returncode) return False if not options.generate: if not compare_text(expectedfilename, actualfilename): execute_and_redirect("diff", [expectedfilename, actualfilename], sys.stderr) return False return True
|
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 = ResourceEditorUi(self)
|
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()) == 0: self.resource = self.mainWindow.createResource(self.ui.resourceLabel(), self.nepomukType) self.ui.relationsTable.setResource(self.resource) self.ui.propsTable.setResource(self.resource) #save generic properties self.resource.setLabel(self.ui.resourceLabel()) self.resource.setDescription(self.ui.description.toPlainText()) #update the fields only if we are in a resourceeditor, otherwise, update the fields only in the sublcass if self.__class__ == getClass("editors.resourceeditor.ResourceEditor"): self.ui.updateFields() self.unsetCursor()
|
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 = Nepomuk.Query.Query(orTerm) sparql = query.toSparqlQuery() ontologies = sparqlToResources(sparql) tmparray = [] for ontology in ontologies: abbrev = ontology.property(Soprano.Vocabulary.NAO.hasDefaultNamespaceAbbreviation()).toString() if len(abbrev) == 0: abbrev = ontology.resourceUri().toString() tmparray.append((ontology, abbrev)) sortedOntologies = sorted(tmparray, key=lambda tuple: tuple[1]) ontologies = [] for elt in sortedOntologies: ontologies.append(elt[0]) return ontologies
|
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() self.addOpenAction() action = QAction(i18n("&Add to places"), self) action.setProperty("key",QVariant(ADD_TO_PLACES)) self.addAction(action) nodeClass = Nepomuk.Types.Class(self.selectedUris[0]) pimoThingClass = Nepomuk.Types.Class(PIMO.Thing) if nodeClass.isSubClassOf(pimoThingClass): self.addSeparator() action = QAction(i18n("&New sub-type"), self) action.setProperty("key", QVariant(NEW_SUB_TYPE)) self.addAction(action)
|
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(i18n(tip)) action.setStatusTip(i18n(tip)) if slot is not None: self.connect(action, SIGNAL(signal), slot)
|
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(i18n(tip)) action.setStatusTip(i18n(tip)) if slot is not None: self.connect(action, SIGNAL(signal), slot)
|
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.workarea.widget(i) if hasattr(editor, "resource") and editor.resource: currentResourcesUris.append(editor.resource.resourceUri().toString()) settings.setValue("Ginkgo/Resources", QVariant(currentResourcesUris)) settings.setValue("Ginkgo/Places", QVariant(self.placesData))
|
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.workarea.widget(i) if hasattr(editor, "resource") and editor.resource: currentResourcesUris.append(editor.resource.resourceUri().toString()) settings.setValue("Ginkgo/Resources", QVariant(currentResourcesUris)) settings.setValue("Ginkgo/Places", QVariant(self.placesData))
|
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.descriptionSplitterState = ggroup.readEntry("description-splitter-state", QByteArray()).toByteArray() resourcesUris = ggroup.readEntry("active-resources", QStringList()).toStringList() for uri in resourcesUris: self.openResource(uri, True, True)
|
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.descriptionSplitterState = ggroup.readEntry("description-splitter-state", QByteArray()).toByteArray() resourcesUris = ggroup.readEntry("active-resources", QStringList()).toStringList() for uri in resourcesUris: self.openResource(uri, True, True) except Exception, e: print "[Ginkgo] An error occurred while restoring the settings: '%s'." % str(e)
|
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()).toByteArray()) self.descriptionSplitterState = ggroup.readEntry("description-splitter-state", QByteArray()).toByteArray() resourcesUris = ggroup.readEntry("active-resources", QStringList()).toStringList() for uri in resourcesUris: self.openResource(uri, True, True)
|
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[results[0]]) elif len(results) > 1: event.addresponse( u"Please be more specific. I don't know if you mean %s", human_join((features[result]['name'] for result in results), conjunction=u'or')) else: 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')
|
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.responses = responses
|
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(event, determiner, object) class ExchangeMessage(Processor): usage = u"""(have|take) <object>
|
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': return self.exchange(event, determiner, object) @match(r"^have\s+(?:(his|her|my|\S+(?:'s|s')|the|a|an|this|these)\s+)?(.*)$")
|
@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 "'" in determiner: taken = determiner + ' ' + object else: taken = u"%(who)s's %(object)s" % {'who': who, 'object': object} if self.carrying is None: event.addresponse(u'takes %s but has nothing to give in exchange', taken, action=True) else: event.addresponse(u'hands %(who)s %(carrying)s ' u'in exchange for %(taken)s', {'who': who, 'carrying': self.carrying, 'taken': taken}, action=True) if determiner == 'this': determiner = indefinite_article(object) if "'" in determiner or determiner in ('a', 'an', 'the'): self.carrying = determiner + ' ' + object else: self.carrying = object
|
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 else: taken = u"%(who)s's %(object)s" % {'who': who, 'object': object} carrying_lock.acquire() if carrying is None: event.addresponse(u'takes %s but has nothing to give in exchange', taken, action=True) else: event.addresponse(u'hands %(who)s %(carrying)s ' u'in exchange for %(taken)s', {'who': who, 'carrying': carrying, 'taken': taken}, action=True) if determiner == 'this': determiner = indefinite_article(object) elif determiner in ('my', 'his', 'her'): determiner = who + "'s" if determiner not in ('this', 'these'): carrying = determiner + ' ' + object else: carrying = object carrying_lock.release()
|
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.