scripts/qapi/common.py

   1 #
   2 # QAPI helper library
   3 #
   4 # Copyright IBM, Corp. 2011
   5 # Copyright (c) 2013-2018 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 GPL, version 2.
  12 # See the COPYING file in the top-level directory.
  13
  14 import re
  15 from typing import (
  16     Any,
  17     Dict,
  18     Match,
  19     Optional,
  20     Sequence,
  21     Union,
  22 )
  23
  24
  25 #: Magic string that gets removed along with all space to its right.
  26 EATSPACE = '\033EATSPACE.'
  27 POINTER_SUFFIX = ' *' + EATSPACE
  28
  29
  30 def camel_to_upper(value: str) -> str:
  31     """
  32     Converts CamelCase to CAMEL_CASE.
  33
  34     Examples::
  35
  36         ENUMName -> ENUM_NAME
  37         EnumName1 -> ENUM_NAME1
  38         ENUM_NAME -> ENUM_NAME
  39         ENUM_NAME1 -> ENUM_NAME1
  40         ENUM_Name2 -> ENUM_NAME2
  41         ENUM24_Name -> ENUM24_NAME
  42     """
  43     c_fun_str = c_name(value, False)
  44     if value.isupper():
  45         return c_fun_str
  46
  47     new_name = ''
  48     length = len(c_fun_str)
  49     for i in range(length):
  50         char = c_fun_str[i]
  51         # When char is upper case and no '_' appears before, do more checks
  52         if char.isupper() and (i > 0) and c_fun_str[i - 1] != '_':
  53             if i < length - 1 and c_fun_str[i + 1].islower():
  54                 new_name += '_'
  55             elif c_fun_str[i - 1].isdigit():
  56                 new_name += '_'
  57         new_name += char
  58     return new_name.lstrip('_').upper()
  59
  60
  61 def c_enum_const(type_name: str,
  62                  const_name: str,
  63                  prefix: Optional[str] = None) -> str:
  64     """
  65     Generate a C enumeration constant name.
  66
  67     :param type_name: The name of the enumeration.
  68     :param const_name: The name of this constant.
  69     :param prefix: Optional, prefix that overrides the type_name.
  70     """
  71     if prefix is not None:
  72         type_name = prefix
  73     return camel_to_upper(type_name) + '_' + c_name(const_name, False).upper()
  74
  75
  76 def c_name(name: str, protect: bool = True) -> str:
  77     """
  78     Map ``name`` to a valid C identifier.
  79
  80     Used for converting 'name' from a 'name':'type' qapi definition
  81     into a generated struct member, as well as converting type names
  82     into substrings of a generated C function name.
  83
  84     '__a.b_c' -> '__a_b_c', 'x-foo' -> 'x_foo'
  85     protect=True: 'int' -> 'q_int'; protect=False: 'int' -> 'int'
  86
  87     :param name: The name to map.
  88     :param protect: If true, avoid returning certain ticklish identifiers
  89                     (like C keywords) by prepending ``q_``.
  90     """
  91     # ANSI X3J11/88-090, 3.1.1
  92     c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue',
  93                      'default', 'do', 'double', 'else', 'enum', 'extern',
  94                      'float', 'for', 'goto', 'if', 'int', 'long', 'register',
  95                      'return', 'short', 'signed', 'sizeof', 'static',
  96                      'struct', 'switch', 'typedef', 'union', 'unsigned',
  97                      'void', 'volatile', 'while'])
  98     # ISO/IEC 9899:1999, 6.4.1
  99     c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
 100     # ISO/IEC 9899:2011, 6.4.1
 101     c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic',
 102                      '_Noreturn', '_Static_assert', '_Thread_local'])
 103     # GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
 104     # excluding _.*
 105     gcc_words = set(['asm', 'typeof'])
 106     # C++ ISO/IEC 14882:2003 2.11
 107     cpp_words = set(['bool', 'catch', 'class', 'const_cast', 'delete',
 108                      'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
 109                      'namespace', 'new', 'operator', 'private', 'protected',
 110                      'public', 'reinterpret_cast', 'static_cast', 'template',
 111                      'this', 'throw', 'true', 'try', 'typeid', 'typename',
 112                      'using', 'virtual', 'wchar_t',
 113                      # alternative representations
 114                      'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
 115                      'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
 116     # namespace pollution:
 117     polluted_words = set(['unix', 'errno', 'mips', 'sparc', 'i386', 'linux'])
 118     name = re.sub(r'[^A-Za-z0-9_]', '_', name)
 119     if protect and (name in (c89_words | c99_words | c11_words | gcc_words
 120                              | cpp_words | polluted_words)
 121                     or name[0].isdigit()):
 122         return 'q_' + name
 123     return name
 124
 125
 126 class Indentation:
 127     """
 128     Indentation level management.
 129
 130     :param initial: Initial number of spaces, default 0.
 131     """
 132     def __init__(self, initial: int = 0) -> None:
 133         self._level = initial
 134
 135     def __repr__(self) -> str:
 136         return "{}({:d})".format(type(self).__name__, self._level)
 137
 138     def __str__(self) -> str:
 139         """Return the current indentation as a string of spaces."""
 140         return ' ' * self._level
 141
 142     def increase(self, amount: int = 4) -> None:
 143         """Increase the indentation level by ``amount``, default 4."""
 144         self._level += amount
 145
 146     def decrease(self, amount: int = 4) -> None:
 147         """Decrease the indentation level by ``amount``, default 4."""
 148         assert amount <= self._level
 149         self._level -= amount
 150
 151
 152 #: Global, current indent level for code generation.
 153 indent = Indentation()
 154
 155
 156 def cgen(code: str, **kwds: object) -> str:
 157     """
 158     Generate ``code`` with ``kwds`` interpolated.
 159
 160     Obey `indent`, and strip `EATSPACE`.
 161     """
 162     raw = code % kwds
 163     pfx = str(indent)
 164     if pfx:
 165         raw = re.sub(r'^(?!(#|$))', pfx, raw, flags=re.MULTILINE)
 166     return re.sub(re.escape(EATSPACE) + r' *', '', raw)
 167
 168
 169 def mcgen(code: str, **kwds: object) -> str:
 170     if code[0] == '\n':
 171         code = code[1:]
 172     return cgen(code, **kwds)
 173
 174
 175 def c_fname(filename: str) -> str:
 176     return re.sub(r'[^A-Za-z0-9_]', '_', filename)
 177
 178
 179 def guardstart(name: str) -> str:
 180     return mcgen('''
 181 #ifndef %(name)s
 182 #define %(name)s
 183
 184 ''',
 185                  name=c_fname(name).upper())
 186
 187
 188 def guardend(name: str) -> str:
 189     return mcgen('''
 190
 191 #endif /* %(name)s */
 192 ''',
 193                  name=c_fname(name).upper())
 194
 195
 196 def gen_ifcond(ifcond: Optional[Union[str, Dict[str, Any]]],
 197                cond_fmt: str, not_fmt: str,
 198                all_operator: str, any_operator: str) -> str:
 199
 200     def do_gen(ifcond: Union[str, Dict[str, Any]],
 201                need_parens: bool) -> str:
 202         if isinstance(ifcond, str):
 203             return cond_fmt % ifcond
 204         assert isinstance(ifcond, dict) and len(ifcond) == 1
 205         if 'not' in ifcond:
 206             return not_fmt % do_gen(ifcond['not'], True)
 207         if 'all' in ifcond:
 208             gen = gen_infix(all_operator, ifcond['all'])
 209         else:
 210             gen = gen_infix(any_operator, ifcond['any'])
 211         if need_parens:
 212             gen = '(' + gen + ')'
 213         return gen
 214
 215     def gen_infix(operator: str, operands: Sequence[Any]) -> str:
 216         return operator.join([do_gen(o, True) for o in operands])
 217
 218     if not ifcond:
 219         return ''
 220     return do_gen(ifcond, False)
 221
 222
 223 def cgen_ifcond(ifcond: Optional[Union[str, Dict[str, Any]]]) -> str:
 224     return gen_ifcond(ifcond, 'defined(%s)', '!%s', ' && ', ' || ')
 225
 226
 227 def docgen_ifcond(ifcond: Optional[Union[str, Dict[str, Any]]]) -> str:
 228     # TODO Doc generated for conditions needs polish
 229     return gen_ifcond(ifcond, '%s', 'not %s', ' and ', ' or ')
 230
 231
 232 def gen_if(cond: str) -> str:
 233     if not cond:
 234         return ''
 235     return mcgen('''
 236 #if %(cond)s
 237 ''', cond=cond)
 238
 239
 240 def gen_endif(cond: str) -> str:
 241     if not cond:
 242         return ''
 243     return mcgen('''
 244 #endif /* %(cond)s */
 245 ''', cond=cond)
 246
 247
 248 def must_match(pattern: str, string: str) -> Match[str]:
 249     match = re.match(pattern, string)
 250     assert match is not None
 251     return match