Return to events_normal.h CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src / cpu

Annotation of hatari/src/cpu/events_normal.h, revision 1.1.1.1

1.1       root        1: 
                      2: STATIC_INLINE void cycles_do_special (void)
                      3: {
                      4: }
                      5: STATIC_INLINE void set_cycles (int c)
                      6: {
                      7: }
                      8: 
                      9: STATIC_INLINE void events_schedule (void)
                     10: {
                     11:        int i;
                     12: 
                     13:        unsigned long int mintime = ~0L;
                     14:        for (i = 0; i < ev_max; i++) {
                     15:                if (eventtab[i].active) {
                     16:                        unsigned long int eventtime = eventtab[i].evtime - currcycle;
                     17:                        if (eventtime < mintime)
                     18:                                mintime = eventtime;
                     19:                }
                     20:        }
                     21:        nextevent = currcycle + mintime;
                     22: }
                     23: 
                     24: STATIC_INLINE void do_cycles_slow (unsigned long cycles_to_add)
                     25: {
                     26:        if (is_lastline && eventtab[ev_hsync].evtime - currcycle <= cycles_to_add
                     27:                && (long int)(read_processor_time () - vsyncmintime) < 0)
                     28:                return;
                     29: 
                     30:        while ((nextevent - currcycle) <= cycles_to_add) {
                     31:                int i;
                     32:                cycles_to_add -= (nextevent - currcycle);
                     33:                currcycle = nextevent;
                     34: 
                     35:                for (i = 0; i < ev_max; i++) {
                     36:                        if (eventtab[i].active && eventtab[i].evtime == currcycle) {
                     37:                                (*eventtab[i].handler)();
                     38:                        }
                     39:                }
                     40:                events_schedule();
                     41:        }
                     42:        currcycle += cycles_to_add;
                     43: }
                     44: 
                     45: STATIC_INLINE void do_cycles_fast (void)
                     46: {
                     47:        if (is_lastline && eventtab[ev_hsync].evtime - currcycle <= 1
                     48:                && (long int)(read_processor_time () - vsyncmintime) < 0)
                     49:                return;
                     50: 
                     51:        currcycle++;
                     52:        if (nextevent == currcycle) {
                     53:                int i;
                     54: 
                     55:                for (i = 0; i < ev_max; i++) {
                     56:                        if (eventtab[i].active && eventtab[i].evtime == currcycle) {
                     57:                                (*eventtab[i].handler) ();
                     58:                        }
                     59:                }
                     60:                events_schedule();
                     61:        }
                     62: 
                     63: }
                     64: 
                     65: /* This is a special-case function.  Normally, all events should lie in the
                     66: future; they should only ever be active at the current cycle during
                     67: do_cycles.  However, a snapshot is saved during do_cycles, and so when
                     68: restoring it, we may have other events pending.  */
                     69: STATIC_INLINE void handle_active_events (void)
                     70: {
                     71:        int i;
                     72:        for (i = 0; i < ev_max; i++) {
                     73:                if (eventtab[i].active && eventtab[i].evtime == currcycle) {
                     74:                        (*eventtab[i].handler)();
                     75:                }
                     76:        }
                     77: }
                     78: 
                     79: STATIC_INLINE unsigned long get_cycles (void)
                     80: {
                     81:        return currcycle;
                     82: }
                     83: 
                     84: extern void init_eventtab (void);
                     85: 
                     86: #if /* M68K_SPEED == 1 */  0
                     87: #define do_cycles do_cycles_fast
                     88: #else
                     89: #define do_cycles do_cycles_slow
                     90: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.