forked from lkesteloot/trs80emu
-
Notifications
You must be signed in to change notification settings - Fork 0
/
event.go
111 lines (89 loc) · 2.47 KB
/
event.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
// Copyright 2012 Lawrence Kesteloot
package main
// Infrastructure to trigger events in the future. This is usually for hardware events.
import (
"log"
)
const (
eventDiskDone = eventType(1 << iota)
eventDiskLostData
eventDiskFirstDrq
eventKickOffCassette
// Masks for multiple events.
eventDisk = eventDiskDone | eventDiskLostData | eventDiskFirstDrq
)
type eventType uint
type eventCallback func()
// A single scheduled event.
type event struct {
eventType eventType
callback eventCallback
clock uint64
next *event
}
// All scheduled events.
type events struct {
head *event
}
// Queue up an event to happen at clock, using a delta clock relative to the
// current time.
func (vm *vm) addEvent(eventType eventType, callback eventCallback, deltaClock uint64) {
vm.events.add(eventType, callback, vm.clock+deltaClock)
}
// Queue up an event to happen at clock.
func (events *events) add(eventType eventType, callback eventCallback, clock uint64) {
event := &event{eventType, callback, clock, nil}
// Insert into list sorted by clock.
eventPtr := &events.head
place := 0
for *eventPtr != nil && (*eventPtr).clock < clock {
*eventPtr = (*eventPtr).next
place++
}
event.next = *eventPtr
*eventPtr = event
if eventDebug {
log.Printf("events.add(%d at %d in place %d)", eventType, clock, place)
}
}
// Dispatch all events that are scheduled for clock or later.
func (events *events) dispatch(clock uint64) {
for events.head != nil && events.head.clock <= clock {
// Remove from list before calling, to allow callback to
// modify the list.
event := events.head
events.head = event.next
if eventDebug {
log.Printf("events.dispatch(%d at %d)", event.eventType, clock)
}
event.callback()
}
}
// Remove all events in list that match the mask eventMask.
func (events *events) cancelEvents(eventMask eventType) {
eventPtr := &events.head
for *eventPtr != nil {
nextEventPtr := &(*eventPtr).next
eventType := (*eventPtr).eventType
if eventType&eventMask != 0 {
// Remove it from list.
*eventPtr = *nextEventPtr
if eventDebug {
log.Printf("events.cancelEvents(%d)", eventType)
}
} else {
// Move to next one.
eventPtr = nextEventPtr
}
}
}
// Returns the first event that matches the specified mask, or nil if none are
// found.
func (events *events) getFirstEvent(eventMask eventType) *event {
for event := events.head; event != nil; event = event.next {
if event.eventType&eventMask != 0 {
return event
}
}
return nil
}