4 # Copyright IBM, Corp. 2011
5 # Copyright (c) 2013-2015 Red Hat Inc.
8 # Anthony Liguori <aliguori@us.ibm.com>
9 # Markus Armbruster <armbru@redhat.com>
11 # This work is licensed under the terms of the GNU GPL, version 2.
12 # See the COPYING file in the top-level directory.
15 from ordereddict
import OrderedDict
23 'str': 'QTYPE_QSTRING',
25 'number': 'QTYPE_QFLOAT',
26 'bool': 'QTYPE_QBOOL',
28 'int16': 'QTYPE_QINT',
29 'int32': 'QTYPE_QINT',
30 'int64': 'QTYPE_QINT',
31 'uint8': 'QTYPE_QINT',
32 'uint16': 'QTYPE_QINT',
33 'uint32': 'QTYPE_QINT',
34 'uint64': 'QTYPE_QINT',
36 'any': None, # any qtype_code possible, actually
39 # Whitelist of commands allowed to return a non-dictionary
42 'human-monitor-command',
44 'query-migrate-cache-size',
51 'guest-fsfreeze-freeze',
52 'guest-fsfreeze-freeze-list',
53 'guest-fsfreeze-status',
54 'guest-fsfreeze-thaw',
58 'guest-sync-delimited',
60 # From qapi-schema-test:
71 # Parsing the schema into expressions
74 def error_path(parent
):
77 res
= ("In file included from %s:%d:\n" % (parent
['file'],
78 parent
['line'])) + res
79 parent
= parent
['parent']
82 class QAPISchemaError(Exception):
83 def __init__(self
, schema
, msg
):
84 self
.fname
= schema
.fname
87 self
.line
= schema
.line
88 for ch
in schema
.src
[schema
.line_pos
:schema
.pos
]:
90 self
.col
= (self
.col
+ 7) % 8 + 1
93 self
.info
= schema
.incl_info
96 return error_path(self
.info
) + \
97 "%s:%d:%d: %s" % (self
.fname
, self
.line
, self
.col
, self
.msg
)
99 class QAPIExprError(Exception):
100 def __init__(self
, expr_info
, msg
):
101 self
.info
= expr_info
105 return error_path(self
.info
['parent']) + \
106 "%s:%d: %s" % (self
.info
['file'], self
.info
['line'], self
.msg
)
108 class QAPISchemaParser(object):
110 def __init__(self
, fp
, previously_included
= [], incl_info
= None):
111 abs_fname
= os
.path
.abspath(fp
.name
)
114 previously_included
.append(abs_fname
)
115 self
.incl_info
= incl_info
117 if self
.src
== '' or self
.src
[-1] != '\n':
125 while self
.tok
!= None:
126 expr_info
= {'file': fname
, 'line': self
.line
,
127 'parent': self
.incl_info
}
128 expr
= self
.get_expr(False)
129 if isinstance(expr
, dict) and "include" in expr
:
131 raise QAPIExprError(expr_info
, "Invalid 'include' directive")
132 include
= expr
["include"]
133 if not isinstance(include
, str):
134 raise QAPIExprError(expr_info
,
135 'Expected a file name (string), got: %s'
137 incl_abs_fname
= os
.path
.join(os
.path
.dirname(abs_fname
),
139 # catch inclusion cycle
142 if incl_abs_fname
== os
.path
.abspath(inf
['file']):
143 raise QAPIExprError(expr_info
, "Inclusion loop for %s"
146 # skip multiple include of the same file
147 if incl_abs_fname
in previously_included
:
150 fobj
= open(incl_abs_fname
, 'r')
152 raise QAPIExprError(expr_info
,
153 '%s: %s' % (e
.strerror
, include
))
154 exprs_include
= QAPISchemaParser(fobj
, previously_included
,
156 self
.exprs
.extend(exprs_include
.exprs
)
158 expr_elem
= {'expr': expr
,
160 self
.exprs
.append(expr_elem
)
164 self
.tok
= self
.src
[self
.cursor
]
165 self
.pos
= self
.cursor
170 self
.cursor
= self
.src
.find('\n', self
.cursor
)
171 elif self
.tok
in ['{', '}', ':', ',', '[', ']']:
173 elif self
.tok
== "'":
177 ch
= self
.src
[self
.cursor
]
180 raise QAPISchemaError(self
,
181 'Missing terminating "\'"')
195 for x
in range(0, 4):
196 ch
= self
.src
[self
.cursor
]
198 if ch
not in "0123456789abcdefABCDEF":
199 raise QAPISchemaError(self
,
200 '\\u escape needs 4 '
202 value
= (value
<< 4) + int(ch
, 16)
203 # If Python 2 and 3 didn't disagree so much on
204 # how to handle Unicode, then we could allow
205 # Unicode string defaults. But most of QAPI is
206 # ASCII-only, so we aren't losing much for now.
207 if not value
or value
> 0x7f:
208 raise QAPISchemaError(self
,
209 'For now, \\u escape '
210 'only supports non-zero '
211 'values up to \\u007f')
216 raise QAPISchemaError(self
,
217 "Unknown escape \\%s" %ch
)
226 elif self
.src
.startswith("true", self
.pos
):
230 elif self
.src
.startswith("false", self
.pos
):
234 elif self
.src
.startswith("null", self
.pos
):
238 elif self
.tok
== '\n':
239 if self
.cursor
== len(self
.src
):
243 self
.line_pos
= self
.cursor
244 elif not self
.tok
.isspace():
245 raise QAPISchemaError(self
, 'Stray "%s"' % self
.tok
)
247 def get_members(self
):
253 raise QAPISchemaError(self
, 'Expected string or "}"')
258 raise QAPISchemaError(self
, 'Expected ":"')
261 raise QAPISchemaError(self
, 'Duplicate key "%s"' % key
)
262 expr
[key
] = self
.get_expr(True)
267 raise QAPISchemaError(self
, 'Expected "," or "}"')
270 raise QAPISchemaError(self
, 'Expected string')
272 def get_values(self
):
277 if not self
.tok
in "{['tfn":
278 raise QAPISchemaError(self
, 'Expected "{", "[", "]", string, '
281 expr
.append(self
.get_expr(True))
286 raise QAPISchemaError(self
, 'Expected "," or "]"')
289 def get_expr(self
, nested
):
290 if self
.tok
!= '{' and not nested
:
291 raise QAPISchemaError(self
, 'Expected "{"')
294 expr
= self
.get_members()
295 elif self
.tok
== '[':
297 expr
= self
.get_values()
298 elif self
.tok
in "'tfn":
302 raise QAPISchemaError(self
, 'Expected "{", "[" or string')
306 # Semantic analysis of schema expressions
307 # TODO fold into QAPISchema
308 # TODO catching name collisions in generated code would be nice
311 def find_base_fields(base
):
312 base_struct_define
= find_struct(base
)
313 if not base_struct_define
:
315 return base_struct_define
['data']
317 # Return the qtype of an alternate branch, or None on error.
318 def find_alternate_member_qtype(qapi_type
):
319 if builtin_types
.has_key(qapi_type
):
320 return builtin_types
[qapi_type
]
321 elif find_struct(qapi_type
):
323 elif find_enum(qapi_type
):
324 return "QTYPE_QSTRING"
325 elif find_union(qapi_type
):
329 # Return the discriminator enum define if discriminator is specified as an
330 # enum type, otherwise return None.
331 def discriminator_find_enum_define(expr
):
332 base
= expr
.get('base')
333 discriminator
= expr
.get('discriminator')
335 if not (discriminator
and base
):
338 base_fields
= find_base_fields(base
)
342 discriminator_type
= base_fields
.get(discriminator
)
343 if not discriminator_type
:
346 return find_enum(discriminator_type
)
348 # FIXME should enforce "other than downstream extensions [...], all
349 # names should begin with a letter".
350 valid_name
= re
.compile('^[a-zA-Z_][a-zA-Z0-9_.-]*$')
351 def check_name(expr_info
, source
, name
, allow_optional
= False,
352 enum_member
= False):
356 if not isinstance(name
, str):
357 raise QAPIExprError(expr_info
,
358 "%s requires a string name" % source
)
359 if name
.startswith('*'):
360 membername
= name
[1:]
361 if not allow_optional
:
362 raise QAPIExprError(expr_info
,
363 "%s does not allow optional name '%s'"
365 # Enum members can start with a digit, because the generated C
366 # code always prefixes it with the enum name
368 membername
= '_' + membername
369 if not valid_name
.match(membername
):
370 raise QAPIExprError(expr_info
,
371 "%s uses invalid name '%s'" % (source
, name
))
373 def add_name(name
, info
, meta
, implicit
= False):
375 check_name(info
, "'%s'" % meta
, name
)
376 # FIXME should reject names that differ only in '_' vs. '.'
377 # vs. '-', because they're liable to clash in generated C.
378 if name
in all_names
:
379 raise QAPIExprError(info
,
380 "%s '%s' is already defined"
381 % (all_names
[name
], name
))
382 if not implicit
and name
[-4:] == 'Kind':
383 raise QAPIExprError(info
,
384 "%s '%s' should not end in 'Kind'"
386 all_names
[name
] = meta
388 def add_struct(definition
, info
):
390 name
= definition
['struct']
391 add_name(name
, info
, 'struct')
392 struct_types
.append(definition
)
394 def find_struct(name
):
396 for struct
in struct_types
:
397 if struct
['struct'] == name
:
401 def add_union(definition
, info
):
403 name
= definition
['union']
404 add_name(name
, info
, 'union')
405 union_types
.append(definition
)
407 def find_union(name
):
409 for union
in union_types
:
410 if union
['union'] == name
:
414 def add_enum(name
, info
, enum_values
= None, implicit
= False):
416 add_name(name
, info
, 'enum', implicit
)
417 enum_types
.append({"enum_name": name
, "enum_values": enum_values
})
421 for enum
in enum_types
:
422 if enum
['enum_name'] == name
:
427 return find_enum(name
) != None
429 def check_type(expr_info
, source
, value
, allow_array
= False,
430 allow_dict
= False, allow_optional
= False,
431 allow_star
= False, allow_metas
= []):
437 if allow_star
and value
== '**':
440 # Check if array type for value is okay
441 if isinstance(value
, list):
443 raise QAPIExprError(expr_info
,
444 "%s cannot be an array" % source
)
445 if len(value
) != 1 or not isinstance(value
[0], str):
446 raise QAPIExprError(expr_info
,
447 "%s: array type must contain single type name"
451 # Check if type name for value is okay
452 if isinstance(value
, str):
454 raise QAPIExprError(expr_info
,
455 "%s uses '**' but did not request 'gen':false"
457 if not value
in all_names
:
458 raise QAPIExprError(expr_info
,
459 "%s uses unknown type '%s'"
461 if not all_names
[value
] in allow_metas
:
462 raise QAPIExprError(expr_info
,
463 "%s cannot use %s type '%s'"
464 % (source
, all_names
[value
], value
))
468 raise QAPIExprError(expr_info
,
469 "%s should be a type name" % source
)
471 if not isinstance(value
, OrderedDict
):
472 raise QAPIExprError(expr_info
,
473 "%s should be a dictionary or type name" % source
)
475 # value is a dictionary, check that each member is okay
476 for (key
, arg
) in value
.items():
477 check_name(expr_info
, "Member of %s" % source
, key
,
478 allow_optional
=allow_optional
)
479 # Todo: allow dictionaries to represent default values of
480 # an optional argument.
481 check_type(expr_info
, "Member '%s' of %s" % (key
, source
), arg
,
482 allow_array
=True, allow_star
=allow_star
,
483 allow_metas
=['built-in', 'union', 'alternate', 'struct',
486 def check_member_clash(expr_info
, base_name
, data
, source
= ""):
487 base
= find_struct(base_name
)
489 base_members
= base
['data']
490 for key
in data
.keys():
491 if key
.startswith('*'):
493 if key
in base_members
or "*" + key
in base_members
:
494 raise QAPIExprError(expr_info
,
495 "Member name '%s'%s clashes with base '%s'"
496 % (key
, source
, base_name
))
498 check_member_clash(expr_info
, base
['base'], data
, source
)
500 def check_command(expr
, expr_info
):
501 name
= expr
['command']
502 allow_star
= expr
.has_key('gen')
504 check_type(expr_info
, "'data' for command '%s'" % name
,
505 expr
.get('data'), allow_dict
=True, allow_optional
=True,
506 allow_metas
=['struct'], allow_star
=allow_star
)
507 returns_meta
= ['union', 'struct']
508 if name
in returns_whitelist
:
509 returns_meta
+= ['built-in', 'alternate', 'enum']
510 check_type(expr_info
, "'returns' for command '%s'" % name
,
511 expr
.get('returns'), allow_array
=True,
512 allow_optional
=True, allow_metas
=returns_meta
,
513 allow_star
=allow_star
)
515 def check_event(expr
, expr_info
):
519 if name
.upper() == 'MAX':
520 raise QAPIExprError(expr_info
, "Event name 'MAX' cannot be created")
522 check_type(expr_info
, "'data' for event '%s'" % name
,
523 expr
.get('data'), allow_dict
=True, allow_optional
=True,
524 allow_metas
=['struct'])
526 def check_union(expr
, expr_info
):
528 base
= expr
.get('base')
529 discriminator
= expr
.get('discriminator')
530 members
= expr
['data']
531 values
= { 'MAX': '(automatic)' }
533 # Two types of unions, determined by discriminator.
535 # With no discriminator it is a simple union.
536 if discriminator
is None:
538 allow_metas
=['built-in', 'union', 'alternate', 'struct', 'enum']
540 raise QAPIExprError(expr_info
,
541 "Simple union '%s' must not have a base"
544 # Else, it's a flat union.
546 # The object must have a string member 'base'.
547 if not isinstance(base
, str):
548 raise QAPIExprError(expr_info
,
549 "Flat union '%s' must have a string base field"
551 base_fields
= find_base_fields(base
)
553 raise QAPIExprError(expr_info
,
554 "Base '%s' is not a valid struct"
557 # The value of member 'discriminator' must name a non-optional
558 # member of the base struct.
559 check_name(expr_info
, "Discriminator of flat union '%s'" % name
,
561 discriminator_type
= base_fields
.get(discriminator
)
562 if not discriminator_type
:
563 raise QAPIExprError(expr_info
,
564 "Discriminator '%s' is not a member of base "
566 % (discriminator
, base
))
567 enum_define
= find_enum(discriminator_type
)
568 allow_metas
=['struct']
569 # Do not allow string discriminator
571 raise QAPIExprError(expr_info
,
572 "Discriminator '%s' must be of enumeration "
573 "type" % discriminator
)
576 for (key
, value
) in members
.items():
577 check_name(expr_info
, "Member of union '%s'" % name
, key
)
579 # Each value must name a known type; furthermore, in flat unions,
580 # branches must be a struct with no overlapping member names
581 check_type(expr_info
, "Member '%s' of union '%s'" % (key
, name
),
582 value
, allow_array
=not base
, allow_metas
=allow_metas
)
584 branch_struct
= find_struct(value
)
586 check_member_clash(expr_info
, base
, branch_struct
['data'],
587 " of branch '%s'" % key
)
589 # If the discriminator names an enum type, then all members
590 # of 'data' must also be members of the enum type.
592 if not key
in enum_define
['enum_values']:
593 raise QAPIExprError(expr_info
,
594 "Discriminator value '%s' is not found in "
596 (key
, enum_define
["enum_name"]))
598 # Otherwise, check for conflicts in the generated enum
600 c_key
= camel_to_upper(key
)
602 raise QAPIExprError(expr_info
,
603 "Union '%s' member '%s' clashes with '%s'"
604 % (name
, key
, values
[c_key
]))
607 def check_alternate(expr
, expr_info
):
608 name
= expr
['alternate']
609 members
= expr
['data']
610 values
= { 'MAX': '(automatic)' }
614 for (key
, value
) in members
.items():
615 check_name(expr_info
, "Member of alternate '%s'" % name
, key
)
617 # Check for conflicts in the generated enum
618 c_key
= camel_to_upper(key
)
620 raise QAPIExprError(expr_info
,
621 "Alternate '%s' member '%s' clashes with '%s'"
622 % (name
, key
, values
[c_key
]))
625 # Ensure alternates have no type conflicts.
626 check_type(expr_info
, "Member '%s' of alternate '%s'" % (key
, name
),
628 allow_metas
=['built-in', 'union', 'struct', 'enum'])
629 qtype
= find_alternate_member_qtype(value
)
631 if qtype
in types_seen
:
632 raise QAPIExprError(expr_info
,
633 "Alternate '%s' member '%s' can't "
634 "be distinguished from member '%s'"
635 % (name
, key
, types_seen
[qtype
]))
636 types_seen
[qtype
] = key
638 def check_enum(expr
, expr_info
):
640 members
= expr
.get('data')
641 prefix
= expr
.get('prefix')
642 values
= { 'MAX': '(automatic)' }
644 if not isinstance(members
, list):
645 raise QAPIExprError(expr_info
,
646 "Enum '%s' requires an array for 'data'" % name
)
647 if prefix
is not None and not isinstance(prefix
, str):
648 raise QAPIExprError(expr_info
,
649 "Enum '%s' requires a string for 'prefix'" % name
)
650 for member
in members
:
651 check_name(expr_info
, "Member of enum '%s'" %name
, member
,
653 key
= camel_to_upper(member
)
655 raise QAPIExprError(expr_info
,
656 "Enum '%s' member '%s' clashes with '%s'"
657 % (name
, member
, values
[key
]))
660 def check_struct(expr
, expr_info
):
661 name
= expr
['struct']
662 members
= expr
['data']
664 check_type(expr_info
, "'data' for struct '%s'" % name
, members
,
665 allow_dict
=True, allow_optional
=True)
666 check_type(expr_info
, "'base' for struct '%s'" % name
, expr
.get('base'),
667 allow_metas
=['struct'])
669 check_member_clash(expr_info
, expr
['base'], expr
['data'])
671 def check_keys(expr_elem
, meta
, required
, optional
=[]):
672 expr
= expr_elem
['expr']
673 info
= expr_elem
['info']
675 if not isinstance(name
, str):
676 raise QAPIExprError(info
,
677 "'%s' key must have a string value" % meta
)
678 required
= required
+ [ meta
]
679 for (key
, value
) in expr
.items():
680 if not key
in required
and not key
in optional
:
681 raise QAPIExprError(info
,
682 "Unknown key '%s' in %s '%s'"
684 if (key
== 'gen' or key
== 'success-response') and value
!= False:
685 raise QAPIExprError(info
,
686 "'%s' of %s '%s' should only use false value"
689 if not expr
.has_key(key
):
690 raise QAPIExprError(info
,
691 "Key '%s' is missing from %s '%s'"
694 def check_exprs(exprs
):
697 # Learn the types and check for valid expression keys
698 for builtin
in builtin_types
.keys():
699 all_names
[builtin
] = 'built-in'
700 for expr_elem
in exprs
:
701 expr
= expr_elem
['expr']
702 info
= expr_elem
['info']
703 if expr
.has_key('enum'):
704 check_keys(expr_elem
, 'enum', ['data'], ['prefix'])
705 add_enum(expr
['enum'], info
, expr
['data'])
706 elif expr
.has_key('union'):
707 check_keys(expr_elem
, 'union', ['data'],
708 ['base', 'discriminator'])
709 add_union(expr
, info
)
710 elif expr
.has_key('alternate'):
711 check_keys(expr_elem
, 'alternate', ['data'])
712 add_name(expr
['alternate'], info
, 'alternate')
713 elif expr
.has_key('struct'):
714 check_keys(expr_elem
, 'struct', ['data'], ['base'])
715 add_struct(expr
, info
)
716 elif expr
.has_key('command'):
717 check_keys(expr_elem
, 'command', [],
718 ['data', 'returns', 'gen', 'success-response'])
719 add_name(expr
['command'], info
, 'command')
720 elif expr
.has_key('event'):
721 check_keys(expr_elem
, 'event', [], ['data'])
722 add_name(expr
['event'], info
, 'event')
724 raise QAPIExprError(expr_elem
['info'],
725 "Expression is missing metatype")
727 # Try again for hidden UnionKind enum
728 for expr_elem
in exprs
:
729 expr
= expr_elem
['expr']
730 if expr
.has_key('union'):
731 if not discriminator_find_enum_define(expr
):
732 add_enum('%sKind' % expr
['union'], expr_elem
['info'],
734 elif expr
.has_key('alternate'):
735 add_enum('%sKind' % expr
['alternate'], expr_elem
['info'],
738 # Validate that exprs make sense
739 for expr_elem
in exprs
:
740 expr
= expr_elem
['expr']
741 info
= expr_elem
['info']
743 if expr
.has_key('enum'):
744 check_enum(expr
, info
)
745 elif expr
.has_key('union'):
746 check_union(expr
, info
)
747 elif expr
.has_key('alternate'):
748 check_alternate(expr
, info
)
749 elif expr
.has_key('struct'):
750 check_struct(expr
, info
)
751 elif expr
.has_key('command'):
752 check_command(expr
, info
)
753 elif expr
.has_key('event'):
754 check_event(expr
, info
)
756 assert False, 'unexpected meta type'
762 # Schema compiler frontend
765 class QAPISchemaEntity(object):
766 def __init__(self
, name
, info
):
767 assert isinstance(name
, str)
772 return c_name(self
.name
)
774 def check(self
, schema
):
777 def visit(self
, visitor
):
781 class QAPISchemaVisitor(object):
782 def visit_begin(self
, schema
):
788 def visit_builtin_type(self
, name
, info
, json_type
):
791 def visit_enum_type(self
, name
, info
, values
, prefix
):
794 def visit_array_type(self
, name
, info
, element_type
):
797 def visit_object_type(self
, name
, info
, base
, members
, variants
):
800 def visit_alternate_type(self
, name
, info
, variants
):
803 def visit_command(self
, name
, info
, arg_type
, ret_type
,
804 gen
, success_response
):
807 def visit_event(self
, name
, info
, arg_type
):
811 class QAPISchemaType(QAPISchemaEntity
):
812 def c_type(self
, is_param
=False):
813 return c_name(self
.name
) + pointer_suffix
821 def alternate_qtype(self
):
823 'string': 'QTYPE_QSTRING',
824 'number': 'QTYPE_QFLOAT',
826 'boolean': 'QTYPE_QBOOL',
827 'object': 'QTYPE_QDICT'
829 return json2qtype
.get(self
.json_type())
832 class QAPISchemaBuiltinType(QAPISchemaType
):
833 def __init__(self
, name
, json_type
, c_type
, c_null
):
834 QAPISchemaType
.__init
__(self
, name
, None)
835 assert not c_type
or isinstance(c_type
, str)
836 assert json_type
in ('string', 'number', 'int', 'boolean', 'null',
838 self
._json
_type
_name
= json_type
839 self
._c
_type
_name
= c_type
840 self
._c
_null
_val
= c_null
845 def c_type(self
, is_param
=False):
846 if is_param
and self
.name
== 'str':
847 return 'const ' + self
._c
_type
_name
848 return self
._c
_type
_name
851 return self
._c
_null
_val
854 return self
._json
_type
_name
856 def visit(self
, visitor
):
857 visitor
.visit_builtin_type(self
.name
, self
.info
, self
.json_type())
860 class QAPISchemaEnumType(QAPISchemaType
):
861 def __init__(self
, name
, info
, values
, prefix
):
862 QAPISchemaType
.__init
__(self
, name
, info
)
864 assert isinstance(v
, str)
865 assert prefix
is None or isinstance(prefix
, str)
869 def check(self
, schema
):
870 assert len(set(self
.values
)) == len(self
.values
)
872 def c_type(self
, is_param
=False):
873 return c_name(self
.name
)
876 return c_enum_const(self
.name
, (self
.values
+ ['MAX'])[0],
882 def visit(self
, visitor
):
883 visitor
.visit_enum_type(self
.name
, self
.info
,
884 self
.values
, self
.prefix
)
887 class QAPISchemaArrayType(QAPISchemaType
):
888 def __init__(self
, name
, info
, element_type
):
889 QAPISchemaType
.__init
__(self
, name
, info
)
890 assert isinstance(element_type
, str)
891 self
._element
_type
_name
= element_type
892 self
.element_type
= None
894 def check(self
, schema
):
895 self
.element_type
= schema
.lookup_type(self
._element
_type
_name
)
896 assert self
.element_type
901 def visit(self
, visitor
):
902 visitor
.visit_array_type(self
.name
, self
.info
, self
.element_type
)
905 class QAPISchemaObjectType(QAPISchemaType
):
906 def __init__(self
, name
, info
, base
, local_members
, variants
):
907 QAPISchemaType
.__init
__(self
, name
, info
)
908 assert base
is None or isinstance(base
, str)
909 for m
in local_members
:
910 assert isinstance(m
, QAPISchemaObjectTypeMember
)
911 assert (variants
is None or
912 isinstance(variants
, QAPISchemaObjectTypeVariants
))
913 self
._base
_name
= base
915 self
.local_members
= local_members
916 self
.variants
= variants
919 def check(self
, schema
):
920 assert self
.members
is not False # not running in cycles
923 self
.members
= False # mark as being checked
925 self
.base
= schema
.lookup_type(self
._base
_name
)
926 assert isinstance(self
.base
, QAPISchemaObjectType
)
927 assert not self
.base
.variants
# not implemented
928 self
.base
.check(schema
)
929 members
= list(self
.base
.members
)
935 for m
in self
.local_members
:
936 m
.check(schema
, members
, seen
)
938 self
.variants
.check(schema
, members
, seen
)
939 self
.members
= members
943 return QAPISchemaType
.c_name(self
)
945 def c_type(self
, is_param
=False):
947 return QAPISchemaType
.c_type(self
)
952 def visit(self
, visitor
):
953 visitor
.visit_object_type(self
.name
, self
.info
,
954 self
.base
, self
.local_members
, self
.variants
)
957 class QAPISchemaObjectTypeMember(object):
958 def __init__(self
, name
, typ
, optional
):
959 assert isinstance(name
, str)
960 assert isinstance(typ
, str)
961 assert isinstance(optional
, bool)
963 self
._type
_name
= typ
965 self
.optional
= optional
967 def check(self
, schema
, all_members
, seen
):
968 assert self
.name
not in seen
969 self
.type = schema
.lookup_type(self
._type
_name
)
971 all_members
.append(self
)
972 seen
[self
.name
] = self
975 class QAPISchemaObjectTypeVariants(object):
976 def __init__(self
, tag_name
, tag_enum
, variants
):
977 assert tag_name
is None or isinstance(tag_name
, str)
978 assert tag_enum
is None or isinstance(tag_enum
, str)
980 assert isinstance(v
, QAPISchemaObjectTypeVariant
)
981 self
.tag_name
= tag_name
984 self
.tag_member
= None
986 self
.tag_member
= QAPISchemaObjectTypeMember('type', tag_enum
,
988 self
.variants
= variants
990 def check(self
, schema
, members
, seen
):
992 self
.tag_member
= seen
[self
.tag_name
]
994 self
.tag_member
.check(schema
, members
, seen
)
995 assert isinstance(self
.tag_member
.type, QAPISchemaEnumType
)
996 for v
in self
.variants
:
998 v
.check(schema
, self
.tag_member
.type, vseen
)
1000 class QAPISchemaObjectTypeVariant(QAPISchemaObjectTypeMember
):
1001 def __init__(self
, name
, typ
):
1002 QAPISchemaObjectTypeMember
.__init
__(self
, name
, typ
, False)
1004 def check(self
, schema
, tag_type
, seen
):
1005 QAPISchemaObjectTypeMember
.check(self
, schema
, [], seen
)
1006 assert self
.name
in tag_type
.values
1008 # This function exists to support ugly simple union special cases
1009 # TODO get rid of them, and drop the function
1010 def simple_union_type(self
):
1011 if isinstance(self
.type, QAPISchemaObjectType
) and not self
.type.info
:
1012 assert len(self
.type.members
) == 1
1013 assert not self
.type.variants
1014 return self
.type.members
[0].type
1018 class QAPISchemaAlternateType(QAPISchemaType
):
1019 def __init__(self
, name
, info
, variants
):
1020 QAPISchemaType
.__init
__(self
, name
, info
)
1021 assert isinstance(variants
, QAPISchemaObjectTypeVariants
)
1022 assert not variants
.tag_name
1023 self
.variants
= variants
1025 def check(self
, schema
):
1026 self
.variants
.check(schema
, [], {})
1028 def json_type(self
):
1031 def visit(self
, visitor
):
1032 visitor
.visit_alternate_type(self
.name
, self
.info
, self
.variants
)
1035 class QAPISchemaCommand(QAPISchemaEntity
):
1036 def __init__(self
, name
, info
, arg_type
, ret_type
, gen
, success_response
):
1037 QAPISchemaEntity
.__init
__(self
, name
, info
)
1038 assert not arg_type
or isinstance(arg_type
, str)
1039 assert not ret_type
or isinstance(ret_type
, str)
1040 self
._arg
_type
_name
= arg_type
1041 self
.arg_type
= None
1042 self
._ret
_type
_name
= ret_type
1043 self
.ret_type
= None
1045 self
.success_response
= success_response
1047 def check(self
, schema
):
1048 if self
._arg
_type
_name
:
1049 self
.arg_type
= schema
.lookup_type(self
._arg
_type
_name
)
1050 assert isinstance(self
.arg_type
, QAPISchemaObjectType
)
1051 assert not self
.arg_type
.variants
# not implemented
1052 if self
._ret
_type
_name
:
1053 self
.ret_type
= schema
.lookup_type(self
._ret
_type
_name
)
1054 assert isinstance(self
.ret_type
, QAPISchemaType
)
1056 def visit(self
, visitor
):
1057 visitor
.visit_command(self
.name
, self
.info
,
1058 self
.arg_type
, self
.ret_type
,
1059 self
.gen
, self
.success_response
)
1062 class QAPISchemaEvent(QAPISchemaEntity
):
1063 def __init__(self
, name
, info
, arg_type
):
1064 QAPISchemaEntity
.__init
__(self
, name
, info
)
1065 assert not arg_type
or isinstance(arg_type
, str)
1066 self
._arg
_type
_name
= arg_type
1067 self
.arg_type
= None
1069 def check(self
, schema
):
1070 if self
._arg
_type
_name
:
1071 self
.arg_type
= schema
.lookup_type(self
._arg
_type
_name
)
1072 assert isinstance(self
.arg_type
, QAPISchemaObjectType
)
1073 assert not self
.arg_type
.variants
# not implemented
1075 def visit(self
, visitor
):
1076 visitor
.visit_event(self
.name
, self
.info
, self
.arg_type
)
1079 class QAPISchema(object):
1080 def __init__(self
, fname
):
1082 self
.exprs
= check_exprs(QAPISchemaParser(open(fname
, "r")).exprs
)
1083 except (QAPISchemaError
, QAPIExprError
), err
:
1084 print >>sys
.stderr
, err
1086 self
._entity
_dict
= {}
1087 self
._def
_predefineds
()
1091 def _def_entity(self
, ent
):
1092 assert ent
.name
not in self
._entity
_dict
1093 self
._entity
_dict
[ent
.name
] = ent
1095 def lookup_entity(self
, name
, typ
=None):
1096 ent
= self
._entity
_dict
.get(name
)
1097 if typ
and not isinstance(ent
, typ
):
1101 def lookup_type(self
, name
):
1102 return self
.lookup_entity(name
, QAPISchemaType
)
1104 def _def_builtin_type(self
, name
, json_type
, c_type
, c_null
):
1105 self
._def
_entity
(QAPISchemaBuiltinType(name
, json_type
,
1107 self
._make
_array
_type
(name
) # TODO really needed?
1109 def _def_predefineds(self
):
1110 for t
in [('str', 'string', 'char' + pointer_suffix
, 'NULL'),
1111 ('number', 'number', 'double', '0'),
1112 ('int', 'int', 'int64_t', '0'),
1113 ('int8', 'int', 'int8_t', '0'),
1114 ('int16', 'int', 'int16_t', '0'),
1115 ('int32', 'int', 'int32_t', '0'),
1116 ('int64', 'int', 'int64_t', '0'),
1117 ('uint8', 'int', 'uint8_t', '0'),
1118 ('uint16', 'int', 'uint16_t', '0'),
1119 ('uint32', 'int', 'uint32_t', '0'),
1120 ('uint64', 'int', 'uint64_t', '0'),
1121 ('size', 'int', 'uint64_t', '0'),
1122 ('bool', 'boolean', 'bool', 'false'),
1123 ('any', 'value', 'QObject' + pointer_suffix
, 'NULL')]:
1124 self
._def
_builtin
_type
(*t
)
1125 self
._entity
_dict
['**'] = self
.lookup_type('any') # TODO drop this alias
1127 def _make_implicit_enum_type(self
, name
, values
):
1128 name
= name
+ 'Kind'
1129 self
._def
_entity
(QAPISchemaEnumType(name
, None, values
, None))
1132 def _make_array_type(self
, element_type
):
1133 name
= element_type
+ 'List'
1134 if not self
.lookup_type(name
):
1135 self
._def
_entity
(QAPISchemaArrayType(name
, None, element_type
))
1138 def _make_implicit_object_type(self
, name
, role
, members
):
1141 name
= ':obj-%s-%s' % (name
, role
)
1142 if not self
.lookup_entity(name
, QAPISchemaObjectType
):
1143 self
._def
_entity
(QAPISchemaObjectType(name
, None, None,
1147 def _def_enum_type(self
, expr
, info
):
1150 prefix
= expr
.get('prefix')
1151 self
._def
_entity
(QAPISchemaEnumType(name
, info
, data
, prefix
))
1152 self
._make
_array
_type
(name
) # TODO really needed?
1154 def _make_member(self
, name
, typ
):
1156 if name
.startswith('*'):
1159 if isinstance(typ
, list):
1160 assert len(typ
) == 1
1161 typ
= self
._make
_array
_type
(typ
[0])
1162 return QAPISchemaObjectTypeMember(name
, typ
, optional
)
1164 def _make_members(self
, data
):
1165 return [self
._make
_member
(key
, value
)
1166 for (key
, value
) in data
.iteritems()]
1168 def _def_struct_type(self
, expr
, info
):
1169 name
= expr
['struct']
1170 base
= expr
.get('base')
1172 self
._def
_entity
(QAPISchemaObjectType(name
, info
, base
,
1173 self
._make
_members
(data
),
1175 self
._make
_array
_type
(name
) # TODO really needed?
1177 def _make_variant(self
, case
, typ
):
1178 return QAPISchemaObjectTypeVariant(case
, typ
)
1180 def _make_simple_variant(self
, case
, typ
):
1181 if isinstance(typ
, list):
1182 assert len(typ
) == 1
1183 typ
= self
._make
_array
_type
(typ
[0])
1184 typ
= self
._make
_implicit
_object
_type
(typ
, 'wrapper',
1185 [self
._make
_member
('data', typ
)])
1186 return QAPISchemaObjectTypeVariant(case
, typ
)
1188 def _make_tag_enum(self
, type_name
, variants
):
1189 return self
._make
_implicit
_enum
_type
(type_name
,
1190 [v
.name
for v
in variants
])
1192 def _def_union_type(self
, expr
, info
):
1193 name
= expr
['union']
1195 base
= expr
.get('base')
1196 tag_name
= expr
.get('discriminator')
1199 variants
= [self
._make
_variant
(key
, value
)
1200 for (key
, value
) in data
.iteritems()]
1202 variants
= [self
._make
_simple
_variant
(key
, value
)
1203 for (key
, value
) in data
.iteritems()]
1204 tag_enum
= self
._make
_tag
_enum
(name
, variants
)
1206 QAPISchemaObjectType(name
, info
, base
,
1207 self
._make
_members
(OrderedDict()),
1208 QAPISchemaObjectTypeVariants(tag_name
,
1211 self
._make
_array
_type
(name
) # TODO really needed?
1213 def _def_alternate_type(self
, expr
, info
):
1214 name
= expr
['alternate']
1216 variants
= [self
._make
_variant
(key
, value
)
1217 for (key
, value
) in data
.iteritems()]
1218 tag_enum
= self
._make
_tag
_enum
(name
, variants
)
1220 QAPISchemaAlternateType(name
, info
,
1221 QAPISchemaObjectTypeVariants(None,
1224 self
._make
_array
_type
(name
) # TODO really needed?
1226 def _def_command(self
, expr
, info
):
1227 name
= expr
['command']
1228 data
= expr
.get('data')
1229 rets
= expr
.get('returns')
1230 gen
= expr
.get('gen', True)
1231 success_response
= expr
.get('success-response', True)
1232 if isinstance(data
, OrderedDict
):
1233 data
= self
._make
_implicit
_object
_type
(name
, 'arg',
1234 self
._make
_members
(data
))
1235 if isinstance(rets
, list):
1236 assert len(rets
) == 1
1237 rets
= self
._make
_array
_type
(rets
[0])
1238 self
._def
_entity
(QAPISchemaCommand(name
, info
, data
, rets
, gen
,
1241 def _def_event(self
, expr
, info
):
1242 name
= expr
['event']
1243 data
= expr
.get('data')
1244 if isinstance(data
, OrderedDict
):
1245 data
= self
._make
_implicit
_object
_type
(name
, 'arg',
1246 self
._make
_members
(data
))
1247 self
._def
_entity
(QAPISchemaEvent(name
, info
, data
))
1249 def _def_exprs(self
):
1250 for expr_elem
in self
.exprs
:
1251 expr
= expr_elem
['expr']
1252 info
= expr_elem
['info']
1254 self
._def
_enum
_type
(expr
, info
)
1255 elif 'struct' in expr
:
1256 self
._def
_struct
_type
(expr
, info
)
1257 elif 'union' in expr
:
1258 self
._def
_union
_type
(expr
, info
)
1259 elif 'alternate' in expr
:
1260 self
._def
_alternate
_type
(expr
, info
)
1261 elif 'command' in expr
:
1262 self
._def
_command
(expr
, info
)
1263 elif 'event' in expr
:
1264 self
._def
_event
(expr
, info
)
1269 for ent
in self
._entity
_dict
.values():
1272 def visit(self
, visitor
):
1273 visitor
.visit_begin(self
)
1274 for name
in sorted(self
._entity
_dict
.keys()):
1275 if self
._entity
_dict
[name
].name
!= name
:
1276 continue # ignore alias TODO drop alias and remove
1277 self
._entity
_dict
[name
].visit(visitor
)
1282 # Code generation helpers
1285 def camel_case(name
):
1289 if ch
in ['_', '-']:
1292 new_name
+= ch
.upper()
1295 new_name
+= ch
.lower()
1298 # ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1
1299 # ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2
1300 # ENUM24_Name -> ENUM24_NAME
1301 def camel_to_upper(value
):
1302 c_fun_str
= c_name(value
, False)
1310 # When c is upper and no "_" appears before, do more checks
1311 if c
.isupper() and (i
> 0) and c_fun_str
[i
- 1] != "_":
1312 # Case 1: next string is lower
1313 # Case 2: previous string is digit
1314 if (i
< (l
- 1) and c_fun_str
[i
+ 1].islower()) or \
1315 c_fun_str
[i
- 1].isdigit():
1318 return new_name
.lstrip('_').upper()
1320 def c_enum_const(type_name
, const_name
, prefix
=None):
1321 if prefix
is not None:
1323 return camel_to_upper(type_name
+ '_' + const_name
)
1325 c_name_trans
= string
.maketrans('.-', '__')
1327 # Map @name to a valid C identifier.
1328 # If @protect, avoid returning certain ticklish identifiers (like
1329 # C keywords) by prepending "q_".
1331 # Used for converting 'name' from a 'name':'type' qapi definition
1332 # into a generated struct member, as well as converting type names
1333 # into substrings of a generated C function name.
1334 # '__a.b_c' -> '__a_b_c', 'x-foo' -> 'x_foo'
1335 # protect=True: 'int' -> 'q_int'; protect=False: 'int' -> 'int'
1336 def c_name(name
, protect
=True):
1337 # ANSI X3J11/88-090, 3.1.1
1338 c89_words
= set(['auto', 'break', 'case', 'char', 'const', 'continue',
1339 'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
1340 'for', 'goto', 'if', 'int', 'long', 'register', 'return',
1341 'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
1342 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'])
1343 # ISO/IEC 9899:1999, 6.4.1
1344 c99_words
= set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
1345 # ISO/IEC 9899:2011, 6.4.1
1346 c11_words
= set(['_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
1347 '_Static_assert', '_Thread_local'])
1348 # GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
1350 gcc_words
= set(['asm', 'typeof'])
1351 # C++ ISO/IEC 14882:2003 2.11
1352 cpp_words
= set(['bool', 'catch', 'class', 'const_cast', 'delete',
1353 'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
1354 'namespace', 'new', 'operator', 'private', 'protected',
1355 'public', 'reinterpret_cast', 'static_cast', 'template',
1356 'this', 'throw', 'true', 'try', 'typeid', 'typename',
1357 'using', 'virtual', 'wchar_t',
1358 # alternative representations
1359 'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
1360 'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
1361 # namespace pollution:
1362 polluted_words
= set(['unix', 'errno'])
1363 if protect
and (name
in c89_words | c99_words | c11_words | gcc_words | cpp_words | polluted_words
):
1365 return name
.translate(c_name_trans
)
1367 eatspace
= '\033EATSPACE.'
1368 pointer_suffix
= ' *' + eatspace
1370 def genindent(count
):
1372 for i
in range(count
):
1378 def push_indent(indent_amount
=4):
1380 indent_level
+= indent_amount
1382 def pop_indent(indent_amount
=4):
1384 indent_level
-= indent_amount
1386 # Generate @code with @kwds interpolated.
1387 # Obey indent_level, and strip eatspace.
1388 def cgen(code
, **kwds
):
1391 indent
= genindent(indent_level
)
1392 # re.subn() lacks flags support before Python 2.7, use re.compile()
1393 raw
= re
.subn(re
.compile("^.", re
.MULTILINE
),
1394 indent
+ r
'\g<0>', raw
)
1396 return re
.sub(re
.escape(eatspace
) + ' *', '', raw
)
1398 def mcgen(code
, **kwds
):
1401 return cgen(code
, **kwds
)
1404 def guardname(filename
):
1405 return c_name(filename
, protect
=False).upper()
1407 def guardstart(name
):
1414 name
=guardname(name
))
1419 #endif /* %(name)s */
1422 name
=guardname(name
))
1424 def gen_enum_lookup(name
, values
, prefix
=None):
1427 const char *const %(c_name)s_lookup[] = {
1429 c_name
=c_name(name
))
1430 for value
in values
:
1431 index
= c_enum_const(name
, value
, prefix
)
1433 [%(index)s] = "%(value)s",
1435 index
=index
, value
=value
)
1437 max_index
= c_enum_const(name
, 'MAX', prefix
)
1439 [%(max_index)s] = NULL,
1442 max_index
=max_index
)
1445 def gen_enum(name
, values
, prefix
=None):
1446 # append automatically generated _MAX value
1447 enum_values
= values
+ ['MAX']
1451 typedef enum %(c_name)s {
1453 c_name
=c_name(name
))
1456 for value
in enum_values
:
1460 c_enum
=c_enum_const(name
, value
, prefix
),
1467 c_name
=c_name(name
))
1471 extern const char *const %(c_name)s_lookup[];
1473 c_name
=c_name(name
))
1476 def gen_params(arg_type
, extra
):
1479 assert not arg_type
.variants
1482 for memb
in arg_type
.members
:
1486 ret
+= 'bool has_%s, ' % c_name(memb
.name
)
1487 ret
+= '%s %s' % (memb
.type.c_type(is_param
=True), c_name(memb
.name
))
1493 # Common command line parsing
1496 def parse_command_line(extra_options
= "", extra_long_options
= []):
1499 opts
, args
= getopt
.gnu_getopt(sys
.argv
[1:],
1500 "chp:o:" + extra_options
,
1501 ["source", "header", "prefix=",
1502 "output-dir="] + extra_long_options
)
1503 except getopt
.GetoptError
, err
:
1504 print >>sys
.stderr
, "%s: %s" % (sys
.argv
[0], str(err
))
1515 if o
in ("-p", "--prefix"):
1516 match
= re
.match('([A-Za-z_.-][A-Za-z0-9_.-]*)?', a
)
1517 if match
.end() != len(a
):
1518 print >>sys
.stderr
, \
1519 "%s: 'funny character '%s' in argument of --prefix" \
1520 % (sys
.argv
[0], a
[match
.end()])
1523 elif o
in ("-o", "--output-dir"):
1524 output_dir
= a
+ "/"
1525 elif o
in ("-c", "--source"):
1527 elif o
in ("-h", "--header"):
1530 extra_opts
.append(oa
)
1532 if not do_c
and not do_h
:
1537 print >>sys
.stderr
, "%s: need exactly one argument" % sys
.argv
[0]
1541 return (fname
, output_dir
, do_c
, do_h
, prefix
, extra_opts
)
1544 # Generate output files with boilerplate
1547 def open_output(output_dir
, do_c
, do_h
, prefix
, c_file
, h_file
,
1548 c_comment
, h_comment
):
1549 guard
= guardname(prefix
+ h_file
)
1550 c_file
= output_dir
+ prefix
+ c_file
1551 h_file
= output_dir
+ prefix
+ h_file
1555 os
.makedirs(output_dir
)
1557 if e
.errno
!= errno
.EEXIST
:
1560 def maybe_open(really
, name
, opt
):
1562 return open(name
, opt
)
1565 return StringIO
.StringIO()
1567 fdef
= maybe_open(do_c
, c_file
, 'w')
1568 fdecl
= maybe_open(do_h
, h_file
, 'w')
1570 fdef
.write(mcgen('''
1571 /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
1574 comment
= c_comment
))
1576 fdecl
.write(mcgen('''
1577 /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
1583 comment
= h_comment
, guard
= guard
))
1585 return (fdef
, fdecl
)
1587 def close_output(fdef
, fdecl
):