~eliasnaur/gio

gio/internal/ops/reader.go -rw-r--r-- 3.5 KiB View raw
efce78d4metaclips example/kitchen: add ProgressBar example 7 days ago
                                                                                
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
// SPDX-License-Identifier: Unlicense OR MIT

package ops

import (
	"encoding/binary"

	"gioui.org/internal/opconst"
	"gioui.org/op"
)

// Reader parses an ops list.
type Reader struct {
	pc    pc
	stack []macro
	ops   *op.Ops
}

// EncodedOp represents an encoded op returned by
// Reader.
type EncodedOp struct {
	Key  Key
	Data []byte
	Refs []interface{}
}

// Key is a unique key for a given op.
type Key struct {
	ops     *op.Ops
	pc      int
	version int
}

// Shadow of op.MacroOp.
type macroOp struct {
	pc pc
}

// Shadow of op.CallOp.
type callOp struct {
	ops *op.Ops
}

type pc struct {
	data int
	refs int
}

type macro struct {
	ops   *op.Ops
	retPC pc
	endPC pc
}

type opMacroDef struct {
	endpc pc
}

// Reset start reading from the op list.
func (r *Reader) Reset(ops *op.Ops) {
7 references
r.stack = r.stack[:0] r.pc = pc{} r.ops = ops } func (r *Reader) Decode() (EncodedOp, bool) {
14 references
if r.ops == nil { return EncodedOp{}, false } for { if len(r.stack) > 0 { b := r.stack[len(r.stack)-1] if r.pc == b.endPC { r.ops = b.ops r.pc = b.retPC r.stack = r.stack[:len(r.stack)-1] continue } } data := r.ops.Data() data = data[r.pc.data:] if len(data) == 0 { return EncodedOp{}, false } key := Key{ops: r.ops, pc: r.pc.data, version: r.ops.Version()} t := opconst.OpType(data[0]) n := t.Size() nrefs := t.NumRefs() data = data[:n] refs := r.ops.Refs() refs = refs[r.pc.refs:] refs = refs[:nrefs] switch t { case opconst.TypeAux: // An Aux operations is always wrapped in a macro, and // its length is the remaining space. block := r.stack[len(r.stack)-1] n += block.endPC.data - r.pc.data - opconst.TypeAuxLen data = data[:n] case opconst.TypeCall: var op callOp op.decode(data, refs) endPC := pc{ data: len(op.ops.Data()), refs: len(op.ops.Refs()), } retPC := r.pc retPC.data += n retPC.refs += nrefs r.stack = append(r.stack, macro{ ops: r.ops, retPC: retPC, endPC: endPC, }) r.pc = pc{} r.ops = op.ops continue case opconst.TypeMacro: var op macroOp op.decode(data) macroData := r.ops.Data()[op.pc.data:] if opconst.OpType(macroData[0]) != opconst.TypeMacroDef { panic("invalid macro reference") } var opDef opMacroDef opDef.decode(macroData[:opconst.TypeMacroDef.Size()]) retPC := r.pc retPC.data += n retPC.refs += nrefs r.stack = append(r.stack, macro{ ops: r.ops, retPC: retPC, endPC: opDef.endpc, }) r.pc = op.pc r.pc.data += opconst.TypeMacroDef.Size() r.pc.refs += opconst.TypeMacroDef.NumRefs() continue case opconst.TypeMacroDef: var op opMacroDef op.decode(data) r.pc = op.endpc continue } r.pc.data += n r.pc.refs += nrefs return EncodedOp{Key: key, Data: data, Refs: refs}, true } } func (op *opMacroDef) decode(data []byte) {
2 references
if opconst.OpType(data[0]) != opconst.TypeMacroDef { panic("invalid op") } bo := binary.LittleEndian dataIdx := int(int32(bo.Uint32(data[1:]))) refsIdx := int(int32(bo.Uint32(data[5:]))) *op = opMacroDef{ endpc: pc{ data: dataIdx, refs: refsIdx, }, } } func (m *callOp) decode(data []byte, refs []interface{}) {
1 reference
if opconst.OpType(data[0]) != opconst.TypeCall { panic("invalid op") } *m = callOp{ ops: refs[0].(*op.Ops), } } func (m *macroOp) decode(data []byte) {
1 reference
if opconst.OpType(data[0]) != opconst.TypeMacro { panic("invalid op") } bo := binary.LittleEndian dataIdx := int(int32(bo.Uint32(data[1:]))) refsIdx := int(int32(bo.Uint32(data[5:]))) *m = macroOp{ pc: pc{ data: dataIdx, refs: refsIdx, }, } }