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',
38 # Whitelist of commands allowed to return a non-dictionary
41 'human-monitor-command',
42 'query-migrate-cache-size',
49 'guest-fsfreeze-freeze',
50 'guest-fsfreeze-freeze-list',
51 'guest-fsfreeze-status',
52 'guest-fsfreeze-thaw',
56 'guest-sync-delimited',
58 # From qapi-schema-test:
69 # Parsing the schema into expressions
72 def error_path(parent
):
75 res
= ("In file included from %s:%d:\n" % (parent
['file'],
76 parent
['line'])) + res
77 parent
= parent
['parent']
80 class QAPISchemaError(Exception):
81 def __init__(self
, schema
, msg
):
82 self
.fname
= schema
.fname
85 self
.line
= schema
.line
86 for ch
in schema
.src
[schema
.line_pos
:schema
.pos
]:
88 self
.col
= (self
.col
+ 7) % 8 + 1
91 self
.info
= schema
.incl_info
94 return error_path(self
.info
) + \
95 "%s:%d:%d: %s" % (self
.fname
, self
.line
, self
.col
, self
.msg
)
97 class QAPIExprError(Exception):
98 def __init__(self
, expr_info
, msg
):
103 return error_path(self
.info
['parent']) + \
104 "%s:%d: %s" % (self
.info
['file'], self
.info
['line'], self
.msg
)
108 def __init__(self
, fp
, previously_included
= [], incl_info
= None):
109 abs_fname
= os
.path
.abspath(fp
.name
)
112 previously_included
.append(abs_fname
)
113 self
.incl_info
= incl_info
115 if self
.src
== '' or self
.src
[-1] != '\n':
123 while self
.tok
!= None:
124 expr_info
= {'file': fname
, 'line': self
.line
,
125 'parent': self
.incl_info
}
126 expr
= self
.get_expr(False)
127 if isinstance(expr
, dict) and "include" in expr
:
129 raise QAPIExprError(expr_info
, "Invalid 'include' directive")
130 include
= expr
["include"]
131 if not isinstance(include
, str):
132 raise QAPIExprError(expr_info
,
133 'Expected a file name (string), got: %s'
135 incl_abs_fname
= os
.path
.join(os
.path
.dirname(abs_fname
),
137 # catch inclusion cycle
140 if incl_abs_fname
== os
.path
.abspath(inf
['file']):
141 raise QAPIExprError(expr_info
, "Inclusion loop for %s"
144 # skip multiple include of the same file
145 if incl_abs_fname
in previously_included
:
148 fobj
= open(incl_abs_fname
, 'r')
150 raise QAPIExprError(expr_info
,
151 '%s: %s' % (e
.strerror
, include
))
152 exprs_include
= QAPISchema(fobj
, previously_included
,
154 self
.exprs
.extend(exprs_include
.exprs
)
156 expr_elem
= {'expr': expr
,
158 self
.exprs
.append(expr_elem
)
162 self
.tok
= self
.src
[self
.cursor
]
163 self
.pos
= self
.cursor
168 self
.cursor
= self
.src
.find('\n', self
.cursor
)
169 elif self
.tok
in ['{', '}', ':', ',', '[', ']']:
171 elif self
.tok
== "'":
175 ch
= self
.src
[self
.cursor
]
178 raise QAPISchemaError(self
,
179 'Missing terminating "\'"')
193 for x
in range(0, 4):
194 ch
= self
.src
[self
.cursor
]
196 if ch
not in "0123456789abcdefABCDEF":
197 raise QAPISchemaError(self
,
198 '\\u escape needs 4 '
200 value
= (value
<< 4) + int(ch
, 16)
201 # If Python 2 and 3 didn't disagree so much on
202 # how to handle Unicode, then we could allow
203 # Unicode string defaults. But most of QAPI is
204 # ASCII-only, so we aren't losing much for now.
205 if not value
or value
> 0x7f:
206 raise QAPISchemaError(self
,
207 'For now, \\u escape '
208 'only supports non-zero '
209 'values up to \\u007f')
214 raise QAPISchemaError(self
,
215 "Unknown escape \\%s" %ch
)
224 elif self
.src
.startswith("true", self
.pos
):
228 elif self
.src
.startswith("false", self
.pos
):
232 elif self
.src
.startswith("null", self
.pos
):
236 elif self
.tok
== '\n':
237 if self
.cursor
== len(self
.src
):
241 self
.line_pos
= self
.cursor
242 elif not self
.tok
.isspace():
243 raise QAPISchemaError(self
, 'Stray "%s"' % self
.tok
)
245 def get_members(self
):
251 raise QAPISchemaError(self
, 'Expected string or "}"')
256 raise QAPISchemaError(self
, 'Expected ":"')
259 raise QAPISchemaError(self
, 'Duplicate key "%s"' % key
)
260 expr
[key
] = self
.get_expr(True)
265 raise QAPISchemaError(self
, 'Expected "," or "}"')
268 raise QAPISchemaError(self
, 'Expected string')
270 def get_values(self
):
275 if not self
.tok
in "{['tfn":
276 raise QAPISchemaError(self
, 'Expected "{", "[", "]", string, '
279 expr
.append(self
.get_expr(True))
284 raise QAPISchemaError(self
, 'Expected "," or "]"')
287 def get_expr(self
, nested
):
288 if self
.tok
!= '{' and not nested
:
289 raise QAPISchemaError(self
, 'Expected "{"')
292 expr
= self
.get_members()
293 elif self
.tok
== '[':
295 expr
= self
.get_values()
296 elif self
.tok
in "'tfn":
300 raise QAPISchemaError(self
, 'Expected "{", "[" or string')
304 # Semantic analysis of schema expressions
307 def find_base_fields(base
):
308 base_struct_define
= find_struct(base
)
309 if not base_struct_define
:
311 return base_struct_define
['data']
313 # Return the qtype of an alternate branch, or None on error.
314 def find_alternate_member_qtype(qapi_type
):
315 if builtin_types
.has_key(qapi_type
):
316 return builtin_types
[qapi_type
]
317 elif find_struct(qapi_type
):
319 elif find_enum(qapi_type
):
320 return "QTYPE_QSTRING"
321 elif find_union(qapi_type
):
325 # Return the discriminator enum define if discriminator is specified as an
326 # enum type, otherwise return None.
327 def discriminator_find_enum_define(expr
):
328 base
= expr
.get('base')
329 discriminator
= expr
.get('discriminator')
331 if not (discriminator
and base
):
334 base_fields
= find_base_fields(base
)
338 discriminator_type
= base_fields
.get(discriminator
)
339 if not discriminator_type
:
342 return find_enum(discriminator_type
)
344 # FIXME should enforce "other than downstream extensions [...], all
345 # names should begin with a letter".
346 valid_name
= re
.compile('^[a-zA-Z_][a-zA-Z0-9_.-]*$')
347 def check_name(expr_info
, source
, name
, allow_optional
= False,
348 enum_member
= False):
352 if not isinstance(name
, str):
353 raise QAPIExprError(expr_info
,
354 "%s requires a string name" % source
)
355 if name
.startswith('*'):
356 membername
= name
[1:]
357 if not allow_optional
:
358 raise QAPIExprError(expr_info
,
359 "%s does not allow optional name '%s'"
361 # Enum members can start with a digit, because the generated C
362 # code always prefixes it with the enum name
364 membername
= '_' + membername
365 if not valid_name
.match(membername
):
366 raise QAPIExprError(expr_info
,
367 "%s uses invalid name '%s'" % (source
, name
))
369 def add_name(name
, info
, meta
, implicit
= False):
371 check_name(info
, "'%s'" % meta
, name
)
372 # FIXME should reject names that differ only in '_' vs. '.'
373 # vs. '-', because they're liable to clash in generated C.
374 if name
in all_names
:
375 raise QAPIExprError(info
,
376 "%s '%s' is already defined"
377 % (all_names
[name
], name
))
378 if not implicit
and name
[-4:] == 'Kind':
379 raise QAPIExprError(info
,
380 "%s '%s' should not end in 'Kind'"
382 all_names
[name
] = meta
384 def add_struct(definition
, info
):
386 name
= definition
['struct']
387 add_name(name
, info
, 'struct')
388 struct_types
.append(definition
)
390 def find_struct(name
):
392 for struct
in struct_types
:
393 if struct
['struct'] == name
:
397 def add_union(definition
, info
):
399 name
= definition
['union']
400 add_name(name
, info
, 'union')
401 union_types
.append(definition
)
403 def find_union(name
):
405 for union
in union_types
:
406 if union
['union'] == name
:
410 def add_enum(name
, info
, enum_values
= None, implicit
= False):
412 add_name(name
, info
, 'enum', implicit
)
413 enum_types
.append({"enum_name": name
, "enum_values": enum_values
})
417 for enum
in enum_types
:
418 if enum
['enum_name'] == name
:
423 return find_enum(name
) != None
425 def check_type(expr_info
, source
, value
, allow_array
= False,
426 allow_dict
= False, allow_optional
= False,
427 allow_star
= False, allow_metas
= []):
433 if allow_star
and value
== '**':
436 # Check if array type for value is okay
437 if isinstance(value
, list):
439 raise QAPIExprError(expr_info
,
440 "%s cannot be an array" % source
)
441 if len(value
) != 1 or not isinstance(value
[0], str):
442 raise QAPIExprError(expr_info
,
443 "%s: array type must contain single type name"
447 # Check if type name for value is okay
448 if isinstance(value
, str):
450 raise QAPIExprError(expr_info
,
451 "%s uses '**' but did not request 'gen':false"
453 if not value
in all_names
:
454 raise QAPIExprError(expr_info
,
455 "%s uses unknown type '%s'"
457 if not all_names
[value
] in allow_metas
:
458 raise QAPIExprError(expr_info
,
459 "%s cannot use %s type '%s'"
460 % (source
, all_names
[value
], value
))
464 raise QAPIExprError(expr_info
,
465 "%s should be a type name" % source
)
467 if not isinstance(value
, OrderedDict
):
468 raise QAPIExprError(expr_info
,
469 "%s should be a dictionary or type name" % source
)
471 # value is a dictionary, check that each member is okay
472 for (key
, arg
) in value
.items():
473 check_name(expr_info
, "Member of %s" % source
, key
,
474 allow_optional
=allow_optional
)
475 # Todo: allow dictionaries to represent default values of
476 # an optional argument.
477 check_type(expr_info
, "Member '%s' of %s" % (key
, source
), arg
,
478 allow_array
=True, allow_star
=allow_star
,
479 allow_metas
=['built-in', 'union', 'alternate', 'struct',
482 def check_member_clash(expr_info
, base_name
, data
, source
= ""):
483 base
= find_struct(base_name
)
485 base_members
= base
['data']
486 for key
in data
.keys():
487 if key
.startswith('*'):
489 if key
in base_members
or "*" + key
in base_members
:
490 raise QAPIExprError(expr_info
,
491 "Member name '%s'%s clashes with base '%s'"
492 % (key
, source
, base_name
))
494 check_member_clash(expr_info
, base
['base'], data
, source
)
496 def check_command(expr
, expr_info
):
497 name
= expr
['command']
498 allow_star
= expr
.has_key('gen')
500 check_type(expr_info
, "'data' for command '%s'" % name
,
501 expr
.get('data'), allow_dict
=True, allow_optional
=True,
502 allow_metas
=['struct'], allow_star
=allow_star
)
503 returns_meta
= ['union', 'struct']
504 if name
in returns_whitelist
:
505 returns_meta
+= ['built-in', 'alternate', 'enum']
506 check_type(expr_info
, "'returns' for command '%s'" % name
,
507 expr
.get('returns'), allow_array
=True,
508 allow_optional
=True, allow_metas
=returns_meta
,
509 allow_star
=allow_star
)
511 def check_event(expr
, expr_info
):
515 if name
.upper() == 'MAX':
516 raise QAPIExprError(expr_info
, "Event name 'MAX' cannot be created")
518 check_type(expr_info
, "'data' for event '%s'" % name
,
519 expr
.get('data'), allow_dict
=True, allow_optional
=True,
520 allow_metas
=['struct'])
522 def check_union(expr
, expr_info
):
524 base
= expr
.get('base')
525 discriminator
= expr
.get('discriminator')
526 members
= expr
['data']
527 values
= { 'MAX': '(automatic)' }
529 # Two types of unions, determined by discriminator.
531 # With no discriminator it is a simple union.
532 if discriminator
is None:
534 allow_metas
=['built-in', 'union', 'alternate', 'struct', 'enum']
536 raise QAPIExprError(expr_info
,
537 "Simple union '%s' must not have a base"
540 # Else, it's a flat union.
542 # The object must have a string member 'base'.
543 if not isinstance(base
, str):
544 raise QAPIExprError(expr_info
,
545 "Flat union '%s' must have a string base field"
547 base_fields
= find_base_fields(base
)
549 raise QAPIExprError(expr_info
,
550 "Base '%s' is not a valid struct"
553 # The value of member 'discriminator' must name a non-optional
554 # member of the base struct.
555 check_name(expr_info
, "Discriminator of flat union '%s'" % name
,
557 discriminator_type
= base_fields
.get(discriminator
)
558 if not discriminator_type
:
559 raise QAPIExprError(expr_info
,
560 "Discriminator '%s' is not a member of base "
562 % (discriminator
, base
))
563 enum_define
= find_enum(discriminator_type
)
564 allow_metas
=['struct']
565 # Do not allow string discriminator
567 raise QAPIExprError(expr_info
,
568 "Discriminator '%s' must be of enumeration "
569 "type" % discriminator
)
572 for (key
, value
) in members
.items():
573 check_name(expr_info
, "Member of union '%s'" % name
, key
)
575 # Each value must name a known type; furthermore, in flat unions,
576 # branches must be a struct with no overlapping member names
577 check_type(expr_info
, "Member '%s' of union '%s'" % (key
, name
),
578 value
, allow_array
=not base
, allow_metas
=allow_metas
)
580 branch_struct
= find_struct(value
)
582 check_member_clash(expr_info
, base
, branch_struct
['data'],
583 " of branch '%s'" % key
)
585 # If the discriminator names an enum type, then all members
586 # of 'data' must also be members of the enum type.
588 if not key
in enum_define
['enum_values']:
589 raise QAPIExprError(expr_info
,
590 "Discriminator value '%s' is not found in "
592 (key
, enum_define
["enum_name"]))
594 # Otherwise, check for conflicts in the generated enum
596 c_key
= camel_to_upper(key
)
598 raise QAPIExprError(expr_info
,
599 "Union '%s' member '%s' clashes with '%s'"
600 % (name
, key
, values
[c_key
]))
603 def check_alternate(expr
, expr_info
):
604 name
= expr
['alternate']
605 members
= expr
['data']
606 values
= { 'MAX': '(automatic)' }
610 for (key
, value
) in members
.items():
611 check_name(expr_info
, "Member of alternate '%s'" % name
, key
)
613 # Check for conflicts in the generated enum
614 c_key
= camel_to_upper(key
)
616 raise QAPIExprError(expr_info
,
617 "Alternate '%s' member '%s' clashes with '%s'"
618 % (name
, key
, values
[c_key
]))
621 # Ensure alternates have no type conflicts.
622 check_type(expr_info
, "Member '%s' of alternate '%s'" % (key
, name
),
624 allow_metas
=['built-in', 'union', 'struct', 'enum'])
625 qtype
= find_alternate_member_qtype(value
)
627 if qtype
in types_seen
:
628 raise QAPIExprError(expr_info
,
629 "Alternate '%s' member '%s' can't "
630 "be distinguished from member '%s'"
631 % (name
, key
, types_seen
[qtype
]))
632 types_seen
[qtype
] = key
634 def check_enum(expr
, expr_info
):
636 members
= expr
.get('data')
637 values
= { 'MAX': '(automatic)' }
639 if not isinstance(members
, list):
640 raise QAPIExprError(expr_info
,
641 "Enum '%s' requires an array for 'data'" % name
)
642 for member
in members
:
643 check_name(expr_info
, "Member of enum '%s'" %name
, member
,
645 key
= camel_to_upper(member
)
647 raise QAPIExprError(expr_info
,
648 "Enum '%s' member '%s' clashes with '%s'"
649 % (name
, member
, values
[key
]))
652 def check_struct(expr
, expr_info
):
653 name
= expr
['struct']
654 members
= expr
['data']
656 check_type(expr_info
, "'data' for struct '%s'" % name
, members
,
657 allow_dict
=True, allow_optional
=True)
658 check_type(expr_info
, "'base' for struct '%s'" % name
, expr
.get('base'),
659 allow_metas
=['struct'])
661 check_member_clash(expr_info
, expr
['base'], expr
['data'])
663 def check_keys(expr_elem
, meta
, required
, optional
=[]):
664 expr
= expr_elem
['expr']
665 info
= expr_elem
['info']
667 if not isinstance(name
, str):
668 raise QAPIExprError(info
,
669 "'%s' key must have a string value" % meta
)
670 required
= required
+ [ meta
]
671 for (key
, value
) in expr
.items():
672 if not key
in required
and not key
in optional
:
673 raise QAPIExprError(info
,
674 "Unknown key '%s' in %s '%s'"
676 if (key
== 'gen' or key
== 'success-response') and value
!= False:
677 raise QAPIExprError(info
,
678 "'%s' of %s '%s' should only use false value"
681 if not expr
.has_key(key
):
682 raise QAPIExprError(info
,
683 "Key '%s' is missing from %s '%s'"
686 def check_exprs(exprs
):
689 # Learn the types and check for valid expression keys
690 for builtin
in builtin_types
.keys():
691 all_names
[builtin
] = 'built-in'
692 for expr_elem
in exprs
:
693 expr
= expr_elem
['expr']
694 info
= expr_elem
['info']
695 if expr
.has_key('enum'):
696 check_keys(expr_elem
, 'enum', ['data'])
697 add_enum(expr
['enum'], info
, expr
['data'])
698 elif expr
.has_key('union'):
699 check_keys(expr_elem
, 'union', ['data'],
700 ['base', 'discriminator'])
701 add_union(expr
, info
)
702 elif expr
.has_key('alternate'):
703 check_keys(expr_elem
, 'alternate', ['data'])
704 add_name(expr
['alternate'], info
, 'alternate')
705 elif expr
.has_key('struct'):
706 check_keys(expr_elem
, 'struct', ['data'], ['base'])
707 add_struct(expr
, info
)
708 elif expr
.has_key('command'):
709 check_keys(expr_elem
, 'command', [],
710 ['data', 'returns', 'gen', 'success-response'])
711 add_name(expr
['command'], info
, 'command')
712 elif expr
.has_key('event'):
713 check_keys(expr_elem
, 'event', [], ['data'])
714 add_name(expr
['event'], info
, 'event')
716 raise QAPIExprError(expr_elem
['info'],
717 "Expression is missing metatype")
719 # Try again for hidden UnionKind enum
720 for expr_elem
in exprs
:
721 expr
= expr_elem
['expr']
722 if expr
.has_key('union'):
723 if not discriminator_find_enum_define(expr
):
724 add_enum('%sKind' % expr
['union'], expr_elem
['info'],
726 elif expr
.has_key('alternate'):
727 add_enum('%sKind' % expr
['alternate'], expr_elem
['info'],
730 # Validate that exprs make sense
731 for expr_elem
in exprs
:
732 expr
= expr_elem
['expr']
733 info
= expr_elem
['info']
735 if expr
.has_key('enum'):
736 check_enum(expr
, info
)
737 elif expr
.has_key('union'):
738 check_union(expr
, info
)
739 elif expr
.has_key('alternate'):
740 check_alternate(expr
, info
)
741 elif expr
.has_key('struct'):
742 check_struct(expr
, info
)
743 elif expr
.has_key('command'):
744 check_command(expr
, info
)
745 elif expr
.has_key('event'):
746 check_event(expr
, info
)
748 assert False, 'unexpected meta type'
750 return map(lambda expr_elem
: expr_elem
['expr'], exprs
)
752 def parse_schema(fname
):
754 schema
= QAPISchema(open(fname
, "r"))
755 return check_exprs(schema
.exprs
)
756 except (QAPISchemaError
, QAPIExprError
), e
:
757 print >>sys
.stderr
, e
761 # Code generation helpers
764 def parse_args(typeinfo
):
765 if isinstance(typeinfo
, str):
766 struct
= find_struct(typeinfo
)
767 assert struct
!= None
768 typeinfo
= struct
['data']
770 for member
in typeinfo
:
772 argentry
= typeinfo
[member
]
774 if member
.startswith('*'):
777 # Todo: allow argentry to be OrderedDict, for providing the
778 # value of an optional argument.
779 yield (argname
, argentry
, optional
)
781 def camel_case(name
):
788 new_name
+= ch
.upper()
791 new_name
+= ch
.lower()
794 # ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1
795 # ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2
796 # ENUM24_Name -> ENUM24_NAME
797 def camel_to_upper(value
):
798 c_fun_str
= c_name(value
, False)
806 # When c is upper and no "_" appears before, do more checks
807 if c
.isupper() and (i
> 0) and c_fun_str
[i
- 1] != "_":
808 # Case 1: next string is lower
809 # Case 2: previous string is digit
810 if (i
< (l
- 1) and c_fun_str
[i
+ 1].islower()) or \
811 c_fun_str
[i
- 1].isdigit():
814 return new_name
.lstrip('_').upper()
816 def c_enum_const(type_name
, const_name
):
817 return camel_to_upper(type_name
+ '_' + const_name
)
819 c_name_trans
= string
.maketrans('.-', '__')
821 # Map @name to a valid C identifier.
822 # If @protect, avoid returning certain ticklish identifiers (like
823 # C keywords) by prepending "q_".
825 # Used for converting 'name' from a 'name':'type' qapi definition
826 # into a generated struct member, as well as converting type names
827 # into substrings of a generated C function name.
828 # '__a.b_c' -> '__a_b_c', 'x-foo' -> 'x_foo'
829 # protect=True: 'int' -> 'q_int'; protect=False: 'int' -> 'int'
830 def c_name(name
, protect
=True):
831 # ANSI X3J11/88-090, 3.1.1
832 c89_words
= set(['auto', 'break', 'case', 'char', 'const', 'continue',
833 'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
834 'for', 'goto', 'if', 'int', 'long', 'register', 'return',
835 'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
836 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'])
837 # ISO/IEC 9899:1999, 6.4.1
838 c99_words
= set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
839 # ISO/IEC 9899:2011, 6.4.1
840 c11_words
= set(['_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
841 '_Static_assert', '_Thread_local'])
842 # GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
844 gcc_words
= set(['asm', 'typeof'])
845 # C++ ISO/IEC 14882:2003 2.11
846 cpp_words
= set(['bool', 'catch', 'class', 'const_cast', 'delete',
847 'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
848 'namespace', 'new', 'operator', 'private', 'protected',
849 'public', 'reinterpret_cast', 'static_cast', 'template',
850 'this', 'throw', 'true', 'try', 'typeid', 'typename',
851 'using', 'virtual', 'wchar_t',
852 # alternative representations
853 'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
854 'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
855 # namespace pollution:
856 polluted_words
= set(['unix', 'errno'])
857 if protect
and (name
in c89_words | c99_words | c11_words | gcc_words | cpp_words | polluted_words
):
859 return name
.translate(c_name_trans
)
861 # Map type @name to the C typedef name for the list form.
863 # ['Name'] -> 'NameList', ['x-Foo'] -> 'x_FooList', ['int'] -> 'intList'
864 def c_list_type(name
):
865 return type_name(name
) + 'List'
867 # Map type @value to the C typedef form.
869 # Used for converting 'type' from a 'member':'type' qapi definition
870 # into the alphanumeric portion of the type for a generated C parameter,
871 # as well as generated C function names. See c_type() for the rest of
872 # the conversion such as adding '*' on pointer types.
873 # 'int' -> 'int', '[x-Foo]' -> 'x_FooList', '__a.b_c' -> '__a_b_c'
874 def type_name(value
):
875 if type(value
) == list:
876 return c_list_type(value
[0])
877 if value
in builtin_types
.keys():
881 eatspace
= '\033EATSPACE.'
882 pointer_suffix
= ' *' + eatspace
884 # Map type @name to its C type expression.
885 # If @is_param, const-qualify the string type.
887 # This function is used for computing the full C type of 'member':'name'.
888 # A special suffix is added in c_type() for pointer types, and it's
889 # stripped in mcgen(). So please notice this when you check the return
890 # value of c_type() outside mcgen().
891 def c_type(value
, is_param
=False):
894 return 'const char' + pointer_suffix
895 return 'char' + pointer_suffix
899 elif (value
== 'int8' or value
== 'int16' or value
== 'int32' or
900 value
== 'int64' or value
== 'uint8' or value
== 'uint16' or
901 value
== 'uint32' or value
== 'uint64'):
903 elif value
== 'size':
905 elif value
== 'bool':
907 elif value
== 'number':
909 elif type(value
) == list:
910 return c_list_type(value
[0]) + pointer_suffix
915 elif value
in events
:
916 return camel_case(value
) + 'Event' + pointer_suffix
919 assert isinstance(value
, str) and value
!= ""
920 return c_name(value
) + pointer_suffix
923 return c_type(value
).endswith(pointer_suffix
)
925 def genindent(count
):
927 for i
in range(count
):
933 def push_indent(indent_amount
=4):
935 indent_level
+= indent_amount
937 def pop_indent(indent_amount
=4):
939 indent_level
-= indent_amount
941 # Generate @code with @kwds interpolated.
942 # Obey indent_level, and strip eatspace.
943 def cgen(code
, **kwds
):
946 indent
= genindent(indent_level
)
947 # re.subn() lacks flags support before Python 2.7, use re.compile()
948 raw
= re
.subn(re
.compile("^.", re
.MULTILINE
),
949 indent
+ r
'\g<0>', raw
)
951 return re
.sub(re
.escape(eatspace
) + ' *', '', raw
)
953 def mcgen(code
, **kwds
):
956 return cgen(code
, **kwds
)
959 def guardname(filename
):
960 return c_name(filename
, protect
=False).upper()
962 def guardstart(name
):
969 name
=guardname(name
))
974 #endif /* %(name)s */
977 name
=guardname(name
))
980 # Common command line parsing
983 def parse_command_line(extra_options
= "", extra_long_options
= []):
986 opts
, args
= getopt
.gnu_getopt(sys
.argv
[1:],
987 "chp:o:" + extra_options
,
988 ["source", "header", "prefix=",
989 "output-dir="] + extra_long_options
)
990 except getopt
.GetoptError
, err
:
991 print >>sys
.stderr
, "%s: %s" % (sys
.argv
[0], str(err
))
1002 if o
in ("-p", "--prefix"):
1003 match
= re
.match('([A-Za-z_.-][A-Za-z0-9_.-]*)?', a
)
1004 if match
.end() != len(a
):
1005 print >>sys
.stderr
, \
1006 "%s: 'funny character '%s' in argument of --prefix" \
1007 % (sys
.argv
[0], a
[match
.end()])
1010 elif o
in ("-o", "--output-dir"):
1011 output_dir
= a
+ "/"
1012 elif o
in ("-c", "--source"):
1014 elif o
in ("-h", "--header"):
1017 extra_opts
.append(oa
)
1019 if not do_c
and not do_h
:
1024 print >>sys
.stderr
, "%s: need exactly one argument" % sys
.argv
[0]
1028 return (fname
, output_dir
, do_c
, do_h
, prefix
, extra_opts
)
1031 # Generate output files with boilerplate
1034 def open_output(output_dir
, do_c
, do_h
, prefix
, c_file
, h_file
,
1035 c_comment
, h_comment
):
1036 guard
= guardname(prefix
+ h_file
)
1037 c_file
= output_dir
+ prefix
+ c_file
1038 h_file
= output_dir
+ prefix
+ h_file
1042 os
.makedirs(output_dir
)
1044 if e
.errno
!= errno
.EEXIST
:
1047 def maybe_open(really
, name
, opt
):
1049 return open(name
, opt
)
1052 return StringIO
.StringIO()
1054 fdef
= maybe_open(do_c
, c_file
, 'w')
1055 fdecl
= maybe_open(do_h
, h_file
, 'w')
1057 fdef
.write(mcgen('''
1058 /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
1061 comment
= c_comment
))
1063 fdecl
.write(mcgen('''
1064 /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
1070 comment
= h_comment
, guard
= guard
))
1072 return (fdef
, fdecl
)
1074 def close_output(fdef
, fdecl
):