MagickImage* ProcessImage::transition(const MagickImage& from, const MagickImage& to, int type, int step, int steps) { int w, h; if (step < 0 || step >= steps) { Q_EMIT signalProcessError(QString("step: %1 is out of range (%2)").arg(step).arg(steps)); return 0; } // create a new target image and copy the from image onto MagickImage* const dst = m_api->createImage("black", w = from.getWidth(), h = from.getHeight()); if (!dst) { return 0; } switch (type) { // sliding case TRANSITION_TYPE_SLIDE_L2R: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, DEC(-w), 0, to); break; case TRANSITION_TYPE_SLIDE_R2L: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, DEC(w), 0, to); break; case TRANSITION_TYPE_SLIDE_T2B: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, 0, DEC(-h), to); break; case TRANSITION_TYPE_SLIDE_B2T: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, 0, DEC(h), to); break; // pushing case TRANSITION_TYPE_PUSH_L2R: m_api->overlayImage(*dst, INC(w), 0, from); m_api->overlayImage(*dst, DEC(-w), 0, to); break; case TRANSITION_TYPE_PUSH_R2L: m_api->overlayImage(*dst, INC(-w), 0, from); m_api->overlayImage(*dst, DEC(w), 0, to); break; case TRANSITION_TYPE_PUSH_T2B: m_api->overlayImage(*dst, 0, INC(h), from); m_api->overlayImage(*dst, 0, DEC(-h), to); break; case TRANSITION_TYPE_PUSH_B2T: m_api->overlayImage(*dst, 0, INC(-h), from); m_api->overlayImage(*dst, 0, DEC(h), to); break; // swapping case TRANSITION_TYPE_SWAP_L2R: if (step < steps / 2) { m_api->overlayImage(*dst, INC(w), 0, to); m_api->overlayImage(*dst, INC(-w), 0, from); } else { m_api->overlayImage(*dst, DEC(-w), 0, from); m_api->overlayImage(*dst, DEC(w), 0, to); } break; case TRANSITION_TYPE_SWAP_R2L: if (step < steps / 2) { m_api->overlayImage(*dst, INC(-w), 0, to); m_api->overlayImage(*dst, INC(w), 0, from); } else { m_api->overlayImage(*dst, DEC(w), 0, from); m_api->overlayImage(*dst, DEC(-w), 0, to); } break; case TRANSITION_TYPE_SWAP_T2B: if (step < steps / 2) { m_api->overlayImage(*dst, 0, INC(h), to); m_api->overlayImage(*dst, 0, INC(-h), from); } else { m_api->overlayImage(*dst, 0, DEC(-h), from); m_api->overlayImage(*dst, 0, DEC(h), to); } break; case TRANSITION_TYPE_SWAP_B2T: if (step < steps / 2) { m_api->overlayImage(*dst, 0, INC(-h), to); m_api->overlayImage(*dst, 0, INC(h), from); } else { m_api->overlayImage(*dst, 0, DEC(h), from); m_api->overlayImage(*dst, 0, DEC(-h), to); } break; // rolling case TRANSITION_TYPE_ROLL_L2R: if (INC(w)) m_api->scaleblitImage(*dst, 0, 0, INC(w), h, to, 0, 0, w, h); if (DEC(w)) m_api->scaleblitImage(*dst, INC(w), 0, DEC(w), h, from, 0, 0, w, h); break; case TRANSITION_TYPE_ROLL_R2L: if (DEC(w)) m_api->scaleblitImage(*dst, 0, 0, DEC(w), h, from, 0, 0, w, h); if (INC(w)) m_api->scaleblitImage(*dst, DEC(w), 0, INC(w), h, to, 0, 0, w, h); break; case TRANSITION_TYPE_ROLL_T2B: if (INC(h)) m_api->scaleblitImage(*dst, 0, 0, w, INC(h), to, 0, 0, w, h); if (DEC(h)) m_api->scaleblitImage(*dst, 0, INC(h), w, DEC(h), from, 0, 0, w, h); break; case TRANSITION_TYPE_ROLL_B2T: if (DEC(h)) m_api->scaleblitImage(*dst, 0, 0, w, DEC(h), from, 0, 0, w, h); if (INC(h)) m_api->scaleblitImage(*dst, 0, DEC(h), w, INC(h), to, 0, 0, w, h); break; // fade case TRANSITION_TYPE_FADE: default: m_api->blendImage(*dst, from, to, 1.0 / steps * step); break; } return dst; }
void* child_fn ( void* arg ) { INC(x, "childfn"); return NULL; }
void chk_trj(const gmx_output_env_t *oenv, const char *fn, const char *tpr, real tol) { t_trxframe fr; t_count count; t_fr_time first, last; int j = -1, new_natoms, natoms; real old_t1, old_t2; gmx_bool bShowTimestep = TRUE, newline = FALSE; t_trxstatus *status; gmx_mtop_t mtop; gmx_localtop_t *top = NULL; t_state state; t_inputrec *ir; gmx::MDModules mdModules; ir = mdModules.inputrec(); if (tpr) { read_tpx_state(tpr, ir, &state, &mtop); top = gmx_mtop_generate_local_top(&mtop, ir->efep != efepNO); } new_natoms = -1; natoms = -1; printf("Checking file %s\n", fn); j = 0; old_t2 = -2.0; old_t1 = -1.0; count.bStep = 0; count.bTime = 0; count.bLambda = 0; count.bX = 0; count.bV = 0; count.bF = 0; count.bBox = 0; first.bStep = 0; first.bTime = 0; first.bLambda = 0; first.bX = 0; first.bV = 0; first.bF = 0; first.bBox = 0; last.bStep = 0; last.bTime = 0; last.bLambda = 0; last.bX = 0; last.bV = 0; last.bF = 0; last.bBox = 0; read_first_frame(oenv, &status, fn, &fr, TRX_READ_X | TRX_READ_V | TRX_READ_F); do { if (j == 0) { fprintf(stderr, "\n# Atoms %d\n", fr.natoms); if (fr.bPrec) { fprintf(stderr, "Precision %g (nm)\n", 1/fr.prec); } } newline = TRUE; if ((natoms > 0) && (new_natoms != natoms)) { fprintf(stderr, "\nNumber of atoms at t=%g don't match (%d, %d)\n", old_t1, natoms, new_natoms); newline = FALSE; } if (j >= 2) { if (fabs((fr.time-old_t1)-(old_t1-old_t2)) > 0.1*(fabs(fr.time-old_t1)+fabs(old_t1-old_t2)) ) { bShowTimestep = FALSE; fprintf(stderr, "%sTimesteps at t=%g don't match (%g, %g)\n", newline ? "\n" : "", old_t1, old_t1-old_t2, fr.time-old_t1); } } natoms = new_natoms; if (tpr) { chk_bonds(&top->idef, ir->ePBC, fr.x, fr.box, tol); } if (fr.bX) { chk_coords(j, natoms, fr.x, fr.box, 1e5, tol); } if (fr.bV) { chk_vels(j, natoms, fr.v); } if (fr.bF) { chk_forces(j, natoms, fr.f); } old_t2 = old_t1; old_t1 = fr.time; j++; new_natoms = fr.natoms; #define INC(s, n, f, l, item) if (s.item != 0) { if (n.item == 0) { first.item = fr.time; } last.item = fr.time; n.item++; \ } INC(fr, count, first, last, bStep); INC(fr, count, first, last, bTime); INC(fr, count, first, last, bLambda); INC(fr, count, first, last, bX); INC(fr, count, first, last, bV); INC(fr, count, first, last, bF); INC(fr, count, first, last, bBox); #undef INC } while (read_next_frame(oenv, status, &fr)); fprintf(stderr, "\n"); close_trj(status); fprintf(stderr, "\nItem #frames"); if (bShowTimestep) { fprintf(stderr, " Timestep (ps)"); } fprintf(stderr, "\n"); #define PRINTITEM(label, item) fprintf(stderr, "%-10s %6d", label, count.item); if ((bShowTimestep) && (count.item > 1)) {fprintf(stderr, " %g\n", (last.item-first.item)/(count.item-1)); }else fprintf(stderr, "\n") PRINTITEM ( "Step", bStep ); PRINTITEM ( "Time", bTime ); PRINTITEM ( "Lambda", bLambda ); PRINTITEM ( "Coords", bX ); PRINTITEM ( "Velocities", bV ); PRINTITEM ( "Forces", bF ); PRINTITEM ( "Box", bBox ); }
void _ins(const pt &p, node* &n, int c) { if (!n) n = new node(p, NULL, NULL); else if (cmp(c)(p, n->p)) _ins(p, n->l, INC(c)); else if (cmp(c)(n->p, p)) _ins(p, n->r, INC(c)); }
void setUpdatedActiveSource(void) { INC(eventActiveSource); }
/*===================================================================*/ void K6502_Step( WORD wClocks ) { /* * Only the specified number of the clocks execute Op. * * Parameters * WORD wClocks (Read) * The number of the clocks */ BYTE byCode; WORD wA0; BYTE byD0; BYTE byD1; WORD wD0; // Dispose of it if there is an interrupt requirement if ( NMI_State != NMI_Wiring ) { // NMI Interrupt NMI_State = NMI_Wiring; CLK( 7 ); PUSHW( PC ); PUSH( F & ~FLAG_B ); RSTF( FLAG_D ); SETF( FLAG_I ); PC = K6502_ReadW( VECTOR_NMI ); } else if ( IRQ_State != IRQ_Wiring ) { // IRQ Interrupt // Execute IRQ if an I flag isn't being set if ( !( F & FLAG_I ) ) { IRQ_State = IRQ_Wiring; CLK( 7 ); PUSHW( PC ); PUSH( F & ~FLAG_B ); RSTF( FLAG_D ); SETF( FLAG_I ); PC = K6502_ReadW( VECTOR_IRQ ); } } // It has a loop until a constant clock passes while ( g_wPassedClocks < wClocks ) { // Read an instruction byCode = K6502_Read( PC++ ); // Execute an instruction. switch ( byCode ) { case 0x00: // BRK ++PC; PUSHW( PC ); SETF( FLAG_B ); PUSH( F ); SETF( FLAG_I ); RSTF( FLAG_D ); PC = K6502_ReadW( VECTOR_IRQ ); CLK( 7 ); break; case 0x01: // ORA (Zpg,X) ORA( A_IX ); CLK( 6 ); break; case 0x05: // ORA Zpg ORA( A_ZP ); CLK( 3 ); break; case 0x06: // ASL Zpg ASL( AA_ZP ); CLK( 5 ); break; case 0x08: // PHP SETF( FLAG_B ); PUSH( F ); CLK( 3 ); break; case 0x09: // ORA #Oper ORA( A_IMM ); CLK( 2 ); break; case 0x0A: // ASL A ASLA; CLK( 2 ); break; case 0x0D: // ORA Abs ORA( A_ABS ); CLK( 4 ); break; case 0x0e: // ASL Abs ASL( AA_ABS ); CLK( 6 ); break; case 0x10: // BPL Oper BRA( !( F & FLAG_N ) ); break; case 0x11: // ORA (Zpg),Y ORA( A_IY ); CLK( 5 ); break; case 0x15: // ORA Zpg,X ORA( A_ZPX ); CLK( 4 ); break; case 0x16: // ASL Zpg,X ASL( AA_ZPX ); CLK( 6 ); break; case 0x18: // CLC RSTF( FLAG_C ); CLK( 2 ); break; case 0x19: // ORA Abs,Y ORA( A_ABSY ); CLK( 4 ); break; case 0x1D: // ORA Abs,X ORA( A_ABSX ); CLK( 4 ); break; case 0x1E: // ASL Abs,X ASL( AA_ABSX ); CLK( 7 ); break; case 0x20: // JSR Abs JSR; CLK( 6 ); break; case 0x21: // AND (Zpg,X) AND( A_IX ); CLK( 6 ); break; case 0x24: // BIT Zpg BIT( A_ZP ); CLK( 3 ); break; case 0x25: // AND Zpg AND( A_ZP ); CLK( 3 ); break; case 0x26: // ROL Zpg ROL( AA_ZP ); CLK( 5 ); break; case 0x28: // PLP POP( F ); SETF( FLAG_R ); CLK( 4 ); break; case 0x29: // AND #Oper AND( A_IMM ); CLK( 2 ); break; case 0x2A: // ROL A ROLA; CLK( 2 ); break; case 0x2C: // BIT Abs BIT( A_ABS ); CLK( 4 ); break; case 0x2D: // AND Abs AND( A_ABS ); CLK( 4 ); break; case 0x2E: // ROL Abs ROL( AA_ABS ); CLK( 6 ); break; case 0x30: // BMI Oper BRA( F & FLAG_N ); break; case 0x31: // AND (Zpg),Y AND( A_IY ); CLK( 5 ); break; case 0x35: // AND Zpg,X AND( A_ZPX ); CLK( 4 ); break; case 0x36: // ROL Zpg,X ROL( AA_ZPX ); CLK( 6 ); break; case 0x38: // SEC SETF( FLAG_C ); CLK( 2 ); break; case 0x39: // AND Abs,Y AND( A_ABSY ); CLK( 4 ); break; case 0x3D: // AND Abs,X AND( A_ABSX ); CLK( 4 ); break; case 0x3E: // ROL Abs,X ROL( AA_ABSX ); CLK( 7 ); break; case 0x40: // RTI POP( F ); SETF( FLAG_R ); POPW( PC ); CLK( 6 ); break; case 0x41: // EOR (Zpg,X) EOR( A_IX ); CLK( 6 ); break; case 0x45: // EOR Zpg EOR( A_ZP ); CLK( 3 ); break; case 0x46: // LSR Zpg LSR( AA_ZP ); CLK( 5 ); break; case 0x48: // PHA PUSH( A ); CLK( 3 ); break; case 0x49: // EOR #Oper EOR( A_IMM ); CLK( 2 ); break; case 0x4A: // LSR A LSRA; CLK( 2 ); break; case 0x4C: // JMP Abs JMP( AA_ABS ); CLK( 3 ); break; case 0x4D: // EOR Abs EOR( A_ABS ); CLK( 4 ); break; case 0x4E: // LSR Abs LSR( AA_ABS ); CLK( 6 ); break; case 0x50: // BVC BRA( !( F & FLAG_V ) ); break; case 0x51: // EOR (Zpg),Y EOR( A_IY ); CLK( 5 ); break; case 0x55: // EOR Zpg,X EOR( A_ZPX ); CLK( 4 ); break; case 0x56: // LSR Zpg,X LSR( AA_ZPX ); CLK( 6 ); break; case 0x58: // CLI byD0 = F; RSTF( FLAG_I ); CLK( 2 ); if ( ( byD0 & FLAG_I ) && IRQ_State != IRQ_Wiring ) { IRQ_State = IRQ_Wiring; CLK( 7 ); PUSHW( PC ); PUSH( F & ~FLAG_B ); RSTF( FLAG_D ); SETF( FLAG_I ); PC = K6502_ReadW( VECTOR_IRQ ); } break; case 0x59: // EOR Abs,Y EOR( A_ABSY ); CLK( 4 ); break; case 0x5D: // EOR Abs,X EOR( A_ABSX ); CLK( 4 ); break; case 0x5E: // LSR Abs,X LSR( AA_ABSX ); CLK( 7 ); break; case 0x60: // RTS POPW( PC ); ++PC; CLK( 6 ); break; case 0x61: // ADC (Zpg,X) ADC( A_IX ); CLK( 6 ); break; case 0x65: // ADC Zpg ADC( A_ZP ); CLK( 3 ); break; case 0x66: // ROR Zpg ROR( AA_ZP ); CLK( 5 ); break; case 0x68: // PLA POP( A ); TEST( A ); CLK( 4 ); break; case 0x69: // ADC #Oper ADC( A_IMM ); CLK( 2 ); break; case 0x6A: // ROR A RORA; CLK( 2 ); break; case 0x6C: // JMP (Abs) JMP( K6502_ReadW2( AA_ABS ) ); CLK( 5 ); break; case 0x6D: // ADC Abs ADC( A_ABS ); CLK( 4 ); break; case 0x6E: // ROR Abs ROR( AA_ABS ); CLK( 6 ); break; case 0x70: // BVS BRA( F & FLAG_V ); break; case 0x71: // ADC (Zpg),Y ADC( A_IY ); CLK( 5 ); break; case 0x75: // ADC Zpg,X ADC( A_ZPX ); CLK( 4 ); break; case 0x76: // ROR Zpg,X ROR( AA_ZPX ); CLK( 6 ); break; case 0x78: // SEI SETF( FLAG_I ); CLK( 2 ); break; case 0x79: // ADC Abs,Y ADC( A_ABSY ); CLK( 4 ); break; case 0x7D: // ADC Abs,X ADC( A_ABSX ); CLK( 4 ); break; case 0x7E: // ROR Abs,X ROR( AA_ABSX ); CLK( 7 ); break; case 0x81: // STA (Zpg,X) STA( AA_IX ); CLK( 6 ); break; case 0x84: // STY Zpg STY( AA_ZP ); CLK( 3 ); break; case 0x85: // STA Zpg STA( AA_ZP ); CLK( 3 ); break; case 0x86: // STX Zpg STX( AA_ZP ); CLK( 3 ); break; case 0x88: // DEY --Y; TEST( Y ); CLK( 2 ); break; case 0x8A: // TXA A = X; TEST( A ); CLK( 2 ); break; case 0x8C: // STY Abs STY( AA_ABS ); CLK( 4 ); break; case 0x8D: // STA Abs STA( AA_ABS ); CLK( 4 ); break; case 0x8E: // STX Abs STX( AA_ABS ); CLK( 4 ); break; case 0x90: // BCC BRA( !( F & FLAG_C ) ); break; case 0x91: // STA (Zpg),Y STA( AA_IY ); CLK( 6 ); break; case 0x94: // STY Zpg,X STY( AA_ZPX ); CLK( 4 ); break; case 0x95: // STA Zpg,X STA( AA_ZPX ); CLK( 4 ); break; case 0x96: // STX Zpg,Y STX( AA_ZPY ); CLK( 4 ); break; case 0x98: // TYA A = Y; TEST( A ); CLK( 2 ); break; case 0x99: // STA Abs,Y STA( AA_ABSY ); CLK( 5 ); break; case 0x9A: // TXS SP = X; CLK( 2 ); break; case 0x9D: // STA Abs,X STA( AA_ABSX ); CLK( 5 ); break; case 0xA0: // LDY #Oper LDY( A_IMM ); CLK( 2 ); break; case 0xA1: // LDA (Zpg,X) LDA( A_IX ); CLK( 6 ); break; case 0xA2: // LDX #Oper LDX( A_IMM ); CLK( 2 ); break; case 0xA4: // LDY Zpg LDY( A_ZP ); CLK( 3 ); break; case 0xA5: // LDA Zpg LDA( A_ZP ); CLK( 3 ); break; case 0xA6: // LDX Zpg LDX( A_ZP ); CLK( 3 ); break; case 0xA8: // TAY Y = A; TEST( A ); CLK( 2 ); break; case 0xA9: // LDA #Oper LDA( A_IMM ); CLK( 2 ); break; case 0xAA: // TAX X = A; TEST( A ); CLK( 2 ); break; case 0xAC: // LDY Abs LDY( A_ABS ); CLK( 4 ); break; case 0xAD: // LDA Abs LDA( A_ABS ); CLK( 4 ); break; case 0xAE: // LDX Abs LDX( A_ABS ); CLK( 4 ); break; case 0xB0: // BCS BRA( F & FLAG_C ); break; case 0xB1: // LDA (Zpg),Y LDA( A_IY ); CLK( 5 ); break; case 0xB4: // LDY Zpg,X LDY( A_ZPX ); CLK( 4 ); break; case 0xB5: // LDA Zpg,X LDA( A_ZPX ); CLK( 4 ); break; case 0xB6: // LDX Zpg,Y LDX( A_ZPY ); CLK( 4 ); break; case 0xB8: // CLV RSTF( FLAG_V ); CLK( 2 ); break; case 0xB9: // LDA Abs,Y LDA( A_ABSY ); CLK( 4 ); break; case 0xBA: // TSX X = SP; TEST( X ); CLK( 2 ); break; case 0xBC: // LDY Abs,X LDY( A_ABSX ); CLK( 4 ); break; case 0xBD: // LDA Abs,X LDA( A_ABSX ); CLK( 4 ); break; case 0xBE: // LDX Abs,Y LDX( A_ABSY ); CLK( 4 ); break; case 0xC0: // CPY #Oper CPY( A_IMM ); CLK( 2 ); break; case 0xC1: // CMP (Zpg,X) CMP( A_IX ); CLK( 6 ); break; case 0xC4: // CPY Zpg CPY( A_ZP ); CLK( 3 ); break; case 0xC5: // CMP Zpg CMP( A_ZP ); CLK( 3 ); break; case 0xC6: // DEC Zpg DEC( AA_ZP ); CLK( 5 ); break; case 0xC8: // INY ++Y; TEST( Y ); CLK( 2 ); break; case 0xC9: // CMP #Oper CMP( A_IMM ); CLK( 2 ); break; case 0xCA: // DEX --X; TEST( X ); CLK( 2 ); break; case 0xCC: // CPY Abs CPY( A_ABS ); CLK( 4 ); break; case 0xCD: // CMP Abs CMP( A_ABS ); CLK( 4 ); break; case 0xCE: // DEC Abs DEC( AA_ABS ); CLK( 6 ); break; case 0xD0: // BNE BRA( !( F & FLAG_Z ) ); break; case 0xD1: // CMP (Zpg),Y CMP( A_IY ); CLK( 5 ); break; case 0xD5: // CMP Zpg,X CMP( A_ZPX ); CLK( 4 ); break; case 0xD6: // DEC Zpg,X DEC( AA_ZPX ); CLK( 6 ); break; case 0xD8: // CLD RSTF( FLAG_D ); CLK( 2 ); break; case 0xD9: // CMP Abs,Y CMP( A_ABSY ); CLK( 4 ); break; case 0xDD: // CMP Abs,X CMP( A_ABSX ); CLK( 4 ); break; case 0xDE: // DEC Abs,X DEC( AA_ABSX ); CLK( 7 ); break; case 0xE0: // CPX #Oper CPX( A_IMM ); CLK( 2 ); break; case 0xE1: // SBC (Zpg,X) SBC( A_IX ); CLK( 6 ); break; case 0xE4: // CPX Zpg CPX( A_ZP ); CLK( 3 ); break; case 0xE5: // SBC Zpg SBC( A_ZP ); CLK( 3 ); break; case 0xE6: // INC Zpg INC( AA_ZP ); CLK( 5 ); break; case 0xE8: // INX ++X; TEST( X ); CLK( 2 ); break; case 0xE9: // SBC #Oper SBC( A_IMM ); CLK( 2 ); break; case 0xEA: // NOP CLK( 2 ); break; case 0xEC: // CPX Abs CPX( A_ABS ); CLK( 4 ); break; case 0xED: // SBC Abs SBC( A_ABS ); CLK( 4 ); break; case 0xEE: // INC Abs INC( AA_ABS ); CLK( 6 ); break; case 0xF0: // BEQ BRA( F & FLAG_Z ); break; case 0xF1: // SBC (Zpg),Y SBC( A_IY ); CLK( 5 ); break; case 0xF5: // SBC Zpg,X SBC( A_ZPX ); CLK( 4 ); break; case 0xF6: // INC Zpg,X INC( AA_ZPX ); CLK( 6 ); break; case 0xF8: // SED SETF( FLAG_D ); CLK( 2 ); break; case 0xF9: // SBC Abs,Y SBC( A_ABSY ); CLK( 4 ); break; case 0xFD: // SBC Abs,X SBC( A_ABSX ); CLK( 4 ); break; case 0xFE: // INC Abs,X INC( AA_ABSX ); CLK( 7 ); break; /*-----------------------------------------------------------*/ /* Unlisted Instructions ( thanks to virtualnes ) */ /*-----------------------------------------------------------*/ case 0x1A: // NOP (Unofficial) case 0x3A: // NOP (Unofficial) case 0x5A: // NOP (Unofficial) case 0x7A: // NOP (Unofficial) case 0xDA: // NOP (Unofficial) case 0xFA: // NOP (Unofficial) CLK( 2 ); break; case 0x80: // DOP (CYCLES 2) case 0x82: // DOP (CYCLES 2) case 0x89: // DOP (CYCLES 2) case 0xC2: // DOP (CYCLES 2) case 0xE2: // DOP (CYCLES 2) PC++; CLK( 2 ); break; case 0x04: // DOP (CYCLES 3) case 0x44: // DOP (CYCLES 3) case 0x64: // DOP (CYCLES 3) PC++; CLK( 3 ); break; case 0x14: // DOP (CYCLES 4) case 0x34: // DOP (CYCLES 4) case 0x54: // DOP (CYCLES 4) case 0x74: // DOP (CYCLES 4) case 0xD4: // DOP (CYCLES 4) case 0xF4: // DOP (CYCLES 4) PC++; CLK( 4 ); break; case 0x0C: // TOP case 0x1C: // TOP case 0x3C: // TOP case 0x5C: // TOP case 0x7C: // TOP case 0xDC: // TOP case 0xFC: // TOP PC+=2; CLK( 4 ); break; default: // Unknown Instruction CLK( 2 ); #if 0 InfoNES_MessageBox( "0x%02x is unknown instruction.\n", byCode ) ; #endif break; } /* end of switch ( byCode ) */ } /* end of while ... */ // Correct the number of the clocks g_wPassedClocks -= wClocks; }
int arch_6502_translate_instr(cpu_t *cpu, addr_t pc, BasicBlock *bb) { uint8_t opcode = cpu->RAM[pc]; //LOG("%s:%d PC=$%04X\n", __func__, __LINE__, pc); switch (get_instr(opcode)) { /* flags */ case INSTR_CLC: LET1(cpu->ptr_C, FALSE); break; case INSTR_CLD: LET1(ptr_D, FALSE); break; case INSTR_CLI: LET1(ptr_I, FALSE); break; case INSTR_CLV: LET1(cpu->ptr_V, FALSE); break; case INSTR_SEC: LET1(cpu->ptr_C, TRUE); break; case INSTR_SED: LET1(ptr_D, TRUE); break; case INSTR_SEI: LET1(ptr_I, TRUE); break; /* register transfer */ case INSTR_TAX: SET_NZ(LET(X,R(A))); break; case INSTR_TAY: SET_NZ(LET(Y,R(A))); break; case INSTR_TXA: SET_NZ(LET(A,R(X))); break; case INSTR_TYA: SET_NZ(LET(A,R(Y))); break; case INSTR_TSX: SET_NZ(LET(X,R(S))); break; case INSTR_TXS: SET_NZ(LET(S,R(X))); break; /* load */ case INSTR_LDA: SET_NZ(LET(A,OPERAND)); break; case INSTR_LDX: SET_NZ(LET(X,OPERAND)); break; case INSTR_LDY: SET_NZ(LET(Y,OPERAND)); break; /* store */ case INSTR_STA: STORE(R(A),LOPERAND); break; case INSTR_STX: STORE(R(X),LOPERAND); break; case INSTR_STY: STORE(R(Y),LOPERAND); break; /* stack */ case INSTR_PHA: PUSH(R(A)); break; case INSTR_PHP: PUSH(arch_flags_encode(cpu, bb)); break; case INSTR_PLA: SET_NZ(LET(A,PULL)); break; case INSTR_PLP: arch_flags_decode(cpu, PULL, bb); break; /* shift */ case INSTR_ASL: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, false)); break; case INSTR_LSR: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, false)); break; case INSTR_ROL: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, true)); break; case INSTR_ROR: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, true)); break; /* bit logic */ case INSTR_AND: SET_NZ(LET(A,AND(R(A),OPERAND))); break; case INSTR_ORA: SET_NZ(LET(A,OR(R(A),OPERAND))); break; case INSTR_EOR: SET_NZ(LET(A,XOR(R(A),OPERAND))); break; case INSTR_BIT: SET_NZ(OPERAND); break; /* arithmetic */ case INSTR_ADC: SET_NZ(ADC(ptr_A, ptr_A, OPERAND, true, false)); break; case INSTR_SBC: SET_NZ(ADC(ptr_A, ptr_A, COM(OPERAND), true, false)); break; case INSTR_CMP: SET_NZ(ADC(NULL, ptr_A, COM(OPERAND), false, true)); break; case INSTR_CPX: SET_NZ(ADC(NULL, ptr_X, COM(OPERAND), false, true)); break; case INSTR_CPY: SET_NZ(ADC(NULL, ptr_Y, COM(OPERAND), false, true)); break; /* increment/decrement */ case INSTR_INX: SET_NZ(LET(X,INC(R(X)))); break; case INSTR_INY: SET_NZ(LET(Y,INC(R(Y)))); break; case INSTR_DEX: SET_NZ(LET(X,DEC(R(X)))); break; case INSTR_DEY: SET_NZ(LET(Y,DEC(R(Y)))); break; case INSTR_INC: SET_NZ(STORE(INC(OPERAND),LOPERAND)); break; case INSTR_DEC: SET_NZ(STORE(DEC(OPERAND),LOPERAND)); break; /* control flow */ case INSTR_JMP: if (get_addmode(opcode) == ADDMODE_IND) { Value *v = LOAD_RAM16(CONST32(OPERAND_16)); new StoreInst(v, cpu->ptr_PC, bb); } break; case INSTR_JSR: PUSH16(pc+2); break; case INSTR_RTS: STORE(ADD(PULL16, CONST16(1)), cpu->ptr_PC); break; /* branch */ case INSTR_BEQ: case INSTR_BNE: case INSTR_BCS: case INSTR_BCC: case INSTR_BMI: case INSTR_BPL: case INSTR_BVS: case INSTR_BVC: break; /* other */ case INSTR_NOP: break; case INSTR_BRK: arch_6502_trap(cpu, pc, bb); break; case INSTR_RTI: arch_6502_trap(cpu, pc, bb); break; case INSTR_XXX: arch_6502_trap(cpu, pc, bb); break; } return get_length(get_addmode(opcode)); }
void pong_shorthandler_flood(gasnet_token_t token) { INC(flag); }
/*INC IXH*/ static void op_DD_0x24(Z80EX_CONTEXT *cpu) { INC(IXH); T_WAIT_UNTIL(4); return; }
bool check(uint8_t event, uint8_t curr, const MenuFuncP *menuTab, uint8_t menuTabSize, const pm_uint8_t *horTab, uint8_t horTabMax, uint8_t maxrow) { uint8_t maxcol = MAXCOL(m_posVert); #ifdef NAVIGATION_RE1 // check rotary encoder 1 if changed -> cursor down/up static int16_t re1valprev; p1valdiff = 0; scrollRE = re1valprev - g_rotenc[0]; if (scrollRE) { re1valprev = g_rotenc[0]; if (s_editMode > 0) { p1valdiff = - scrollRE; scrollRE = 0; } } if (event == EVT_KEY_LONG(BTN_RE1)) { if (!menuTab && !s_editMode) { popMenu(); killEvents(event); } } if (event == EVT_KEY_BREAK(BTN_RE1)) { if (s_editMode > 0 && (maxcol & ZCHAR)) { if (m_posHorz < maxcol-ZCHAR) { m_posHorz++; } else { s_editMode = 0; } } else { scrollRE = 0; if (s_editMode++ > 0) s_editMode = 0; if (s_editMode > 0 && m_posVert == 0 && menuTab) s_editMode = -1; } } #else #define scrollRE 0 #endif #ifdef NAVIGATION_POT1 // check pot 1 - if changed -> scroll values static int16_t p1valprev; p1valdiff = (p1valprev-calibratedStick[6]) / SCROLL_POT1_TH; if (p1valdiff) p1valprev = calibratedStick[6]; #endif #ifdef NAVIGATION_POT2 // check pot 2 - if changed -> scroll menu static int16_t p2valprev; int8_t scrollLR = (p2valprev-calibratedStick[4]) / SCROLL_TH; if (scrollLR) p2valprev = calibratedStick[4]; #else #define scrollLR 0 #endif #ifdef NAVIGATION_POT3 // check pot 3 if changed -> cursor down/up static int16_t p3valprev; int8_t scrollUD = (p3valprev-calibratedStick[5]) / SCROLL_TH; if (scrollUD) p3valprev = calibratedStick[5]; #else #define scrollUD 0 #endif if(scrollLR || scrollUD || p1valdiff) g_LightOffCounter = g_eeGeneral.lightAutoOff*500; // on keypress turn the light on 5*100 if (menuTab) { uint8_t attr = 0; if (m_posVert==0 && !s_noScroll) { attr = INVERS; int8_t cc = curr; if (scrollLR || (scrollRE && s_editMode < 0)) { cc = limit((int8_t)0, (int8_t)(curr - scrollLR + scrollRE), (int8_t)(menuTabSize-1)); } switch(event) { case EVT_KEY_FIRST(KEY_LEFT): if (curr > 0) cc = curr - 1; else cc = menuTabSize-1; break; case EVT_KEY_FIRST(KEY_RIGHT): if (curr < (menuTabSize-1)) cc = curr + 1; else cc = 0; break; } if (cc != curr) { chainMenu((MenuFuncP)pgm_read_adr(&menuTab[cc])); return false; } } s_noScroll = 0; DisplayScreenIndex(curr, menuTabSize, attr); } theFile.DisplayProgressBar(menuTab ? lcd_lastPos-2*FW-((curr+1)/10*FWNUM)-2 : 20*FW+1); if (s_editMode<=0) { if (scrollUD) { m_posVert = limit((int8_t)0, (int8_t)(m_posVert - scrollUD), (int8_t)maxrow); m_posHorz = min(m_posHorz, MAXCOL(m_posVert)); BLINK_SYNC; } if (scrollLR && m_posVert>0) { m_posHorz = limit((int8_t)0, (int8_t)(m_posHorz - scrollLR), (int8_t)maxcol); BLINK_SYNC; } #ifdef NAVIGATION_RE1 while (!s_editMode && scrollRE) { if (scrollRE > 0) { --scrollRE; maxcol = MAXCOL(m_posVert); if (maxcol & ZCHAR) maxcol = 0; if (++m_posHorz > maxcol) { m_posHorz = 0; if (++m_posVert > maxrow) { m_posVert = maxrow; m_posHorz = MAXCOL(m_posVert); scrollRE = 0; } } } else { ++scrollRE; if (m_posHorz-- == 0) { if (m_posVert-- == 0) { m_posVert = 0; m_posHorz = 0; scrollRE = 0; } else { m_posHorz = MAXCOL(m_posVert); } } } } #endif } switch(event) { case EVT_ENTRY: minit(); #ifdef NAVIGATION_RE1 if (menuTab) { s_editMode = -1; break; } // no break #else s_editMode = -1; break; #endif #ifdef NAVIGATION_RE1 case EVT_ENTRY_UP: s_editMode = 0; break; #endif case EVT_KEY_FIRST(KEY_MENU): if (maxcol > 0) s_editMode = (s_editMode<=0); break; case EVT_KEY_LONG(KEY_EXIT): s_editMode = 0; popMenu(); break; case EVT_KEY_BREAK(KEY_EXIT): if(s_editMode>0) { s_editMode = 0; break; } if (m_posVert==0 || !menuTab) { popMenu(); //beeps itself } else { beepKey(); minit(); BLINK_SYNC; } break; case EVT_KEY_REPT(KEY_RIGHT): //inc if(m_posHorz==maxcol) break; case EVT_KEY_FIRST(KEY_RIGHT)://inc if(!horTab || s_editMode>0)break; INC(m_posHorz,maxcol); BLINK_SYNC; break; case EVT_KEY_REPT(KEY_LEFT): //dec if(m_posHorz==0) break; case EVT_KEY_FIRST(KEY_LEFT)://dec if(!horTab || s_editMode>0)break; DEC(m_posHorz,maxcol); BLINK_SYNC; break; case EVT_KEY_REPT(KEY_DOWN): //inc if(m_posVert==maxrow) break; case EVT_KEY_FIRST(KEY_DOWN): //inc if(s_editMode>0)break; do { INC(m_posVert,maxrow); } while(MAXCOL(m_posVert) == (uint8_t)-1); m_posHorz = min(m_posHorz, MAXCOL(m_posVert)); BLINK_SYNC; break; case EVT_KEY_REPT(KEY_UP): //dec if(m_posVert==0) break; case EVT_KEY_FIRST(KEY_UP): //dec if(s_editMode>0)break; do { DEC(m_posVert,maxrow); } while(MAXCOL(m_posVert) == (uint8_t)-1); m_posHorz = min(m_posHorz, MAXCOL(m_posVert)); BLINK_SYNC; break; } uint8_t max = menuTab ? 7 : 6; if(m_posVert<1) s_pgOfs=0; else if(m_posVert-s_pgOfs>max) s_pgOfs = m_posVert-max; else if(m_posVert-s_pgOfs<1) s_pgOfs = m_posVert-1; return true; }
void pong_longhandler_flood(gasnet_token_t token, void *buf, size_t nbytes) { INC(flag); }
int Search::search(int depth, int alpha, int beta, _TpvLine *pline, int N_PIECE, int *mateIn) { ASSERT_RANGE(depth, 0, MAX_PLY); INC(cumulativeMovesCount); *mateIn = INT_MAX; ASSERT_RANGE(side, 0, 1); if (!getRunning()) { return 0; } int score = -_INFINITE; /* gtb */ if (gtb && pline->cmove && maxTimeMillsec > 1000 && gtb->isInstalledPieces(N_PIECE) && depth >= gtb->getProbeDepth()) { int v = gtb->getDtm<side, false>(chessboard, (uchar) chessboard[RIGHT_CASTLE_IDX], depth); if (abs(v) != INT_MAX) { *mateIn = v; int res = 0; if (v == 0) { res = 0; } else { res = _INFINITE - (abs(v)); if (v < 0) { res = -res; } } ASSERT_RANGE(res, -_INFINITE, _INFINITE); ASSERT(mainDepth >= depth); return res; } } u64 oldKey = chessboard[ZOBRISTKEY_IDX]; #ifdef DEBUG_MODE double betaEfficiencyCount = 0.0; #endif ASSERT(chessboard[KING_BLACK]); ASSERT(chessboard[KING_WHITE]); ASSERT(chessboard[KING_BLACK + side]); int extension = 0; int is_incheck_side = inCheck<side>(); if (!is_incheck_side && depth != mainDepth) { if (checkInsufficientMaterial(N_PIECE)) { if (inCheck<side ^ 1>()) { return _INFINITE - (mainDepth - depth + 1); } return -lazyEval<side>() * 2; } if (checkDraw(chessboard[ZOBRISTKEY_IDX])) { return -lazyEval<side>() * 2; } } if (is_incheck_side) { extension++; } depth += extension; if (depth == 0) { return quiescence<side, smp>(alpha, beta, -1, N_PIECE, 0); } //************* hash **************** u64 zobristKeyR = chessboard[ZOBRISTKEY_IDX] ^_random::RANDSIDE[side]; _TcheckHash checkHashStruct; if (checkHash<Hash::HASH_GREATER, smp>(false, alpha, beta, depth, zobristKeyR, checkHashStruct)) { return checkHashStruct.res; }; if (checkHash<Hash::HASH_ALWAYS, smp>(false, alpha, beta, depth, zobristKeyR, checkHashStruct)) { return checkHashStruct.res; }; ///********** end hash *************** if (!(numMoves & 1023)) { setRunning(checkTime()); } ++numMoves; ///********* null move *********** int n_pieces_side; _TpvLine line; line.cmove = 0; if (!is_incheck_side && !nullSearch && depth >= NULLMOVE_DEPTH && (n_pieces_side = getNpiecesNoPawnNoKing<side>()) >= NULLMOVES_MIN_PIECE) { nullSearch = true; int nullScore = -search<side ^ 1, smp>(depth - (NULLMOVES_R1 + (depth > (NULLMOVES_R2 + (n_pieces_side < NULLMOVES_R3 ? NULLMOVES_R4 : 0)))) - 1, -beta, -beta + 1, &line, N_PIECE, mateIn); nullSearch = false; if (nullScore >= beta) { INC(nNullMoveCut); return nullScore; } } ///******* null move end ******** /**************Futility Pruning****************/ /**************Futility Pruning razor at pre-pre-frontier*****/ bool futilPrune = false; int futilScore = 0; if (depth <= 3 && !is_incheck_side) { int matBalance = lazyEval<side>(); if ((futilScore = matBalance + FUTIL_MARGIN) <= alpha) { if (depth == 3 && (matBalance + RAZOR_MARGIN) <= alpha && getNpiecesNoPawnNoKing<side ^ 1>() > 3) { INC(nCutRazor); depth--; } else ///**************Futility Pruning at pre-frontier***** if (depth == 2 && (futilScore = matBalance + EXT_FUTILY_MARGIN) <= alpha) { futilPrune = true; score = futilScore; } else ///**************Futility Pruning at frontier***** if (depth == 1) { futilPrune = true; score = futilScore; } } } /************ end Futility Pruning*************/ incListId(); ASSERT_RANGE(KING_BLACK + side, 0, 11); ASSERT_RANGE(KING_BLACK + (side ^ 1), 0, 11); u64 friends = getBitmap<side>(); u64 enemies = getBitmap<side ^ 1>(); if (generateCaptures<side>(enemies, friends)) { decListId(); score = _INFINITE - (mainDepth - depth + 1); return score; } generateMoves<side>(friends | enemies); int listcount = getListSize(); if (!listcount) { --listId; if (is_incheck_side) { return -_INFINITE + (mainDepth - depth + 1); } else { return -lazyEval<side>() * 2; } } _Tmove *best = nullptr; if (checkHashStruct.hashFlag[Hash::HASH_GREATER]) { sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_GREATER]); } else if (checkHashStruct.hashFlag[Hash::HASH_ALWAYS]) { sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_ALWAYS]); } INC(totGen); _Tmove *move; bool checkInCheck = false; int countMove = 0; char hashf = Hash::hashfALPHA; while ((move = getNextMove(&gen_list[listId]))) { countMove++; INC(betaEfficiencyCount); if (!makemove(move, true, checkInCheck)) { takeback(move, oldKey, true); continue; } checkInCheck = true; if (futilPrune && ((move->type & 0x3) != PROMOTION_MOVE_MASK) && futilScore + PIECES_VALUE[move->capturedPiece] <= alpha && !inCheck<side>()) { INC(nCutFp); takeback(move, oldKey, true); continue; } //Late Move Reduction int val = INT_MAX; if (countMove > 4 && !is_incheck_side && depth >= 3 && move->capturedPiece == SQUARE_FREE && move->promotionPiece == NO_PROMOTION) { currentPly++; val = -search<side ^ 1, smp>(depth - 2, -(alpha + 1), -alpha, &line, N_PIECE, mateIn); ASSERT(val != INT_MAX); currentPly--; } if (val > alpha) { int doMws = (score > -_INFINITE + MAX_PLY); int lwb = max(alpha, score); int upb = (doMws ? (lwb + 1) : beta); currentPly++; val = -search<side ^ 1, smp>(depth - 1, -upb, -lwb, &line, move->capturedPiece == SQUARE_FREE ? N_PIECE : N_PIECE - 1, mateIn); ASSERT(val != INT_MAX); currentPly--; if (doMws && (lwb < val) && (val < beta)) { currentPly++; val = -search<side ^ 1, smp>(depth - 1, -beta, -val + 1, &line, move->capturedPiece == SQUARE_FREE ? N_PIECE : N_PIECE - 1, mateIn); currentPly--; } } score = max(score, val); takeback(move, oldKey, true); move->score = score; if (score > alpha) { if (score >= beta) { decListId(); ASSERT(move->score == score); INC(nCutAB); ADD(betaEfficiency, betaEfficiencyCount / (double) listcount * 100.0); ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]); ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]); recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth - extension, Hash::hashfBETA, zobristKeyR, score, move); setKillerHeuristic(move->from, move->to, 0x400); return score; } alpha = score; hashf = Hash::hashfEXACT; best = move; move->score = score; //used in it updatePv(pline, &line, move); } } ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]); ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]); recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth - extension, hashf, zobristKeyR, score, best); decListId(); return score; }
int Search::quiescence(int alpha, int beta, const char promotionPiece, int N_PIECE, int depth) { if (!getRunning()) { return 0; } ASSERT(chessboard[KING_BLACK + side]); if (!(numMovesq++ & 1023)) { setRunning(checkTime()); } int score = getScore(side, N_PIECE, alpha, beta, false); if (score >= beta) { return beta; } ///************* hash **************** char hashf = Hash::hashfALPHA; u64 zobristKeyR = chessboard[ZOBRISTKEY_IDX] ^_random::RANDSIDE[side]; _TcheckHash checkHashStruct; if (checkHash<Hash::HASH_GREATER, smp>(true, alpha, beta, depth, zobristKeyR, checkHashStruct)) { return checkHashStruct.res; }; if (checkHash<Hash::HASH_ALWAYS, smp>(true, alpha, beta, depth, zobristKeyR, checkHashStruct)) { return checkHashStruct.res; }; ///********** end hash *************** /**************Delta Pruning ****************/ char fprune = 0; int fscore; if ((fscore = score + (promotionPiece == NO_PROMOTION ? VALUEQUEEN : 2 * VALUEQUEEN)) < alpha) { fprune = 1; } /************ end Delta Pruning *************/ if (score > alpha) { alpha = score; } incListId(); u64 friends = getBitmap<side>(); u64 enemies = getBitmap<side ^ 1>(); if (generateCaptures<side>(enemies, friends)) { decListId(); return _INFINITE - (mainDepth + depth); } if (!getListSize()) { --listId; return score; } _Tmove *move; _Tmove *best = nullptr; u64 oldKey = chessboard[ZOBRISTKEY_IDX]; if (checkHashStruct.hashFlag[Hash::HASH_GREATER]) { sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_GREATER]); } else if (checkHashStruct.hashFlag[Hash::HASH_ALWAYS]) { sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_ALWAYS]); } while ((move = getNextMove(&gen_list[listId]))) { if (!makemove(move, false, true)) { takeback(move, oldKey, false); continue; } /**************Delta Pruning ****************/ if (fprune && ((move->type & 0x3) != PROMOTION_MOVE_MASK) && fscore + PIECES_VALUE[move->capturedPiece] <= alpha) { INC(nCutFp); takeback(move, oldKey, false); continue; } /************ end Delta Pruning *************/ int val = -quiescence<side ^ 1, smp>(-beta, -alpha, move->promotionPiece, N_PIECE - 1, depth - 1); score = max(score, val); takeback(move, oldKey, false); if (score > alpha) { if (score >= beta) { decListId(); ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]); ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]); recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth, Hash::hashfBETA, zobristKeyR, score, move); return beta; } best = move; alpha = score; hashf = Hash::hashfEXACT; } } ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]); ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]); recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth, hashf, zobristKeyR, score, best); decListId(); return score; }
void setUpdatedStandby(void) { INC(eventStandby); }
/* - step - map set of states reachable before char to set reachable after */ static states step(struct re_guts *g, sopno start, /* start state within strip */ sopno stop, /* state after stop state within strip */ states bef, /* states reachable before */ int ch, /* character or NONCHAR code */ states aft) /* states already known reachable after */ { cset *cs; sop s; sopno pc; onestate here; /* note, macros know this name */ sopno look; int i; for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) { s = g->strip[pc]; switch (OP(s)) { case OEND: assert(pc == stop-1); break; case OCHAR: /* only characters can match */ assert(!NONCHAR(ch) || ch != (char)OPND(s)); if (ch == (char)OPND(s)) FWD(aft, bef, 1); break; case OBOL: if (ch == BOL || ch == BOLEOL) FWD(aft, bef, 1); break; case OEOL: if (ch == EOL || ch == BOLEOL) FWD(aft, bef, 1); break; case OBOW: if (ch == BOW) FWD(aft, bef, 1); break; case OEOW: if (ch == EOW) FWD(aft, bef, 1); break; case OANY: if (!NONCHAR(ch)) FWD(aft, bef, 1); break; case OANYOF: cs = &g->sets[OPND(s)]; if (!NONCHAR(ch) && CHIN(cs, ch)) FWD(aft, bef, 1); break; case OBACK_: /* ignored here */ case O_BACK: FWD(aft, aft, 1); break; case OPLUS_: /* forward, this is just an empty */ FWD(aft, aft, 1); break; case O_PLUS: /* both forward and back */ FWD(aft, aft, 1); i = ISSETBACK(aft, OPND(s)); BACK(aft, aft, OPND(s)); if (!i && ISSETBACK(aft, OPND(s))) { /* oho, must reconsider loop body */ pc -= OPND(s) + 1; INIT(here, pc); } break; case OQUEST_: /* two branches, both forward */ FWD(aft, aft, 1); FWD(aft, aft, OPND(s)); break; case O_QUEST: /* just an empty */ FWD(aft, aft, 1); break; case OLPAREN: /* not significant here */ case ORPAREN: FWD(aft, aft, 1); break; case OCH_: /* mark the first two branches */ FWD(aft, aft, 1); assert(OP(g->strip[pc+OPND(s)]) == OOR2); FWD(aft, aft, OPND(s)); break; case OOR1: /* done a branch, find the O_CH */ if (ISSTATEIN(aft, here)) { for (look = 1; OP(s = g->strip[pc+look]) != O_CH; look += OPND(s)) assert(OP(s) == OOR2); FWD(aft, aft, look); } break; case OOR2: /* propagate OCH_'s marking */ FWD(aft, aft, 1); if (OP(g->strip[pc+OPND(s)]) != O_CH) { assert(OP(g->strip[pc+OPND(s)]) == OOR2); FWD(aft, aft, OPND(s)); } break; case O_CH: /* just empty */ FWD(aft, aft, 1); break; default: /* ooooops... */ assert(nope); break; } } return(aft); }
static int trap_load_block( libspectrum_tape_block *block ) { libspectrum_byte parity, *data; int i = 0, length, read; /* On exit: * A = calculated parity byte if parity checked, else 0 (CHECKME) * F : if parity checked, all flags are modified * else carry only is modified (FIXME) * B = 0xB0 (success) or 0x00 (failure) * C = 0x01 (confirmed), 0x21, 0xFE or 0xDE (CHECKME) * DE : decremented by number of bytes loaded or verified * H = calculated parity byte or undefined * L = last byte read, or 1 if none * IX : incremented by number of bytes loaded or verified * A' = unchanged on error + no flag byte, else 0x01 * F' = 0x01 on error + no flag byte, else 0x45 * R = no point in altering it :-) * Other registers unchanged. */ data = libspectrum_tape_block_data( block ); length = libspectrum_tape_block_data_length( block ); /* Number of bytes to load or verify */ read = length - 1; if( read > DE ) read = DE; /* If there's no data in the block (!), set L then error exit. * We don't need to alter H, IX or DE here */ if( !length ) { L = F_ = 1; F &= ~FLAG_C; return 0; } i = A_; /* i = A' (flag byte) */ AF_ = 0x0145; A = 0; /* Initialise the parity check and L to the block ID byte */ L = parity = *data++; /* If the block ID byte != the flag byte, clear carry and return */ if( parity != i ) goto error_ret; /* Now set L to the *last* byte in the block */ L = data[read - 1]; /* Loading or verifying determined by the carry flag of F' */ if( F_ & FLAG_C ) { for( i = 0; i < read; i++ ) { parity ^= data[i]; writebyte_internal( IX+i, data[i] ); } } else { /* verifying */ for( i = 0; i < read; i++ ) { parity ^= data[i]; if( data[i] != readbyte_internal(IX+i) ) { /* Verification failure */ L = data[i]; goto error_ret; } } } /* At this point, i == number of bytes actually read or verified */ /* If |DE| bytes have been read and there's more data, do the parity check */ if( DE == i && read + 1 < length ) { parity ^= data[read]; A = parity; CP( 1 ); /* parity check is successful if A==0 */ B = 0xB0; } else { /* Failure to read first bit of the next byte (ref. 48K ROM, 0x5EC) */ B = 255; L = 1; INC( B ); error_ret: F &= ~FLAG_C; } /* At this point, AF, AF', B and L are already modified */ C = 1; H = parity; DE -= i; IX += i; return 0; }
// // 柦椷幚峴 // INT CPU::EXEC( INT request_cycles ) { BYTE opcode; // 僆儁僐乕僪 INT OLD_cycles = TOTAL_cycles; INT exec_cycles; BYTE nmi_request, irq_request; BOOL bClockProcess = m_bClockProcess; // TEMP register WORD EA; register WORD ET; register WORD WT; register BYTE DT; while( request_cycles > 0 ) { exec_cycles = 0; if( DMA_cycles ) { if( request_cycles <= DMA_cycles ) { DMA_cycles -= request_cycles; TOTAL_cycles += request_cycles; // 僋儘僢僋摨婜張棟 mapper->Clock( request_cycles ); #if DPCM_SYNCCLOCK apu->SyncDPCM( request_cycles ); #endif if( bClockProcess ) { nes->Clock( request_cycles ); } // nes->Clock( request_cycles ); goto _execute_exit; } else { exec_cycles += DMA_cycles; // request_cycles -= DMA_cycles; DMA_cycles = 0; } } nmi_request = irq_request = 0; opcode = OP6502( R.PC++ ); if( R.INT_pending ) { if( R.INT_pending & NMI_FLAG ) { nmi_request = 0xFF; R.INT_pending &= ~NMI_FLAG; } else if( R.INT_pending & IRQ_MASK ) { R.INT_pending &= ~IRQ_TRIGGER2; if( !(R.P & I_FLAG) && opcode != 0x40 ) { irq_request = 0xFF; R.INT_pending &= ~IRQ_TRIGGER; } } } //增加指令预测忽略功能 //opcode BYTE iInstructionLen =1; switch (TraceAddrMode[opcode]) { case IND: case ADR: case ABS: case ABX: case ABY: iInstructionLen = 3; break; case IMM: case ZPG: case ZPX: case ZPY: case INX: case INY: iInstructionLen = 2; break; case IMP:case ACC:case ERR: break; case REL:iInstructionLen = 2;break; } if( ((TraceArr[opcode][0]=='*') || (TraceArr[opcode][1]=='?'))&& (!Config.emulator.bIllegalOp) ) { //这里可以优化输出信息 //char str[111]; //DecodeInstruction (R.PC-1, str); //DEBUGOUT( "Bad Instruction:%s\n",str); R.PC=(R.PC-1)+iInstructionLen; ADD_CYCLE(iInstructionLen*2); goto end_is; } // switch( opcode ) { case 0x69: // ADC #$?? MR_IM(); ADC(); ADD_CYCLE(2); break; case 0x65: // ADC $?? MR_ZP(); ADC(); ADD_CYCLE(3); break; case 0x75: // ADC $??,X MR_ZX(); ADC(); ADD_CYCLE(4); break; case 0x6D: // ADC $???? MR_AB(); ADC(); ADD_CYCLE(4); break; case 0x7D: // ADC $????,X MR_AX(); ADC(); CHECK_EA(); ADD_CYCLE(4); break; case 0x79: // ADC $????,Y MR_AY(); ADC(); CHECK_EA(); ADD_CYCLE(4); break; case 0x61: // ADC ($??,X) MR_IX(); ADC(); ADD_CYCLE(6); break; case 0x71: // ADC ($??),Y MR_IY(); ADC(); CHECK_EA(); ADD_CYCLE(4); break; case 0xE9: // SBC #$?? MR_IM(); SBC(); ADD_CYCLE(2); break; case 0xE5: // SBC $?? MR_ZP(); SBC(); ADD_CYCLE(3); break; case 0xF5: // SBC $??,X MR_ZX(); SBC(); ADD_CYCLE(4); break; case 0xED: // SBC $???? MR_AB(); SBC(); ADD_CYCLE(4); break; case 0xFD: // SBC $????,X MR_AX(); SBC(); CHECK_EA(); ADD_CYCLE(4); break; case 0xF9: // SBC $????,Y MR_AY(); SBC(); CHECK_EA(); ADD_CYCLE(4); break; case 0xE1: // SBC ($??,X) MR_IX(); SBC(); ADD_CYCLE(6); break; case 0xF1: // SBC ($??),Y MR_IY(); SBC(); CHECK_EA(); ADD_CYCLE(5); break; case 0xC6: // DEC $?? MR_ZP(); DEC(); MW_ZP(); ADD_CYCLE(5); break; case 0xD6: // DEC $??,X MR_ZX(); DEC(); MW_ZP(); ADD_CYCLE(6); break; case 0xCE: // DEC $???? MR_AB(); DEC(); MW_EA(); ADD_CYCLE(6); break; case 0xDE: // DEC $????,X MR_AX(); DEC(); MW_EA(); ADD_CYCLE(7); break; case 0xCA: // DEX DEX(); ADD_CYCLE(2); break; case 0x88: // DEY DEY(); ADD_CYCLE(2); break; case 0xE6: // INC $?? MR_ZP(); INC(); MW_ZP(); ADD_CYCLE(5); break; case 0xF6: // INC $??,X MR_ZX(); INC(); MW_ZP(); ADD_CYCLE(6); break; case 0xEE: // INC $???? MR_AB(); INC(); MW_EA(); ADD_CYCLE(6); break; case 0xFE: // INC $????,X MR_AX(); INC(); MW_EA(); ADD_CYCLE(7); break; case 0xE8: // INX INX(); ADD_CYCLE(2); break; case 0xC8: // INY INY(); ADD_CYCLE(2); break; case 0x29: // AND #$?? MR_IM(); AND(); ADD_CYCLE(2); break; case 0x25: // AND $?? MR_ZP(); AND(); ADD_CYCLE(3); break; case 0x35: // AND $??,X MR_ZX(); AND(); ADD_CYCLE(4); break; case 0x2D: // AND $???? MR_AB(); AND(); ADD_CYCLE(4); break; case 0x3D: // AND $????,X MR_AX(); AND(); CHECK_EA(); ADD_CYCLE(4); break; case 0x39: // AND $????,Y MR_AY(); AND(); CHECK_EA(); ADD_CYCLE(4); break; case 0x21: // AND ($??,X) MR_IX(); AND(); ADD_CYCLE(6); break; case 0x31: // AND ($??),Y MR_IY(); AND(); CHECK_EA(); ADD_CYCLE(5); break; case 0x0A: // ASL A ASL_A(); ADD_CYCLE(2); break; case 0x06: // ASL $?? MR_ZP(); ASL(); MW_ZP(); ADD_CYCLE(5); break; case 0x16: // ASL $??,X MR_ZX(); ASL(); MW_ZP(); ADD_CYCLE(6); break; case 0x0E: // ASL $???? MR_AB(); ASL(); MW_EA(); ADD_CYCLE(6); break; case 0x1E: // ASL $????,X MR_AX(); ASL(); MW_EA(); ADD_CYCLE(7); break; case 0x24: // BIT $?? MR_ZP(); BIT(); ADD_CYCLE(3); break; case 0x2C: // BIT $???? MR_AB(); BIT(); ADD_CYCLE(4); break; case 0x49: // EOR #$?? MR_IM(); EOR(); ADD_CYCLE(2); break; case 0x45: // EOR $?? MR_ZP(); EOR(); ADD_CYCLE(3); break; case 0x55: // EOR $??,X MR_ZX(); EOR(); ADD_CYCLE(4); break; case 0x4D: // EOR $???? MR_AB(); EOR(); ADD_CYCLE(4); break; case 0x5D: // EOR $????,X MR_AX(); EOR(); CHECK_EA(); ADD_CYCLE(4); break; case 0x59: // EOR $????,Y MR_AY(); EOR(); CHECK_EA(); ADD_CYCLE(4); break; case 0x41: // EOR ($??,X) MR_IX(); EOR(); ADD_CYCLE(6); break; case 0x51: // EOR ($??),Y MR_IY(); EOR(); CHECK_EA(); ADD_CYCLE(5); break; case 0x4A: // LSR A LSR_A(); ADD_CYCLE(2); break; case 0x46: // LSR $?? MR_ZP(); LSR(); MW_ZP(); ADD_CYCLE(5); break; case 0x56: // LSR $??,X MR_ZX(); LSR(); MW_ZP(); ADD_CYCLE(6); break; case 0x4E: // LSR $???? MR_AB(); LSR(); MW_EA(); ADD_CYCLE(6); break; case 0x5E: // LSR $????,X MR_AX(); LSR(); MW_EA(); ADD_CYCLE(7); break; case 0x09: // ORA #$?? MR_IM(); ORA(); ADD_CYCLE(2); break; case 0x05: // ORA $?? MR_ZP(); ORA(); ADD_CYCLE(3); break; case 0x15: // ORA $??,X MR_ZX(); ORA(); ADD_CYCLE(4); break; case 0x0D: // ORA $???? MR_AB(); ORA(); ADD_CYCLE(4); break; case 0x1D: // ORA $????,X MR_AX(); ORA(); CHECK_EA(); ADD_CYCLE(4); break; case 0x19: // ORA $????,Y MR_AY(); ORA(); CHECK_EA(); ADD_CYCLE(4); break; case 0x01: // ORA ($??,X) MR_IX(); ORA(); ADD_CYCLE(6); break; case 0x11: // ORA ($??),Y MR_IY(); ORA(); CHECK_EA(); ADD_CYCLE(5); break; case 0x2A: // ROL A ROL_A(); ADD_CYCLE(2); break; case 0x26: // ROL $?? MR_ZP(); ROL(); MW_ZP(); ADD_CYCLE(5); break; case 0x36: // ROL $??,X MR_ZX(); ROL(); MW_ZP(); ADD_CYCLE(6); break; case 0x2E: // ROL $???? MR_AB(); ROL(); MW_EA(); ADD_CYCLE(6); break; case 0x3E: // ROL $????,X MR_AX(); ROL(); MW_EA(); ADD_CYCLE(7); break; case 0x6A: // ROR A ROR_A(); ADD_CYCLE(2); break; case 0x66: // ROR $?? MR_ZP(); ROR(); MW_ZP(); ADD_CYCLE(5); break; case 0x76: // ROR $??,X MR_ZX(); ROR(); MW_ZP(); ADD_CYCLE(6); break; case 0x6E: // ROR $???? MR_AB(); ROR(); MW_EA(); ADD_CYCLE(6); break; case 0x7E: // ROR $????,X MR_AX(); ROR(); MW_EA(); ADD_CYCLE(7); break; case 0xA9: // LDA #$?? MR_IM(); LDA(); ADD_CYCLE(2); break; case 0xA5: // LDA $?? MR_ZP(); LDA(); ADD_CYCLE(3); break; case 0xB5: // LDA $??,X MR_ZX(); LDA(); ADD_CYCLE(4); break; case 0xAD: // LDA $???? MR_AB(); LDA(); ADD_CYCLE(4); break; case 0xBD: // LDA $????,X MR_AX(); LDA(); CHECK_EA(); ADD_CYCLE(4); break; case 0xB9: // LDA $????,Y MR_AY(); LDA(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA1: // LDA ($??,X) MR_IX(); LDA(); ADD_CYCLE(6); break; case 0xB1: // LDA ($??),Y MR_IY(); LDA(); CHECK_EA(); ADD_CYCLE(5); break; case 0xA2: // LDX #$?? MR_IM(); LDX(); ADD_CYCLE(2); break; case 0xA6: // LDX $?? MR_ZP(); LDX(); ADD_CYCLE(3); break; case 0xB6: // LDX $??,Y MR_ZY(); LDX(); ADD_CYCLE(4); break; case 0xAE: // LDX $???? MR_AB(); LDX(); ADD_CYCLE(4); break; case 0xBE: // LDX $????,Y MR_AY(); LDX(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA0: // LDY #$?? MR_IM(); LDY(); ADD_CYCLE(2); break; case 0xA4: // LDY $?? MR_ZP(); LDY(); ADD_CYCLE(3); break; case 0xB4: // LDY $??,X MR_ZX(); LDY(); ADD_CYCLE(4); break; case 0xAC: // LDY $???? MR_AB(); LDY(); ADD_CYCLE(4); break; case 0xBC: // LDY $????,X MR_AX(); LDY(); CHECK_EA(); ADD_CYCLE(4); break; case 0x85: // STA $?? EA_ZP(); STA(); MW_ZP(); ADD_CYCLE(3); break; case 0x95: // STA $??,X EA_ZX(); STA(); MW_ZP(); ADD_CYCLE(4); break; case 0x8D: // STA $???? EA_AB(); STA(); MW_EA(); ADD_CYCLE(4); break; case 0x9D: // STA $????,X EA_AX(); STA(); MW_EA(); ADD_CYCLE(5); break; case 0x99: // STA $????,Y EA_AY(); STA(); MW_EA(); ADD_CYCLE(5); break; case 0x81: // STA ($??,X) EA_IX(); STA(); MW_EA(); ADD_CYCLE(6); break; case 0x91: // STA ($??),Y EA_IY(); STA(); MW_EA(); ADD_CYCLE(6); break; case 0x86: // STX $?? EA_ZP(); STX(); MW_ZP(); ADD_CYCLE(3); break; case 0x96: // STX $??,Y EA_ZY(); STX(); MW_ZP(); ADD_CYCLE(4); break; case 0x8E: // STX $???? EA_AB(); STX(); MW_EA(); ADD_CYCLE(4); break; case 0x84: // STY $?? EA_ZP(); STY(); MW_ZP(); ADD_CYCLE(3); break; case 0x94: // STY $??,X EA_ZX(); STY(); MW_ZP(); ADD_CYCLE(4); break; case 0x8C: // STY $???? EA_AB(); STY(); MW_EA(); ADD_CYCLE(4); break; case 0xAA: // TAX TAX(); ADD_CYCLE(2); break; case 0x8A: // TXA TXA(); ADD_CYCLE(2); break; case 0xA8: // TAY TAY(); ADD_CYCLE(2); break; case 0x98: // TYA TYA(); ADD_CYCLE(2); break; case 0xBA: // TSX TSX(); ADD_CYCLE(2); break; case 0x9A: // TXS TXS(); ADD_CYCLE(2); break; case 0xC9: // CMP #$?? MR_IM(); CMP_(); ADD_CYCLE(2); break; case 0xC5: // CMP $?? MR_ZP(); CMP_(); ADD_CYCLE(3); break; case 0xD5: // CMP $??,X MR_ZX(); CMP_(); ADD_CYCLE(4); break; case 0xCD: // CMP $???? MR_AB(); CMP_(); ADD_CYCLE(4); break; case 0xDD: // CMP $????,X MR_AX(); CMP_(); CHECK_EA(); ADD_CYCLE(4); break; case 0xD9: // CMP $????,Y MR_AY(); CMP_(); CHECK_EA(); ADD_CYCLE(4); break; case 0xC1: // CMP ($??,X) MR_IX(); CMP_(); ADD_CYCLE(6); break; case 0xD1: // CMP ($??),Y MR_IY(); CMP_(); CHECK_EA(); ADD_CYCLE(5); break; case 0xE0: // CPX #$?? MR_IM(); CPX(); ADD_CYCLE(2); break; case 0xE4: // CPX $?? MR_ZP(); CPX(); ADD_CYCLE(3); break; case 0xEC: // CPX $???? MR_AB(); CPX(); ADD_CYCLE(4); break; case 0xC0: // CPY #$?? MR_IM(); CPY(); ADD_CYCLE(2); break; case 0xC4: // CPY $?? MR_ZP(); CPY(); ADD_CYCLE(3); break; case 0xCC: // CPY $???? MR_AB(); CPY(); ADD_CYCLE(4); break; case 0x90: // BCC MR_IM(); BCC(); ADD_CYCLE(2); break; case 0xB0: // BCS MR_IM(); BCS(); ADD_CYCLE(2); break; case 0xF0: // BEQ MR_IM(); BEQ(); ADD_CYCLE(2); break; case 0x30: // BMI MR_IM(); BMI(); ADD_CYCLE(2); break; case 0xD0: // BNE MR_IM(); BNE(); ADD_CYCLE(2); break; case 0x10: // BPL MR_IM(); BPL(); ADD_CYCLE(2); break; case 0x50: // BVC MR_IM(); BVC(); ADD_CYCLE(2); break; case 0x70: // BVS MR_IM(); BVS(); ADD_CYCLE(2); break; case 0x4C: // JMP $???? JMP(); ADD_CYCLE(3); break; case 0x6C: // JMP ($????) JMP_ID(); ADD_CYCLE(5); break; case 0x20: // JSR JSR(); ADD_CYCLE(6); break; case 0x40: // RTI RTI(); ADD_CYCLE(6); break; case 0x60: // RTS RTS(); ADD_CYCLE(6); break; // 僼儔僌惂屼宯 case 0x18: // CLC CLC(); ADD_CYCLE(2); break; case 0xD8: // CLD CLD(); ADD_CYCLE(2); break; case 0x58: // CLI CLI(); ADD_CYCLE(2); break; case 0xB8: // CLV CLV(); ADD_CYCLE(2); break; case 0x38: // SEC SEC(); ADD_CYCLE(2); break; case 0xF8: // SED SED(); ADD_CYCLE(2); break; case 0x78: // SEI SEI(); ADD_CYCLE(2); break; // 僗僞僢僋宯 case 0x48: // PHA PUSH( R.A ); ADD_CYCLE(3); break; case 0x08: // PHP PUSH( R.P | B_FLAG ); ADD_CYCLE(3); break; case 0x68: // PLA (N-----Z-) R.A = POP(); SET_ZN_FLAG(R.A); ADD_CYCLE(4); break; case 0x28: // PLP R.P = POP() | R_FLAG; ADD_CYCLE(4); break; // 偦偺懠 case 0x00: // BRK BRK(); ADD_CYCLE(7); break; case 0xEA: // NOP ADD_CYCLE(2); break; // 枹岞奐柦椷孮 case 0x0B: // ANC #$?? case 0x2B: // ANC #$?? MR_IM(); ANC(); ADD_CYCLE(2); break; case 0x8B: // ANE #$?? MR_IM(); ANE(); ADD_CYCLE(2); break; case 0x6B: // ARR #$?? MR_IM(); ARR(); ADD_CYCLE(2); break; case 0x4B: // ASR #$?? MR_IM(); ASR(); ADD_CYCLE(2); break; case 0xC7: // DCP $?? MR_ZP(); DCP(); MW_ZP(); ADD_CYCLE(5); break; case 0xD7: // DCP $??,X MR_ZX(); DCP(); MW_ZP(); ADD_CYCLE(6); break; case 0xCF: // DCP $???? MR_AB(); DCP(); MW_EA(); ADD_CYCLE(6); break; case 0xDF: // DCP $????,X MR_AX(); DCP(); MW_EA(); ADD_CYCLE(7); break; case 0xDB: // DCP $????,Y MR_AY(); DCP(); MW_EA(); ADD_CYCLE(7); break; case 0xC3: // DCP ($??,X) MR_IX(); DCP(); MW_EA(); ADD_CYCLE(8); break; case 0xD3: // DCP ($??),Y MR_IY(); DCP(); MW_EA(); ADD_CYCLE(8); break; case 0xE7: // ISB $?? MR_ZP(); ISB(); MW_ZP(); ADD_CYCLE(5); break; case 0xF7: // ISB $??,X MR_ZX(); ISB(); MW_ZP(); ADD_CYCLE(5); break; case 0xEF: // ISB $???? MR_AB(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xFF: // ISB $????,X MR_AX(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xFB: // ISB $????,Y MR_AY(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xE3: // ISB ($??,X) MR_IX(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xF3: // ISB ($??),Y MR_IY(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xBB: // LAS $????,Y MR_AY(); LAS(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA7: // LAX $?? MR_ZP(); LAX(); ADD_CYCLE(3); break; case 0xB7: // LAX $??,Y MR_ZY(); LAX(); ADD_CYCLE(4); break; case 0xAF: // LAX $???? MR_AB(); LAX(); ADD_CYCLE(4); break; case 0xBF: // LAX $????,Y MR_AY(); LAX(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA3: // LAX ($??,X) MR_IX(); LAX(); ADD_CYCLE(6); break; case 0xB3: // LAX ($??),Y MR_IY(); LAX(); CHECK_EA(); ADD_CYCLE(5); break; case 0xAB: // LXA #$?? MR_IM(); LXA(); ADD_CYCLE(2); break; case 0x27: // RLA $?? MR_ZP(); RLA(); MW_ZP(); ADD_CYCLE(5); break; case 0x37: // RLA $??,X MR_ZX(); RLA(); MW_ZP(); ADD_CYCLE(6); break; case 0x2F: // RLA $???? MR_AB(); RLA(); MW_EA(); ADD_CYCLE(6); break; case 0x3F: // RLA $????,X MR_AX(); RLA(); MW_EA(); ADD_CYCLE(7); break; case 0x3B: // RLA $????,Y MR_AY(); RLA(); MW_EA(); ADD_CYCLE(7); break; case 0x23: // RLA ($??,X) MR_IX(); RLA(); MW_EA(); ADD_CYCLE(8); break; case 0x33: // RLA ($??),Y MR_IY(); RLA(); MW_EA(); ADD_CYCLE(8); break; case 0x67: // RRA $?? MR_ZP(); RRA(); MW_ZP(); ADD_CYCLE(5); break; case 0x77: // RRA $??,X MR_ZX(); RRA(); MW_ZP(); ADD_CYCLE(6); break; case 0x6F: // RRA $???? MR_AB(); RRA(); MW_EA(); ADD_CYCLE(6); break; case 0x7F: // RRA $????,X MR_AX(); RRA(); MW_EA(); ADD_CYCLE(7); break; case 0x7B: // RRA $????,Y MR_AY(); RRA(); MW_EA(); ADD_CYCLE(7); break; case 0x63: // RRA ($??,X) MR_IX(); RRA(); MW_EA(); ADD_CYCLE(8); break; case 0x73: // RRA ($??),Y MR_IY(); RRA(); MW_EA(); ADD_CYCLE(8); break; case 0x87: // SAX $?? MR_ZP(); SAX(); MW_ZP(); ADD_CYCLE(3); break; case 0x97: // SAX $??,Y MR_ZY(); SAX(); MW_ZP(); ADD_CYCLE(4); break; case 0x8F: // SAX $???? MR_AB(); SAX(); MW_EA(); ADD_CYCLE(4); break; case 0x83: // SAX ($??,X) MR_IX(); SAX(); MW_EA(); ADD_CYCLE(6); break; case 0xCB: // SBX #$?? MR_IM(); SBX(); ADD_CYCLE(2); break; case 0x9F: // SHA $????,Y MR_AY(); SHA(); MW_EA(); ADD_CYCLE(5); break; case 0x93: // SHA ($??),Y MR_IY(); SHA(); MW_EA(); ADD_CYCLE(6); break; case 0x9B: // SHS $????,Y MR_AY(); SHS(); MW_EA(); ADD_CYCLE(5); break; case 0x9E: // SHX $????,Y MR_AY(); SHX(); MW_EA(); ADD_CYCLE(5); break; case 0x9C: // SHY $????,X MR_AX(); SHY(); MW_EA(); ADD_CYCLE(5); break; case 0x07: // SLO $?? MR_ZP(); SLO(); MW_ZP(); ADD_CYCLE(5); break; case 0x17: // SLO $??,X MR_ZX(); SLO(); MW_ZP(); ADD_CYCLE(6); break; case 0x0F: // SLO $???? MR_AB(); SLO(); MW_EA(); ADD_CYCLE(6); break; case 0x1F: // SLO $????,X MR_AX(); SLO(); MW_EA(); ADD_CYCLE(7); break; case 0x1B: // SLO $????,Y MR_AY(); SLO(); MW_EA(); ADD_CYCLE(7); break; case 0x03: // SLO ($??,X) MR_IX(); SLO(); MW_EA(); ADD_CYCLE(8); break; case 0x13: // SLO ($??),Y MR_IY(); SLO(); MW_EA(); ADD_CYCLE(8); break; case 0x47: // SRE $?? MR_ZP(); SRE(); MW_ZP(); ADD_CYCLE(5); break; case 0x57: // SRE $??,X MR_ZX(); SRE(); MW_ZP(); ADD_CYCLE(6); break; case 0x4F: // SRE $???? MR_AB(); SRE(); MW_EA(); ADD_CYCLE(6); break; case 0x5F: // SRE $????,X MR_AX(); SRE(); MW_EA(); ADD_CYCLE(7); break; case 0x5B: // SRE $????,Y MR_AY(); SRE(); MW_EA(); ADD_CYCLE(7); break; case 0x43: // SRE ($??,X) MR_IX(); SRE(); MW_EA(); ADD_CYCLE(8); break; case 0x53: // SRE ($??),Y MR_IY(); SRE(); MW_EA(); ADD_CYCLE(8); break; case 0xEB: // SBC #$?? (Unofficial) MR_IM(); SBC(); ADD_CYCLE(2); break; case 0x1A: // NOP (Unofficial) case 0x3A: // NOP (Unofficial) case 0x5A: // NOP (Unofficial) case 0x7A: // NOP (Unofficial) case 0xDA: // NOP (Unofficial) case 0xFA: // NOP (Unofficial) ADD_CYCLE(2); break; case 0x80: // DOP (CYCLES 2) case 0x82: // DOP (CYCLES 2) case 0x89: // DOP (CYCLES 2) case 0xC2: // DOP (CYCLES 2) case 0xE2: // DOP (CYCLES 2) R.PC++; ADD_CYCLE(2); break; case 0x04: // DOP (CYCLES 3) case 0x44: // DOP (CYCLES 3) case 0x64: // DOP (CYCLES 3) R.PC++; ADD_CYCLE(3); break; case 0x14: // DOP (CYCLES 4) case 0x34: // DOP (CYCLES 4) case 0x54: // DOP (CYCLES 4) case 0x74: // DOP (CYCLES 4) case 0xD4: // DOP (CYCLES 4) case 0xF4: // DOP (CYCLES 4) R.PC++; ADD_CYCLE(4); break; case 0x0C: // TOP case 0x1C: // TOP case 0x3C: // TOP case 0x5C: // TOP case 0x7C: // TOP case 0xDC: // TOP case 0xFC: // TOP R.PC+=2; ADD_CYCLE(4); break; case 0x02: /* JAM */ case 0x12: /* JAM */ case 0x22: /* JAM */ case 0x32: /* JAM */ case 0x42: /* JAM */ case 0x52: /* JAM */ case 0x62: /* JAM */ case 0x72: /* JAM */ case 0x92: /* JAM */ case 0xB2: /* JAM */ case 0xD2: /* JAM */ case 0xF2: /* JAM */ default: if( !Config.emulator.bIllegalOp ) { throw CApp::GetErrorString( IDS_ERROR_ILLEGALOPCODE ); goto _execute_exit; } else { R.PC--; ADD_CYCLE(4); } break; // default: // __assume(0); } end_is: __asm nop; if( nmi_request ) { _NMI(); } else if( irq_request ) { _IRQ(); } request_cycles -= exec_cycles; TOTAL_cycles += exec_cycles; // 僋儘僢僋摨婜張棟 mapper->Clock( exec_cycles ); #if DPCM_SYNCCLOCK apu->SyncDPCM( exec_cycles ); #endif if( bClockProcess ) { nes->Clock( exec_cycles ); } // nes->Clock( exec_cycles ); } _execute_exit: #if !DPCM_SYNCCLOCK apu->SyncDPCM( TOTAL_cycles - OLD_cycles ); #endif return TOTAL_cycles - OLD_cycles; }
void request_stats_final(REQUEST *request) { if (request->master_state == REQUEST_COUNTED) return; if ((request->listener->type != RAD_LISTEN_NONE) && (request->listener->type != RAD_LISTEN_AUTH) && (request->listener->type != RAD_LISTEN_ACCT)) return; /* don't count statistic requests */ if (request->packet->code == PW_STATUS_SERVER) return; #undef INC_AUTH #define INC_AUTH(_x) radius_auth_stats._x++;request->listener->stats._x++;if (request->client && request->client->auth) request->client->auth->_x++; #undef INC_ACCT #define INC_ACCT(_x) radius_acct_stats._x++;request->listener->stats._x++;if (request->client && request->client->acct) request->client->acct->_x++ /* * Update the statistics. * * Note that we do NOT do this in a child thread. * Instead, we update the stats when a request is * deleted, because only the main server thread calls * this function, which makes it thread-safe. */ switch (request->reply->code) { case PW_AUTHENTICATION_ACK: INC_AUTH(total_responses); INC_AUTH(total_access_accepts); break; case PW_AUTHENTICATION_REJECT: INC_AUTH(total_responses); INC_AUTH(total_access_rejects); break; case PW_ACCESS_CHALLENGE: INC_AUTH(total_responses); INC_AUTH(total_access_challenges); break; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_RESPONSE: INC_ACCT(total_responses); break; #endif /* * No response, it must have been a bad * authenticator. */ case 0: if (request->packet->code == PW_AUTHENTICATION_REQUEST) { if (request->reply->offset == -2) { INC_AUTH(total_bad_authenticators); } else { INC_AUTH(total_packets_dropped); } } else if (request->packet->code == PW_ACCOUNTING_REQUEST) { if (request->reply->offset == -2) { INC_ACCT(total_bad_authenticators); } else { INC_ACCT(total_packets_dropped); } } break; default: break; } #ifdef WITH_PROXY if (!request->proxy || !request->proxy_listener) goto done; /* simplifies formatting */ switch (request->proxy->code) { case PW_AUTHENTICATION_REQUEST: proxy_auth_stats.total_requests += request->num_proxied_requests; request->proxy_listener->stats.total_requests += request->num_proxied_requests; request->home_server->stats.total_requests += request->num_proxied_requests; break; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_REQUEST: proxy_acct_stats.total_requests++; request->proxy_listener->stats.total_requests += request->num_proxied_requests; request->home_server->stats.total_requests += request->num_proxied_requests; break; #endif default: break; } if (!request->proxy_reply) goto done; /* simplifies formatting */ #undef INC #define INC(_x) proxy_auth_stats._x += request->num_proxied_responses; request->proxy_listener->stats._x += request->num_proxied_responses; request->home_server->stats._x += request->num_proxied_responses; switch (request->proxy_reply->code) { case PW_AUTHENTICATION_ACK: INC(total_responses); INC(total_access_accepts); break; case PW_AUTHENTICATION_REJECT: INC(total_responses); INC(total_access_rejects); break; case PW_ACCESS_CHALLENGE: INC(total_responses); INC(total_access_challenges); break; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_RESPONSE: proxy_acct_stats.total_responses++; request->proxy_listener->stats.total_responses++; request->home_server->stats.total_responses++; break; #endif default: proxy_auth_stats.total_unknown_types++; request->proxy_listener->stats.total_unknown_types++; request->home_server->stats.total_unknown_types++; break; } done: #endif /* WITH_PROXY */ request->master_state = REQUEST_COUNTED; }
/** Reads a key code from a window. @param win The window to read from. @return The key code. **/ int OVERLOAD(wgetch)(WINDOW * const win) { log_call("wgetch(" PTRF ").", PTRS(win)); if (options.play_on) { int key = play_key(win); if (key == KEY_EOF) { options.play_on = FALSE; } else { return key; } } if (options.roll_on) { int key = play_key(win); if (key == KEY_EOF) { options.roll_on = FALSE; } else { return key; } } /* Keeps track of the actual turn count. */ if (*exec_turns < previous_turns) { negative_turns++; } else if (*exec_turns > previous_turns) { options.k_on = TRUE; } else { options.k_on = FALSE; } previous_turns = *exec_turns; turns = *exec_turns + negative_turns; /* Waits for a key. */ const int key = orig_wgetch(win); /* Handles a key. */ if (key == cfg_save_key) { put_fwrite(cfg_output_paths[current_save]); save_state(current_save); } else if (key == cfg_load_key) { load_state(current_save); } else if (key == cfg_next_save_key) { INC(current_save, 1, cfg_saves); } else if (key == cfg_prev_save_key) { DEC(current_save, 1, cfg_saves); } else if (key == cfg_longer_duration_key) { if (current_duration < frame_rate * frame_rate) { current_duration *= 2; } } else if (key == cfg_shorter_duration_key) { if (current_duration > frame_rate / frame_rate) { current_duration /= 2; } } else if (key == cfg_more_time_key) { if (cfg_timestamp - record.timestamp < LONG_MAX) { cfg_timestamp++; } } else if (key == cfg_less_time_key) { if (cfg_timestamp - record.timestamp > 0) { cfg_timestamp--; } } else if (key == cfg_menu_key) { options.gui_menu = !options.gui_menu; options.gui_info = FALSE; } else if (key == cfg_info_key) { options.gui_menu = FALSE; options.gui_info = !options.gui_info; } else if (key == cfg_condense_key) { options.gui_condensed = !options.gui_condensed; } else if (key == cfg_hide_key) { options.gui_hidden = !options.gui_hidden; } else if (key == cfg_play_key) { if (options.play_on) { options.play_on = !options.play_on; } else if (record.frames == 0) { options.play_on = TRUE; put_fread(cfg_input_path); record.current = record.first; } } else if (key == cfg_stop_key) { options.play_on = FALSE; record.current = NULL; } else if (key == cfg_quit_key) { options.progress = EXIT; *shared.state = HAD_ENOUGH; shared.pids[0] = 0; uninit(FALSE); exit(NO_PROBLEM); } else { if (record.frames == 0 && key != ' ') { return KEY_NULL; } else { const size_t inputs = sizeof previous_inputs / sizeof *previous_inputs - 1; for (size_t input = 0; input < inputs; input++) {//shifts the array left previous_inputs[input] = previous_inputs[input + 1]; } previous_inputs[inputs] = key; rec_add_key_frame(current_duration, key); } } wrefresh(win); return key; }
void check(const char *name, check_event_t event, uint8_t curr, const MenuFuncP *menuTab, uint8_t menuTabSize, const pm_uint8_t *horTab, uint8_t horTabMax, vertpos_t rowcount, uint8_t flags) { vertpos_t l_posVert = m_posVert; horzpos_t l_posHorz = m_posHorz; uint8_t maxcol = MAXCOL(l_posVert); if (menuTab) { int cc = curr; switch (event) { case EVT_KEY_LONG(KEY_MENU): if (menuTab == menuTabModel) { killEvents(event); if (modelHasNotes()) { MENU_ADD_SD_ITEM(STR_VIEW_CHANNELS); MENU_ADD_ITEM(STR_VIEW_NOTES); menuHandler = onLongMenuPress; } else { pushMenu(menuChannelsView); } } break; case EVT_KEY_LONG(KEY_PAGE): if (curr > 0) cc = curr - 1; else cc = menuTabSize-1; killEvents(event); break; case EVT_KEY_BREAK(KEY_PAGE): if (curr < (menuTabSize-1)) cc = curr + 1; else cc = 0; break; } if (!calibrationState && cc != curr) { chainMenu((MenuFuncP)pgm_read_adr(&menuTab[cc])); } if (!(flags&CHECK_FLAG_NO_SCREEN_INDEX)) { displayScreenIndex(curr, menuTabSize, 0); } drawFilledRect(0, 0, LCD_W, MENU_HEADER_HEIGHT, SOLID, FILL_WHITE|GREY_DEFAULT); } DISPLAY_PROGRESS_BAR(menuTab ? lcdLastPos-2*FW-((curr+1)/10*FWNUM)-2 : 20*FW+1); switch(event) { case EVT_ENTRY: menuEntryTime = get_tmr10ms(); l_posVert = POS_VERT_INIT; l_posHorz = POS_HORZ_INIT(l_posVert); SET_SCROLLBAR_X(LCD_W-1); s_editMode = EDIT_MODE_INIT; break; case EVT_ENTRY_UP: menuEntryTime = get_tmr10ms(); s_editMode = 0; l_posHorz = POS_HORZ_INIT(l_posVert); SET_SCROLLBAR_X(LCD_W-1); break; case EVT_ROTARY_BREAK: if (s_editMode > 1) break; if (m_posHorz < 0 && maxcol > 0 && READ_ONLY_UNLOCKED()) { l_posHorz = 0; break; } if (READ_ONLY_UNLOCKED()) { s_editMode = (s_editMode<=0); } break; case EVT_KEY_LONG(KEY_EXIT): s_editMode = 0; // TODO needed? we call ENTRY_UP after which does the same popMenu(); break; case EVT_KEY_BREAK(KEY_EXIT): if (s_editMode>0) { s_editMode = 0; break; } if (l_posHorz >= 0 && (COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { l_posHorz = -1; } else { uint8_t posVertInit = POS_VERT_INIT; if (s_pgOfs != 0 || l_posVert != posVertInit) { s_pgOfs = 0; l_posVert = posVertInit; l_posHorz = POS_HORZ_INIT(l_posVert); } else { popMenu(); } } break; CASE_EVT_ROTARY_MOVE_RIGHT if (s_editMode != 0) break; if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { if (l_posHorz >= 0) { INC(l_posHorz, 0, maxcol); break; } } else { if (l_posHorz < maxcol) { l_posHorz++; break; } else { l_posHorz = 0; if (!IS_ROTARY_MOVE_RIGHT(event)) break; } } do { INC(l_posVert, POS_VERT_INIT, rowcount-1); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); s_editMode = 0; // if we go down, we must be in this mode l_posHorz = POS_HORZ_INIT(l_posVert); break; CASE_EVT_ROTARY_MOVE_LEFT if (s_editMode != 0) break; if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { if (l_posHorz >= 0) { DEC(l_posHorz, 0, maxcol); break; } } else { if (l_posHorz > 0) { l_posHorz--; break; } else if (IS_ROTARY_MOVE_LEFT(event) && s_editMode == 0) { l_posHorz = 0xff; } else { l_posHorz = maxcol; break; } } do { DEC(l_posVert, POS_VERT_INIT, rowcount-1); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); s_editMode = 0; // if we go up, we must be in this mode if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) l_posHorz = -1; else l_posHorz = min((uint8_t)l_posHorz, MAXCOL(l_posVert)); break; } int linesCount = rowcount; if (l_posVert == 0 || (l_posVert==1 && MAXCOL(vertpos_t(0)) >= HIDDEN_ROW) || (l_posVert==2 && MAXCOL(vertpos_t(0)) >= HIDDEN_ROW && MAXCOL(vertpos_t(1)) >= HIDDEN_ROW)) { s_pgOfs = 0; if (horTab) { linesCount = 0; for (int i=0; i<rowcount; i++) { if (i>=horTabMax || horTab[i] != HIDDEN_ROW) { linesCount++; } } } } else if (horTab) { if (rowcount > NUM_BODY_LINES) { while (1) { vertpos_t firstLine = 0; for (int numLines=0; firstLine<rowcount && numLines<s_pgOfs; firstLine++) { if (firstLine>=horTabMax || horTab[firstLine] != HIDDEN_ROW) { numLines++; } } if (l_posVert < firstLine) { s_pgOfs--; } else { vertpos_t lastLine = firstLine; for (int numLines=0; lastLine<rowcount && numLines<NUM_BODY_LINES; lastLine++) { if (lastLine>=horTabMax || horTab[lastLine] != HIDDEN_ROW) { numLines++; } } if (l_posVert >= lastLine) { s_pgOfs++; } else { linesCount = s_pgOfs + NUM_BODY_LINES; for (int i=lastLine; i<rowcount; i++) { if (i>=horTabMax || horTab[i] != HIDDEN_ROW) { linesCount++; } } break; } } } } } else { if (l_posVert>=NUM_BODY_LINES+s_pgOfs) { s_pgOfs = l_posVert-NUM_BODY_LINES+1; } else if (l_posVert<s_pgOfs) { s_pgOfs = l_posVert; } } if (scrollbar_X && linesCount > NUM_BODY_LINES) { displayScrollbar(scrollbar_X, MENU_HEADER_HEIGHT, LCD_H-MENU_HEADER_HEIGHT, s_pgOfs, linesCount, NUM_BODY_LINES); } if (name) { title(name); } m_posVert = l_posVert; m_posHorz = l_posHorz; }
bool _con(const pt &p, node *n, int c) { if (!n) return false; if (cmp(c)(p, n->p)) return _con(p, n->l, INC(c)); if (cmp(c)(n->p, p)) return _con(p, n->r, INC(c)); return true; }
/*INC A*/ static void op_0x3c(Z80EX_CONTEXT *cpu) { INC(A); T_WAIT_UNTIL(4); return; }
void request_stats_final(REQUEST *request) { if (request->master_state == REQUEST_COUNTED) return; if (!request->listener) return; if (!request->client) return; if ((request->listener->type != RAD_LISTEN_NONE) && #ifdef WITH_ACCOUNTING (request->listener->type != RAD_LISTEN_ACCT) && #endif #ifdef WITH_COA (request->listener->type != RAD_LISTEN_COA) && #endif (request->listener->type != RAD_LISTEN_AUTH)) return; #undef INC_AUTH #define INC_AUTH(_x) radius_auth_stats._x++;request->listener->stats._x++;request->client->auth._x++; #undef INC_ACCT #ifdef WITH_ACCOUNTING #define INC_ACCT(_x) radius_acct_stats._x++;request->listener->stats._x++;request->client->acct._x++ #else #define INC_ACCT(_x) #endif #undef INC_COA #ifdef WITH_COA #define INC_COA(_x) radius_coa_stats._x++;request->listener->stats._x++;request->client->coa._x++ #else #define INC_COA(_x) #endif #undef INC_DSC #ifdef WITH_DSC #define INC_DSC(_x) radius_dsc_stats._x++;request->listener->stats._x++;request->client->dsc._x++ #else #define INC_DSC(_x) #endif /* * Update the statistics. * * Note that we do NOT do this in a child thread. * Instead, we update the stats when a request is * deleted, because only the main server thread calls * this function, which makes it thread-safe. */ if (request->reply) switch (request->reply->code) { case PW_AUTHENTICATION_ACK: INC_AUTH(total_access_accepts); auth_stats: INC_AUTH(total_responses); /* * FIXME: Do the time calculations once... */ stats_time(&radius_auth_stats, &request->packet->timestamp, &request->reply->timestamp); stats_time(&request->client->auth, &request->packet->timestamp, &request->reply->timestamp); stats_time(&request->listener->stats, &request->packet->timestamp, &request->reply->timestamp); break; case PW_AUTHENTICATION_REJECT: INC_AUTH(total_access_rejects); goto auth_stats; case PW_ACCESS_CHALLENGE: INC_AUTH(total_access_challenges); goto auth_stats; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_RESPONSE: INC_ACCT(total_responses); stats_time(&radius_acct_stats, &request->packet->timestamp, &request->reply->timestamp); stats_time(&request->client->acct, &request->packet->timestamp, &request->reply->timestamp); break; #endif #ifdef WITH_COA case PW_COA_ACK: INC_COA(total_access_accepts); coa_stats: INC_COA(total_responses); stats_time(&request->client->coa, &request->packet->timestamp, &request->reply->timestamp); break; case PW_COA_NAK: INC_COA(total_access_rejects); goto coa_stats; case PW_DISCONNECT_ACK: INC_DSC(total_access_accepts); dsc_stats: INC_DSC(total_responses); stats_time(&request->client->dsc, &request->packet->timestamp, &request->reply->timestamp); break; case PW_DISCONNECT_NAK: INC_DSC(total_access_rejects); goto dsc_stats; #endif /* * No response, it must have been a bad * authenticator. */ case 0: if (request->packet->code == PW_AUTHENTICATION_REQUEST) { if (request->reply->offset == -2) { INC_AUTH(total_bad_authenticators); } else { INC_AUTH(total_packets_dropped); } } else if (request->packet->code == PW_ACCOUNTING_REQUEST) { if (request->reply->offset == -2) { INC_ACCT(total_bad_authenticators); } else { INC_ACCT(total_packets_dropped); } } break; default: break; } #ifdef WITH_PROXY if (!request->proxy || !request->proxy_listener) goto done; /* simplifies formatting */ switch (request->proxy->code) { case PW_AUTHENTICATION_REQUEST: proxy_auth_stats.total_requests += request->num_proxied_requests; request->proxy_listener->stats.total_requests += request->num_proxied_requests; request->home_server->stats.total_requests += request->num_proxied_requests; break; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_REQUEST: proxy_acct_stats.total_requests++; request->proxy_listener->stats.total_requests += request->num_proxied_requests; request->home_server->stats.total_requests += request->num_proxied_requests; break; #endif default: break; } if (!request->proxy_reply) goto done; /* simplifies formatting */ #undef INC #define INC(_x) proxy_auth_stats._x += request->num_proxied_responses; request->proxy_listener->stats._x += request->num_proxied_responses; request->home_server->stats._x += request->num_proxied_responses; switch (request->proxy_reply->code) { case PW_AUTHENTICATION_ACK: INC(total_access_accepts); proxy_stats: INC(total_responses); stats_time(&proxy_auth_stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); stats_time(&request->home_server->stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); break; case PW_AUTHENTICATION_REJECT: INC(total_access_rejects); goto proxy_stats; case PW_ACCESS_CHALLENGE: INC(total_access_challenges); goto proxy_stats; #ifdef WITH_ACCOUNTING case PW_ACCOUNTING_RESPONSE: proxy_acct_stats.total_responses++; request->proxy_listener->stats.total_responses++; request->home_server->stats.total_responses++; stats_time(&proxy_acct_stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); stats_time(&request->home_server->stats, &request->proxy->timestamp, &request->proxy_reply->timestamp); break; #endif default: proxy_auth_stats.total_unknown_types++; request->proxy_listener->stats.total_unknown_types++; request->home_server->stats.total_unknown_types++; break; } done: #endif /* WITH_PROXY */ request->master_state = REQUEST_COUNTED; }
void setUpdatedDiscovery(void) { INC(eventDiscovery); }