← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/1.6.1.patch/scripts/qapi.py

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/1.6.1.patch/scripts/qapi.py
 
1
#
 
2
# QAPI helper library
 
3
#
 
4
# Copyright IBM, Corp. 2011
 
5
# Copyright (c) 2013 Red Hat Inc.
 
6
#
 
7
# Authors:
 
8
#  Anthony Liguori <aliguori@us.ibm.com>
 
9
#  Markus Armbruster <armbru@redhat.com>
 
10
#
 
11
# This work is licensed under the terms of the GNU GPLv2.
 
12
# See the COPYING.LIB file in the top-level directory.
 
13
 
 
14
from ordereddict import OrderedDict
 
15
import sys
 
16
 
 
17
builtin_types = [
 
18
    'str', 'int', 'number', 'bool',
 
19
    'int8', 'int16', 'int32', 'int64',
 
20
    'uint8', 'uint16', 'uint32', 'uint64'
 
21
]
 
22
 
 
23
builtin_type_qtypes = {
 
24
    'str':      'QTYPE_QSTRING',
 
25
    'int':      'QTYPE_QINT',
 
26
    'number':   'QTYPE_QFLOAT',
 
27
    'bool':     'QTYPE_QBOOL',
 
28
    'int8':     'QTYPE_QINT',
 
29
    'int16':    'QTYPE_QINT',
 
30
    'int32':    'QTYPE_QINT',
 
31
    'int64':    'QTYPE_QINT',
 
32
    'uint8':    'QTYPE_QINT',
 
33
    'uint16':   'QTYPE_QINT',
 
34
    'uint32':   'QTYPE_QINT',
 
35
    'uint64':   'QTYPE_QINT',
 
36
}
 
37
 
 
38
class QAPISchemaError(Exception):
 
39
    def __init__(self, schema, msg):
 
40
        self.fp = schema.fp
 
41
        self.msg = msg
 
42
        self.line = self.col = 1
 
43
        for ch in schema.src[0:schema.pos]:
 
44
            if ch == '\n':
 
45
                self.line += 1
 
46
                self.col = 1
 
47
            elif ch == '\t':
 
48
                self.col = (self.col + 7) % 8 + 1
 
49
            else:
 
50
                self.col += 1
 
51
 
 
52
    def __str__(self):
 
53
        return "%s:%s:%s: %s" % (self.fp.name, self.line, self.col, self.msg)
 
54
 
 
55
class QAPISchema:
 
56
 
 
57
    def __init__(self, fp):
 
58
        self.fp = fp
 
59
        self.src = fp.read()
 
60
        if self.src == '' or self.src[-1] != '\n':
 
61
            self.src += '\n'
 
62
        self.cursor = 0
 
63
        self.exprs = []
 
64
        self.accept()
 
65
 
 
66
        while self.tok != None:
 
67
            self.exprs.append(self.get_expr(False))
 
68
 
 
69
    def accept(self):
 
70
        while True:
 
71
            self.tok = self.src[self.cursor]
 
72
            self.pos = self.cursor
 
73
            self.cursor += 1
 
74
            self.val = None
 
75
 
 
76
            if self.tok == '#':
 
77
                self.cursor = self.src.find('\n', self.cursor)
 
78
            elif self.tok in ['{', '}', ':', ',', '[', ']']:
 
79
                return
 
80
            elif self.tok == "'":
 
81
                string = ''
 
82
                esc = False
 
83
                while True:
 
84
                    ch = self.src[self.cursor]
 
85
                    self.cursor += 1
 
86
                    if ch == '\n':
 
87
                        raise QAPISchemaError(self,
 
88
                                              'Missing terminating "\'"')
 
89
                    if esc:
 
90
                        string += ch
 
91
                        esc = False
 
92
                    elif ch == "\\":
 
93
                        esc = True
 
94
                    elif ch == "'":
 
95
                        self.val = string
 
96
                        return
 
97
                    else:
 
98
                        string += ch
 
99
            elif self.tok == '\n':
 
100
                if self.cursor == len(self.src):
 
101
                    self.tok = None
 
102
                    return
 
103
            elif not self.tok.isspace():
 
104
                raise QAPISchemaError(self, 'Stray "%s"' % self.tok)
 
105
 
 
106
    def get_members(self):
 
107
        expr = OrderedDict()
 
108
        if self.tok == '}':
 
109
            self.accept()
 
110
            return expr
 
111
        if self.tok != "'":
 
112
            raise QAPISchemaError(self, 'Expected string or "}"')
 
113
        while True:
 
114
            key = self.val
 
115
            self.accept()
 
116
            if self.tok != ':':
 
117
                raise QAPISchemaError(self, 'Expected ":"')
 
118
            self.accept()
 
119
            expr[key] = self.get_expr(True)
 
120
            if self.tok == '}':
 
121
                self.accept()
 
122
                return expr
 
123
            if self.tok != ',':
 
124
                raise QAPISchemaError(self, 'Expected "," or "}"')
 
125
            self.accept()
 
126
            if self.tok != "'":
 
127
                raise QAPISchemaError(self, 'Expected string')
 
128
 
 
129
    def get_values(self):
 
130
        expr = []
 
131
        if self.tok == ']':
 
132
            self.accept()
 
133
            return expr
 
134
        if not self.tok in [ '{', '[', "'" ]:
 
135
            raise QAPISchemaError(self, 'Expected "{", "[", "]" or string')
 
136
        while True:
 
137
            expr.append(self.get_expr(True))
 
138
            if self.tok == ']':
 
139
                self.accept()
 
140
                return expr
 
141
            if self.tok != ',':
 
142
                raise QAPISchemaError(self, 'Expected "," or "]"')
 
143
            self.accept()
 
144
 
 
145
    def get_expr(self, nested):
 
146
        if self.tok != '{' and not nested:
 
147
            raise QAPISchemaError(self, 'Expected "{"')
 
148
        if self.tok == '{':
 
149
            self.accept()
 
150
            expr = self.get_members()
 
151
        elif self.tok == '[':
 
152
            self.accept()
 
153
            expr = self.get_values()
 
154
        elif self.tok == "'":
 
155
            expr = self.val
 
156
            self.accept()
 
157
        else:
 
158
            raise QAPISchemaError(self, 'Expected "{", "[" or string')
 
159
        return expr
 
160
 
 
161
def parse_schema(fp):
 
162
    try:
 
163
        schema = QAPISchema(fp)
 
164
    except QAPISchemaError as e:
 
165
        print >>sys.stderr, e
 
166
        exit(1)
 
167
 
 
168
    exprs = []
 
169
 
 
170
    for expr in schema.exprs:
 
171
        if expr.has_key('enum'):
 
172
            add_enum(expr['enum'])
 
173
        elif expr.has_key('union'):
 
174
            add_union(expr)
 
175
            add_enum('%sKind' % expr['union'])
 
176
        elif expr.has_key('type'):
 
177
            add_struct(expr)
 
178
        exprs.append(expr)
 
179
 
 
180
    return exprs
 
181
 
 
182
def parse_args(typeinfo):
 
183
    if isinstance(typeinfo, basestring):
 
184
        struct = find_struct(typeinfo)
 
185
        assert struct != None
 
186
        typeinfo = struct['data']
 
187
 
 
188
    for member in typeinfo:
 
189
        argname = member
 
190
        argentry = typeinfo[member]
 
191
        optional = False
 
192
        structured = False
 
193
        if member.startswith('*'):
 
194
            argname = member[1:]
 
195
            optional = True
 
196
        if isinstance(argentry, OrderedDict):
 
197
            structured = True
 
198
        yield (argname, argentry, optional, structured)
 
199
 
 
200
def de_camel_case(name):
 
201
    new_name = ''
 
202
    for ch in name:
 
203
        if ch.isupper() and new_name:
 
204
            new_name += '_'
 
205
        if ch == '-':
 
206
            new_name += '_'
 
207
        else:
 
208
            new_name += ch.lower()
 
209
    return new_name
 
210
 
 
211
def camel_case(name):
 
212
    new_name = ''
 
213
    first = True
 
214
    for ch in name:
 
215
        if ch in ['_', '-']:
 
216
            first = True
 
217
        elif first:
 
218
            new_name += ch.upper()
 
219
            first = False
 
220
        else:
 
221
            new_name += ch.lower()
 
222
    return new_name
 
223
 
 
224
def c_var(name, protect=True):
 
225
    # ANSI X3J11/88-090, 3.1.1
 
226
    c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue',
 
227
                     'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
 
228
                     'for', 'goto', 'if', 'int', 'long', 'register', 'return',
 
229
                     'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
 
230
                     'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'])
 
231
    # ISO/IEC 9899:1999, 6.4.1
 
232
    c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
 
233
    # ISO/IEC 9899:2011, 6.4.1
 
234
    c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
 
235
                     '_Static_assert', '_Thread_local'])
 
236
    # GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
 
237
    # excluding _.*
 
238
    gcc_words = set(['asm', 'typeof'])
 
239
    # namespace pollution:
 
240
    polluted_words = set(['unix'])
 
241
    if protect and (name in c89_words | c99_words | c11_words | gcc_words | polluted_words):
 
242
        return "q_" + name
 
243
    return name.replace('-', '_').lstrip("*")
 
244
 
 
245
def c_fun(name, protect=True):
 
246
    return c_var(name, protect).replace('.', '_')
 
247
 
 
248
def c_list_type(name):
 
249
    return '%sList' % name
 
250
 
 
251
def type_name(name):
 
252
    if type(name) == list:
 
253
        return c_list_type(name[0])
 
254
    return name
 
255
 
 
256
enum_types = []
 
257
struct_types = []
 
258
union_types = []
 
259
 
 
260
def add_struct(definition):
 
261
    global struct_types
 
262
    struct_types.append(definition)
 
263
 
 
264
def find_struct(name):
 
265
    global struct_types
 
266
    for struct in struct_types:
 
267
        if struct['type'] == name:
 
268
            return struct
 
269
    return None
 
270
 
 
271
def add_union(definition):
 
272
    global union_types
 
273
    union_types.append(definition)
 
274
 
 
275
def find_union(name):
 
276
    global union_types
 
277
    for union in union_types:
 
278
        if union['union'] == name:
 
279
            return union
 
280
    return None
 
281
 
 
282
def add_enum(name):
 
283
    global enum_types
 
284
    enum_types.append(name)
 
285
 
 
286
def is_enum(name):
 
287
    global enum_types
 
288
    return (name in enum_types)
 
289
 
 
290
def c_type(name):
 
291
    if name == 'str':
 
292
        return 'char *'
 
293
    elif name == 'int':
 
294
        return 'int64_t'
 
295
    elif (name == 'int8' or name == 'int16' or name == 'int32' or
 
296
          name == 'int64' or name == 'uint8' or name == 'uint16' or
 
297
          name == 'uint32' or name == 'uint64'):
 
298
        return name + '_t'
 
299
    elif name == 'size':
 
300
        return 'uint64_t'
 
301
    elif name == 'bool':
 
302
        return 'bool'
 
303
    elif name == 'number':
 
304
        return 'double'
 
305
    elif type(name) == list:
 
306
        return '%s *' % c_list_type(name[0])
 
307
    elif is_enum(name):
 
308
        return name
 
309
    elif name == None or len(name) == 0:
 
310
        return 'void'
 
311
    elif name == name.upper():
 
312
        return '%sEvent *' % camel_case(name)
 
313
    else:
 
314
        return '%s *' % name
 
315
 
 
316
def genindent(count):
 
317
    ret = ""
 
318
    for i in range(count):
 
319
        ret += " "
 
320
    return ret
 
321
 
 
322
indent_level = 0
 
323
 
 
324
def push_indent(indent_amount=4):
 
325
    global indent_level
 
326
    indent_level += indent_amount
 
327
 
 
328
def pop_indent(indent_amount=4):
 
329
    global indent_level
 
330
    indent_level -= indent_amount
 
331
 
 
332
def cgen(code, **kwds):
 
333
    indent = genindent(indent_level)
 
334
    lines = code.split('\n')
 
335
    lines = map(lambda x: indent + x, lines)
 
336
    return '\n'.join(lines) % kwds + '\n'
 
337
 
 
338
def mcgen(code, **kwds):
 
339
    return cgen('\n'.join(code.split('\n')[1:-1]), **kwds)
 
340
 
 
341
def basename(filename):
 
342
    return filename.split("/")[-1]
 
343
 
 
344
def guardname(filename):
 
345
    guard = basename(filename).rsplit(".", 1)[0]
 
346
    for substr in [".", " ", "-"]:
 
347
        guard = guard.replace(substr, "_")
 
348
    return guard.upper() + '_H'
 
349
 
 
350
def guardstart(name):
 
351
    return mcgen('''
 
352
 
 
353
#ifndef %(name)s
 
354
#define %(name)s
 
355
 
 
356
''',
 
357
                 name=guardname(name))
 
358
 
 
359
def guardend(name):
 
360
    return mcgen('''
 
361
 
 
362
#endif /* %(name)s */
 
363
 
 
364
''',
 
365
                 name=guardname(name))