static PyObject * advisory_richcompare(PyObject *self, PyObject *other, int op) { PyObject *result; HifAdvisory *cself, *cother; if (!advisory_converter(self, &cself) || !advisory_converter(other, &cother)) { if(PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } int identical = hif_advisory_compare(cself, cother); switch (op) { case Py_EQ: result = TEST_COND(identical); break; case Py_NE: result = TEST_COND(!identical); break; case Py_LE: case Py_GE: case Py_LT: case Py_GT: result = Py_NotImplemented; break; default: PyErr_BadArgument(); return NULL; } Py_INCREF(result); return result; }
static PyObject * cell_richcompare(PyObject *a, PyObject *b, int op) { int result; PyObject *v; /* neither argument should be NULL, unless something's gone wrong */ assert(a != NULL && b != NULL); /* both arguments should be instances of PyCellObject */ if (!PyCell_Check(a) || !PyCell_Check(b)) { v = Py_NotImplemented; Py_INCREF(v); return v; } /* compare cells by contents; empty cells come before anything else */ a = ((PyCellObject *)a)->ob_ref; b = ((PyCellObject *)b)->ob_ref; if (a != NULL && b != NULL) return PyObject_RichCompare(a, b, op); result = (b == NULL) - (a == NULL); switch (op) { case Py_EQ: v = TEST_COND(result == 0); break; case Py_NE: v = TEST_COND(result != 0); break; case Py_LE: v = TEST_COND(result <= 0); break; case Py_GE: v = TEST_COND(result >= 0); break; case Py_LT: v = TEST_COND(result < 0); break; case Py_GT: v = TEST_COND(result > 0); break; default: PyErr_BadArgument(); return NULL; } Py_INCREF(v); return v; }
static PyObject * nevra_richcompare(PyObject *self, PyObject *other, int op) { PyObject *v; Nevra *other_nevra, *self_nevra; other_nevra = nevraFromPyObject(other); self_nevra = nevraFromPyObject(self); if (!other_nevra) { if(PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } long result = self_nevra->compare(*other_nevra); switch (op) { case Py_EQ: v = TEST_COND(result == 0); break; case Py_NE: v = TEST_COND(result != 0); break; case Py_LE: v = TEST_COND(result <= 0); break; case Py_GE: v = TEST_COND(result >= 0); break; case Py_LT: v = TEST_COND(result < 0); break; case Py_GT: v = TEST_COND(result > 0); break; default: PyErr_BadArgument(); return NULL; } Py_INCREF(v); return v; }
PyObject * package_py_richcompare(PyObject *self, PyObject *other, int op) { PyObject *v; HyPackage self_package, other_package; if (!package_converter(self, &self_package) || !package_converter(other, &other_package)) { if(PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } long result = hy_package_cmp(self_package, other_package); switch (op) { case Py_EQ: v = TEST_COND(result == 0); break; case Py_NE: v = TEST_COND(result != 0); break; case Py_LE: v = TEST_COND(result <= 0); break; case Py_GE: v = TEST_COND(result >= 0); break; case Py_LT: v = TEST_COND(result < 0); break; case Py_GT: v = TEST_COND(result > 0); break; default: PyErr_BadArgument(); return NULL; } Py_INCREF(v); return v; }
u32 armcpu_exec() { // Usually, fetching and executing are processed parallelly. // So this function stores the cycles of each process to // the variables below, and returns appropriate cycle count. u32 cFetch = 0; u32 cExecute = 0; //this assert is annoying. but sometimes it is handy. //assert(ARMPROC.instruct_adr!=0x00000000); //#ifdef DEVELOPER #if 0 if ((((ARMPROC.instruct_adr & 0x0F000000) == 0x0F000000) && (PROCNUM == 0)) || (((ARMPROC.instruct_adr & 0x0F000000) == 0x00000000) && (PROCNUM == 1))) { switch (ARMPROC.instruct_adr & 0xFFFF) { case 0x00000000: printf("BIOS%c: Reset!!!\n", PROCNUM?'7':'9'); emu_halt(); break; case 0x00000004: printf("BIOS%c: Undefined instruction\n", PROCNUM?'7':'9'); //emu_halt(); break; case 0x00000008: //printf("BIOS%c: SWI\n", PROCNUM?'7':'9'); break; case 0x0000000C: printf("BIOS%c: Prefetch Abort!!!\n", PROCNUM?'7':'9'); //emu_halt(); break; case 0x00000010: //printf("BIOS%c: Data Abort!!!\n", PROCNUM?'7':'9'); //emu_halt(); break; case 0x00000014: printf("BIOS%c: Reserved!!!\n", PROCNUM?'7':'9'); break; case 0x00000018: //printf("BIOS%c: IRQ\n", PROCNUM?'7':'9'); break; case 0x0000001C: printf("BIOS%c: Fast IRQ\n", PROCNUM?'7':'9'); break; } } #endif #if 0 //#ifdef GDB_STUB if (ARMPROC.stalled) { return STALLED_CYCLE_COUNT; } /* check for interrupts */ if (ARMPROC.irq_flag) { armcpu_irqException(&ARMPROC); } cFetch = armcpu_prefetch(&ARMPROC); if (ARMPROC.stalled) { return MMU_fetchExecuteCycles<PROCNUM>(cExecute, cFetch); } #endif //cFetch = armcpu_prefetch(&ARMPROC); //printf("%d: %08X\n",PROCNUM,ARMPROC.instruct_adr); if(ARMPROC.CPSR.bits.T == 0) { const u32 condition = CONDITION(ARMPROC.instruction); if( condition == 0x0E //fast path for unconditional instructions || (TEST_COND(condition, CODE(ARMPROC.instruction), ARMPROC.CPSR)) //handles any condition ) { #ifdef HAVE_LUA CallRegisteredLuaMemHook(ARMPROC.instruct_adr, 4, ARMPROC.instruction, LUAMEMHOOK_EXEC); // should report even if condition=false? #endif if(PROCNUM==0) { #ifdef DEVELOPER DEBUG_statistics.instructionHits[0].arm[INSTRUCTION_INDEX(ARMPROC.instruction)]++; #endif cExecute = arm_instructions_set_0[INSTRUCTION_INDEX(ARMPROC.instruction)](ARMPROC.instruction); } else { #ifdef DEVELOPER DEBUG_statistics.instructionHits[1].arm[INSTRUCTION_INDEX(ARMPROC.instruction)]++; #endif cExecute = arm_instructions_set_1[INSTRUCTION_INDEX(ARMPROC.instruction)](ARMPROC.instruction); } } else cExecute = 1; // If condition=false: 1S cycle #ifdef GDB_STUB if ( ARMPROC.post_ex_fn != NULL) { /* call the external post execute function */ ARMPROC.post_ex_fn(ARMPROC.post_ex_fn_data, ARMPROC.instruct_adr, 0); } ARMPROC.mem_if->prefetch32( ARMPROC.mem_if->data, ARMPROC.next_instruction); #endif cFetch = armcpu_prefetch<PROCNUM>(); return MMU_fetchExecuteCycles<PROCNUM>(cExecute, cFetch); } #ifdef HAVE_LUA CallRegisteredLuaMemHook(ARMPROC.instruct_adr, 2, ARMPROC.instruction, LUAMEMHOOK_EXEC); #endif if(PROCNUM==0) { #ifdef DEVELOPER DEBUG_statistics.instructionHits[0].thumb[ARMPROC.instruction>>6]++; #endif cExecute = thumb_instructions_set_0[ARMPROC.instruction>>6](ARMPROC.instruction); }