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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
# SPDX-FileCopyrightText: 2022 UnionTech Software Technology Co., Ltd.
#
# SPDX-License-Identifier: GPL-3.0-or-later
import sys
from common import *
from enum import *
import argparse
import subprocess
error_names = []
request_names = []
max_error_code = 0
x_prefix = ''
parser = argparse.ArgumentParser()
parser.add_argument('xml_file')
parser.add_argument('-o', '--output', dest='output', default='/dev/stdout')
parser.add_argument('-F', '--no-fmt', dest='no_fmt', action='store_true')
parser.add_argument('-p', '--package', dest='package')
parser.add_argument(
'-I', '--no-import-x', dest='no_import_x', action='store_true')
args = parser.parse_args()
def go_open(self):
set_namespace(self.namespace)
_ns = get_namespace()
global args
if args.package is not None:
pkg = args.package
else:
# pkg = _ns.header
if _ns.is_ext:
pkg = get_go_pkg_name(_ns.ext_name)
else:
pkg = 'x'
set_level(0)
l('package %s', pkg)
if pkg != 'x':
l('import x "github.com/linuxdeepin/go-x11-client"')
global x_prefix
x_prefix = 'x.'
if _ns.is_ext:
l('// _ns.ext_name: %s', _ns.ext_name)
l('const MajorVersion = %d', int(_ns.major_version))
l('const MinorVersion = %d', int(_ns.minor_version))
l('var _ext *%sExtension', x_prefix)
l('func Ext() *x.Extension {')
l(' return _ext')
l('}')
def go_close(self):
# handle errors
_ns = get_namespace()
global error_names
global request_names
global x_prefix
if len(error_names) > 0:
l("var errorCodeNameMap = map[uint8]string{")
for name in error_names:
error_code = get_type_name(name) + "ErrorCode"
error_name = get_type_name(name)
if not error_name.startswith("Bad"):
error_name = "Bad" + error_name
if error_name == "BadDeviceBusy":
error_name = "DeviceBusy"
l("%s : \"%s\",", error_code, error_name)
l("}") # end error code name map
if len(request_names) > 0:
l("var requestOpcodeNameMap = map[uint]string{")
for name in request_names:
l("%sOpcode : \"%s\",", name, name)
l("}") # end request opcode name map
if _ns.is_ext:
l("func init() {")
errMap = "nil"
if len(error_names) > 0:
errMap = "errorCodeNameMap"
reqMap = "nil"
if len(request_names) > 0:
reqMap = "requestOpcodeNameMap"
l('_ext = %sNewExtension("%s", %d, %s, %s)', x_prefix, _ns.ext_xname, max_error_code, errMap, reqMap)
l("}") # end func init
# write source file
global args
gofile = open(args.output, 'w')
if args.no_fmt:
output_lines(gofile)
else:
pipe = subprocess.Popen(
'gofmt', bufsize=4096, stdin=subprocess.PIPE, stdout=gofile)
output_lines(pipe.stdin)
pipe.wait()
if pipe.returncode != 0:
# write no formated code and raise exception.
output_lines(gofile)
raise Exception("gofmt exit with error code %d" % pipe.returncode)
def go_simple(self, name):
if self.name != name:
type_name = get_type_name(name)
source_type_name = get_type_name(self.name)
set_level(0)
l("// simple %s", name)
l("type %s %s", type_name, source_type_name)
def go_enum(self, name):
prefix = get_enum_prefix(name)
set_level(0)
l("// enum %s", prefix)
l('const (')
for (item_name, val) in self.values:
item_name = get_enum_item_name(item_name)
l("%s%s = %s", prefix, item_name, val)
# newline
l(')\n')
def go_struct(self, name):
pass
def go_union(self, name):
pass
def go_request(self, name):
global request_names
name_base = get_request_name(name)
opcode_name = name_base + "Opcode"
l("const %s = %s", opcode_name, self.opcode)
request_names.append(name_base)
if self.reply:
l("type %s %sSeqNum", name_base + "Cookie", x_prefix)
def go_event(self, name):
type_name = get_type_name(name) + "Event"
code_name = type_name + "Code"
code = self.opcodes[name]
l('const %s = %d', code_name, int(code))
define_go_event_new_func(type_name)
def define_go_event_new_func(go_type):
global x_prefix
l('\nfunc New%s(data []byte) (*%s, error) {', go_type, go_type)
l('var ev %s', go_type)
l('r := %sNewReaderFromData(data)', x_prefix)
l('err := read%s(r, &ev)', go_type)
l('if err != nil {')
l(' return nil, err')
l('}')
l('return &ev, nil')
l('}')
def go_error(self, name):
global max_error_code
global error_names
type_name = get_type_name(name) + 'Error'
code_name = type_name + "Code"
code = int(self.opcodes[name])
l('const %s = %d', code_name, code)
error_names.append(name)
if code > max_error_code:
max_error_code = code
def go_eventstruct(self, name):
pass
output = {
'open': go_open,
'close': go_close,
'simple': go_simple,
'enum': go_enum,
'struct': go_struct,
'union': go_union,
'request': go_request,
'event': go_event,
'error': go_error,
'eventstruct': go_eventstruct,
}
# Import the module class
from xcbgen.state import Module
from xcbgen.xtypes import *
# Parse the xml header
module = Module(args.xml_file, output)
# Build type-registry and resolve type dependencies
module.register()
module.resolve()
# Output the code
module.generate()
|
