Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1 | # |
| 2 | # QAPI helper library |
| 3 | # |
| 4 | # Copyright IBM, Corp. 2011 |
Eric Blake | e408311 | 2016-01-29 06:48:41 -0700 | [diff] [blame] | 5 | # Copyright (c) 2013-2016 Red Hat Inc. |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 6 | # |
| 7 | # Authors: |
| 8 | # Anthony Liguori <aliguori@us.ibm.com> |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 9 | # Markus Armbruster <armbru@redhat.com> |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 10 | # |
Markus Armbruster | 678e48a | 2014-03-01 08:40:34 +0100 | [diff] [blame] | 11 | # This work is licensed under the terms of the GNU GPL, version 2. |
| 12 | # See the COPYING file in the top-level directory. |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 13 | |
Lluís Vilanova | a719a27 | 2014-05-07 20:46:15 +0200 | [diff] [blame] | 14 | import re |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 15 | from ordereddict import OrderedDict |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 16 | import errno |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 17 | import getopt |
Lluís Vilanova | 33aaad5 | 2014-05-02 15:52:35 +0200 | [diff] [blame] | 18 | import os |
Markus Armbruster | 2caba36 | 2013-07-27 17:41:56 +0200 | [diff] [blame] | 19 | import sys |
Markus Armbruster | 4729926 | 2015-05-14 06:50:47 -0600 | [diff] [blame] | 20 | import string |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 21 | |
Eric Blake | b52c4b9 | 2015-05-04 09:05:00 -0600 | [diff] [blame] | 22 | builtin_types = { |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 23 | 'str': 'QTYPE_QSTRING', |
| 24 | 'int': 'QTYPE_QINT', |
| 25 | 'number': 'QTYPE_QFLOAT', |
| 26 | 'bool': 'QTYPE_QBOOL', |
| 27 | 'int8': 'QTYPE_QINT', |
| 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', |
Eric Blake | cb17f79 | 2015-05-04 09:05:01 -0600 | [diff] [blame] | 35 | 'size': 'QTYPE_QINT', |
Eric Blake | 1310a3d | 2015-12-01 22:20:46 -0700 | [diff] [blame] | 36 | 'any': None, # any QType possible, actually |
Eric Blake | 7264f5c | 2015-12-01 22:20:47 -0700 | [diff] [blame] | 37 | 'QType': 'QTYPE_QSTRING', |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 38 | } |
| 39 | |
Markus Armbruster | bc52d03 | 2017-03-15 13:56:51 +0100 | [diff] [blame] | 40 | # Are documentation comments required? |
| 41 | doc_required = False |
| 42 | |
Eric Blake | 10d4d99 | 2015-05-04 09:05:23 -0600 | [diff] [blame] | 43 | # Whitelist of commands allowed to return a non-dictionary |
Markus Armbruster | 1554a8f | 2017-03-15 13:56:54 +0100 | [diff] [blame] | 44 | returns_whitelist = [] |
Eric Blake | 10d4d99 | 2015-05-04 09:05:23 -0600 | [diff] [blame] | 45 | |
Eric Blake | 893e1f2 | 2015-12-01 22:20:57 -0700 | [diff] [blame] | 46 | # Whitelist of entities allowed to violate case conventions |
Markus Armbruster | 2cfbae3 | 2017-03-15 13:56:55 +0100 | [diff] [blame^] | 47 | name_case_whitelist = [] |
Eric Blake | 893e1f2 | 2015-12-01 22:20:57 -0700 | [diff] [blame] | 48 | |
Eric Blake | 4dc2e69 | 2015-05-04 09:05:17 -0600 | [diff] [blame] | 49 | enum_types = [] |
| 50 | struct_types = [] |
| 51 | union_types = [] |
| 52 | events = [] |
| 53 | all_names = {} |
| 54 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 55 | # |
| 56 | # Parsing the schema into expressions |
| 57 | # |
| 58 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 59 | |
Lluís Vilanova | a719a27 | 2014-05-07 20:46:15 +0200 | [diff] [blame] | 60 | def error_path(parent): |
| 61 | res = "" |
| 62 | while parent: |
| 63 | res = ("In file included from %s:%d:\n" % (parent['file'], |
| 64 | parent['line'])) + res |
| 65 | parent = parent['parent'] |
| 66 | return res |
| 67 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 68 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 69 | class QAPIError(Exception): |
| 70 | def __init__(self, fname, line, col, incl_info, msg): |
Eric Blake | 59b0054 | 2015-09-29 16:21:01 -0600 | [diff] [blame] | 71 | Exception.__init__(self) |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 72 | self.fname = fname |
| 73 | self.line = line |
| 74 | self.col = col |
| 75 | self.info = incl_info |
Markus Armbruster | 2caba36 | 2013-07-27 17:41:56 +0200 | [diff] [blame] | 76 | self.msg = msg |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 77 | |
| 78 | def __str__(self): |
| 79 | loc = "%s:%d" % (self.fname, self.line) |
| 80 | if self.col is not None: |
| 81 | loc += ":%s" % self.col |
| 82 | return error_path(self.info) + "%s: %s" % (loc, self.msg) |
| 83 | |
| 84 | |
| 85 | class QAPIParseError(QAPIError): |
| 86 | def __init__(self, parser, msg): |
| 87 | col = 1 |
| 88 | for ch in parser.src[parser.line_pos:parser.pos]: |
Wenchao Xia | 515b943 | 2014-03-04 18:44:33 -0800 | [diff] [blame] | 89 | if ch == '\t': |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 90 | col = (col + 7) % 8 + 1 |
Markus Armbruster | 2caba36 | 2013-07-27 17:41:56 +0200 | [diff] [blame] | 91 | else: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 92 | col += 1 |
| 93 | QAPIError.__init__(self, parser.fname, parser.line, col, |
| 94 | parser.incl_info, msg) |
Markus Armbruster | 2caba36 | 2013-07-27 17:41:56 +0200 | [diff] [blame] | 95 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 96 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 97 | class QAPISemError(QAPIError): |
| 98 | def __init__(self, info, msg): |
| 99 | QAPIError.__init__(self, info['file'], info['line'], None, |
| 100 | info['parent'], msg) |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 101 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 102 | |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 103 | class QAPIDoc(object): |
| 104 | class Section(object): |
| 105 | def __init__(self, name=None): |
| 106 | # optional section name (argument/member or section name) |
| 107 | self.name = name |
| 108 | # the list of lines for this section |
| 109 | self.content = [] |
| 110 | |
| 111 | def append(self, line): |
| 112 | self.content.append(line) |
| 113 | |
| 114 | def __repr__(self): |
| 115 | return "\n".join(self.content).strip() |
| 116 | |
| 117 | class ArgSection(Section): |
| 118 | pass |
| 119 | |
| 120 | def __init__(self, parser, info): |
| 121 | # self.parser is used to report errors with QAPIParseError. The |
| 122 | # resulting error position depends on the state of the parser. |
| 123 | # It happens to be the beginning of the comment. More or less |
| 124 | # servicable, but action at a distance. |
| 125 | self.parser = parser |
| 126 | self.info = info |
| 127 | self.symbol = None |
| 128 | self.body = QAPIDoc.Section() |
| 129 | # dict mapping parameter name to ArgSection |
| 130 | self.args = OrderedDict() |
| 131 | # a list of Section |
| 132 | self.sections = [] |
| 133 | # the current section |
| 134 | self.section = self.body |
| 135 | # associated expression (to be set by expression parser) |
| 136 | self.expr = None |
| 137 | |
| 138 | def has_section(self, name): |
| 139 | """Return True if we have a section with this name.""" |
| 140 | for i in self.sections: |
| 141 | if i.name == name: |
| 142 | return True |
| 143 | return False |
| 144 | |
| 145 | def append(self, line): |
| 146 | """Parse a comment line and add it to the documentation.""" |
| 147 | line = line[1:] |
| 148 | if not line: |
| 149 | self._append_freeform(line) |
| 150 | return |
| 151 | |
| 152 | if line[0] != ' ': |
| 153 | raise QAPIParseError(self.parser, "Missing space after #") |
| 154 | line = line[1:] |
| 155 | |
| 156 | # FIXME not nice: things like '# @foo:' and '# @foo: ' aren't |
| 157 | # recognized, and get silently treated as ordinary text |
| 158 | if self.symbol: |
| 159 | self._append_symbol_line(line) |
| 160 | elif not self.body.content and line.startswith("@"): |
| 161 | if not line.endswith(":"): |
| 162 | raise QAPIParseError(self.parser, "Line should end with :") |
| 163 | self.symbol = line[1:-1] |
| 164 | # FIXME invalid names other than the empty string aren't flagged |
| 165 | if not self.symbol: |
| 166 | raise QAPIParseError(self.parser, "Invalid name") |
| 167 | else: |
| 168 | self._append_freeform(line) |
| 169 | |
| 170 | def _append_symbol_line(self, line): |
| 171 | name = line.split(' ', 1)[0] |
| 172 | |
| 173 | if name.startswith("@") and name.endswith(":"): |
| 174 | line = line[len(name)+1:] |
| 175 | self._start_args_section(name[1:-1]) |
| 176 | elif name in ("Returns:", "Since:", |
| 177 | # those are often singular or plural |
| 178 | "Note:", "Notes:", |
| 179 | "Example:", "Examples:", |
| 180 | "TODO:"): |
| 181 | line = line[len(name)+1:] |
| 182 | self._start_section(name[:-1]) |
| 183 | |
| 184 | self._append_freeform(line) |
| 185 | |
| 186 | def _start_args_section(self, name): |
| 187 | # FIXME invalid names other than the empty string aren't flagged |
| 188 | if not name: |
| 189 | raise QAPIParseError(self.parser, "Invalid parameter name") |
| 190 | if name in self.args: |
| 191 | raise QAPIParseError(self.parser, |
| 192 | "'%s' parameter name duplicated" % name) |
| 193 | if self.sections: |
| 194 | raise QAPIParseError(self.parser, |
| 195 | "'@%s:' can't follow '%s' section" |
| 196 | % (name, self.sections[0].name)) |
| 197 | self.section = QAPIDoc.ArgSection(name) |
| 198 | self.args[name] = self.section |
| 199 | |
| 200 | def _start_section(self, name=""): |
| 201 | if name in ("Returns", "Since") and self.has_section(name): |
| 202 | raise QAPIParseError(self.parser, |
| 203 | "Duplicated '%s' section" % name) |
| 204 | self.section = QAPIDoc.Section(name) |
| 205 | self.sections.append(self.section) |
| 206 | |
| 207 | def _append_freeform(self, line): |
| 208 | in_arg = isinstance(self.section, QAPIDoc.ArgSection) |
| 209 | if (in_arg and self.section.content |
| 210 | and not self.section.content[-1] |
| 211 | and line and not line[0].isspace()): |
| 212 | self._start_section() |
| 213 | if (in_arg or not self.section.name |
| 214 | or not self.section.name.startswith("Example")): |
| 215 | line = line.strip() |
| 216 | self.section.append(line) |
| 217 | |
| 218 | |
Markus Armbruster | a4bcb20 | 2015-09-16 13:06:04 +0200 | [diff] [blame] | 219 | class QAPISchemaParser(object): |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 220 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 221 | def __init__(self, fp, previously_included=[], incl_info=None): |
Markus Armbruster | 5441404 | 2015-06-09 16:22:45 +0200 | [diff] [blame] | 222 | abs_fname = os.path.abspath(fp.name) |
Markus Armbruster | 8608d25 | 2015-06-09 18:32:29 +0200 | [diff] [blame] | 223 | fname = fp.name |
Markus Armbruster | 5441404 | 2015-06-09 16:22:45 +0200 | [diff] [blame] | 224 | self.fname = fname |
Markus Armbruster | 5441404 | 2015-06-09 16:22:45 +0200 | [diff] [blame] | 225 | previously_included.append(abs_fname) |
| 226 | self.incl_info = incl_info |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 227 | self.src = fp.read() |
| 228 | if self.src == '' or self.src[-1] != '\n': |
| 229 | self.src += '\n' |
| 230 | self.cursor = 0 |
Wenchao Xia | 515b943 | 2014-03-04 18:44:33 -0800 | [diff] [blame] | 231 | self.line = 1 |
| 232 | self.line_pos = 0 |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 233 | self.exprs = [] |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 234 | self.docs = [] |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 235 | self.accept() |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 236 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 237 | while self.tok is not None: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 238 | info = {'file': fname, 'line': self.line, |
| 239 | 'parent': self.incl_info} |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 240 | if self.tok == '#': |
| 241 | doc = self.get_doc(info) |
| 242 | self.docs.append(doc) |
| 243 | continue |
| 244 | |
Lluís Vilanova | a719a27 | 2014-05-07 20:46:15 +0200 | [diff] [blame] | 245 | expr = self.get_expr(False) |
Markus Armbruster | e04dea8 | 2017-03-15 13:56:50 +0100 | [diff] [blame] | 246 | if 'include' in expr: |
Lluís Vilanova | a719a27 | 2014-05-07 20:46:15 +0200 | [diff] [blame] | 247 | if len(expr) != 1: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 248 | raise QAPISemError(info, "Invalid 'include' directive") |
Lluís Vilanova | a719a27 | 2014-05-07 20:46:15 +0200 | [diff] [blame] | 249 | include = expr["include"] |
| 250 | if not isinstance(include, str): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 251 | raise QAPISemError(info, |
| 252 | "Value of 'include' must be a string") |
Markus Armbruster | e04dea8 | 2017-03-15 13:56:50 +0100 | [diff] [blame] | 253 | self._include(include, info, os.path.dirname(abs_fname), |
| 254 | previously_included) |
Markus Armbruster | bc52d03 | 2017-03-15 13:56:51 +0100 | [diff] [blame] | 255 | elif "pragma" in expr: |
| 256 | if len(expr) != 1: |
| 257 | raise QAPISemError(info, "Invalid 'pragma' directive") |
| 258 | pragma = expr['pragma'] |
| 259 | if not isinstance(pragma, dict): |
| 260 | raise QAPISemError( |
| 261 | info, "Value of 'pragma' must be a dictionary") |
| 262 | for name, value in pragma.iteritems(): |
| 263 | self._pragma(name, value, info) |
Lluís Vilanova | a719a27 | 2014-05-07 20:46:15 +0200 | [diff] [blame] | 264 | else: |
| 265 | expr_elem = {'expr': expr, |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 266 | 'info': info} |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 267 | if (self.docs |
| 268 | and self.docs[-1].info['file'] == fname |
| 269 | and not self.docs[-1].expr): |
| 270 | self.docs[-1].expr = expr |
| 271 | expr_elem['doc'] = self.docs[-1] |
| 272 | |
Lluís Vilanova | a719a27 | 2014-05-07 20:46:15 +0200 | [diff] [blame] | 273 | self.exprs.append(expr_elem) |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 274 | |
Markus Armbruster | e04dea8 | 2017-03-15 13:56:50 +0100 | [diff] [blame] | 275 | def _include(self, include, info, base_dir, previously_included): |
| 276 | incl_abs_fname = os.path.join(base_dir, include) |
| 277 | # catch inclusion cycle |
| 278 | inf = info |
| 279 | while inf: |
| 280 | if incl_abs_fname == os.path.abspath(inf['file']): |
| 281 | raise QAPISemError(info, "Inclusion loop for %s" % include) |
| 282 | inf = inf['parent'] |
| 283 | |
| 284 | # skip multiple include of the same file |
| 285 | if incl_abs_fname in previously_included: |
| 286 | return |
| 287 | try: |
| 288 | fobj = open(incl_abs_fname, 'r') |
| 289 | except IOError as e: |
| 290 | raise QAPISemError(info, '%s: %s' % (e.strerror, include)) |
| 291 | exprs_include = QAPISchemaParser(fobj, previously_included, info) |
| 292 | self.exprs.extend(exprs_include.exprs) |
| 293 | self.docs.extend(exprs_include.docs) |
| 294 | |
Markus Armbruster | bc52d03 | 2017-03-15 13:56:51 +0100 | [diff] [blame] | 295 | def _pragma(self, name, value, info): |
Markus Armbruster | 2cfbae3 | 2017-03-15 13:56:55 +0100 | [diff] [blame^] | 296 | global doc_required, returns_whitelist, name_case_whitelist |
Markus Armbruster | bc52d03 | 2017-03-15 13:56:51 +0100 | [diff] [blame] | 297 | if name == 'doc-required': |
| 298 | if not isinstance(value, bool): |
| 299 | raise QAPISemError(info, |
| 300 | "Pragma 'doc-required' must be boolean") |
| 301 | doc_required = value |
Markus Armbruster | 1554a8f | 2017-03-15 13:56:54 +0100 | [diff] [blame] | 302 | elif name == 'returns-whitelist': |
| 303 | if (not isinstance(value, list) |
| 304 | or any([not isinstance(elt, str) for elt in value])): |
| 305 | raise QAPISemError(info, |
| 306 | "Pragma returns-whitelist must be" |
| 307 | " a list of strings") |
| 308 | returns_whitelist = value |
Markus Armbruster | 2cfbae3 | 2017-03-15 13:56:55 +0100 | [diff] [blame^] | 309 | elif name == 'name-case-whitelist': |
| 310 | if (not isinstance(value, list) |
| 311 | or any([not isinstance(elt, str) for elt in value])): |
| 312 | raise QAPISemError(info, |
| 313 | "Pragma name-case-whitelist must be" |
| 314 | " a list of strings") |
| 315 | name_case_whitelist = value |
Markus Armbruster | bc52d03 | 2017-03-15 13:56:51 +0100 | [diff] [blame] | 316 | else: |
| 317 | raise QAPISemError(info, "Unknown pragma '%s'" % name) |
| 318 | |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 319 | def accept(self, skip_comment=True): |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 320 | while True: |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 321 | self.tok = self.src[self.cursor] |
Markus Armbruster | 2caba36 | 2013-07-27 17:41:56 +0200 | [diff] [blame] | 322 | self.pos = self.cursor |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 323 | self.cursor += 1 |
| 324 | self.val = None |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 325 | |
Markus Armbruster | f1a145e | 2013-07-27 17:42:01 +0200 | [diff] [blame] | 326 | if self.tok == '#': |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 327 | if self.src[self.cursor] == '#': |
| 328 | # Start of doc comment |
| 329 | skip_comment = False |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 330 | self.cursor = self.src.find('\n', self.cursor) |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 331 | if not skip_comment: |
| 332 | self.val = self.src[self.pos:self.cursor] |
| 333 | return |
Eric Blake | 8712fa5 | 2015-10-26 16:34:41 -0600 | [diff] [blame] | 334 | elif self.tok in "{}:,[]": |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 335 | return |
| 336 | elif self.tok == "'": |
| 337 | string = '' |
| 338 | esc = False |
| 339 | while True: |
| 340 | ch = self.src[self.cursor] |
| 341 | self.cursor += 1 |
| 342 | if ch == '\n': |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 343 | raise QAPIParseError(self, 'Missing terminating "\'"') |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 344 | if esc: |
Eric Blake | a7f5966 | 2015-05-04 09:05:36 -0600 | [diff] [blame] | 345 | if ch == 'b': |
| 346 | string += '\b' |
| 347 | elif ch == 'f': |
| 348 | string += '\f' |
| 349 | elif ch == 'n': |
| 350 | string += '\n' |
| 351 | elif ch == 'r': |
| 352 | string += '\r' |
| 353 | elif ch == 't': |
| 354 | string += '\t' |
| 355 | elif ch == 'u': |
| 356 | value = 0 |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 357 | for _ in range(0, 4): |
Eric Blake | a7f5966 | 2015-05-04 09:05:36 -0600 | [diff] [blame] | 358 | ch = self.src[self.cursor] |
| 359 | self.cursor += 1 |
| 360 | if ch not in "0123456789abcdefABCDEF": |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 361 | raise QAPIParseError(self, |
| 362 | '\\u escape needs 4 ' |
| 363 | 'hex digits') |
Eric Blake | a7f5966 | 2015-05-04 09:05:36 -0600 | [diff] [blame] | 364 | value = (value << 4) + int(ch, 16) |
| 365 | # If Python 2 and 3 didn't disagree so much on |
| 366 | # how to handle Unicode, then we could allow |
| 367 | # Unicode string defaults. But most of QAPI is |
| 368 | # ASCII-only, so we aren't losing much for now. |
| 369 | if not value or value > 0x7f: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 370 | raise QAPIParseError(self, |
| 371 | 'For now, \\u escape ' |
| 372 | 'only supports non-zero ' |
| 373 | 'values up to \\u007f') |
Eric Blake | a7f5966 | 2015-05-04 09:05:36 -0600 | [diff] [blame] | 374 | string += chr(value) |
| 375 | elif ch in "\\/'\"": |
| 376 | string += ch |
| 377 | else: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 378 | raise QAPIParseError(self, |
| 379 | "Unknown escape \\%s" % ch) |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 380 | esc = False |
| 381 | elif ch == "\\": |
| 382 | esc = True |
| 383 | elif ch == "'": |
| 384 | self.val = string |
| 385 | return |
| 386 | else: |
| 387 | string += ch |
Markus Armbruster | e565d93 | 2015-06-10 08:24:58 +0200 | [diff] [blame] | 388 | elif self.src.startswith("true", self.pos): |
| 389 | self.val = True |
| 390 | self.cursor += 3 |
| 391 | return |
| 392 | elif self.src.startswith("false", self.pos): |
| 393 | self.val = False |
| 394 | self.cursor += 4 |
| 395 | return |
| 396 | elif self.src.startswith("null", self.pos): |
| 397 | self.val = None |
| 398 | self.cursor += 3 |
| 399 | return |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 400 | elif self.tok == '\n': |
| 401 | if self.cursor == len(self.src): |
| 402 | self.tok = None |
| 403 | return |
Wenchao Xia | 515b943 | 2014-03-04 18:44:33 -0800 | [diff] [blame] | 404 | self.line += 1 |
| 405 | self.line_pos = self.cursor |
Markus Armbruster | 9213aa5 | 2013-07-27 17:41:57 +0200 | [diff] [blame] | 406 | elif not self.tok.isspace(): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 407 | raise QAPIParseError(self, 'Stray "%s"' % self.tok) |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 408 | |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 409 | def get_members(self): |
| 410 | expr = OrderedDict() |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 411 | if self.tok == '}': |
| 412 | self.accept() |
| 413 | return expr |
| 414 | if self.tok != "'": |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 415 | raise QAPIParseError(self, 'Expected string or "}"') |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 416 | while True: |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 417 | key = self.val |
| 418 | self.accept() |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 419 | if self.tok != ':': |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 420 | raise QAPIParseError(self, 'Expected ":"') |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 421 | self.accept() |
Wenchao Xia | 4b35991 | 2014-03-04 18:44:32 -0800 | [diff] [blame] | 422 | if key in expr: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 423 | raise QAPIParseError(self, 'Duplicate key "%s"' % key) |
Markus Armbruster | 5f3cd2b | 2013-07-27 17:41:59 +0200 | [diff] [blame] | 424 | expr[key] = self.get_expr(True) |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 425 | if self.tok == '}': |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 426 | self.accept() |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 427 | return expr |
| 428 | if self.tok != ',': |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 429 | raise QAPIParseError(self, 'Expected "," or "}"') |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 430 | self.accept() |
| 431 | if self.tok != "'": |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 432 | raise QAPIParseError(self, 'Expected string') |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 433 | |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 434 | def get_values(self): |
| 435 | expr = [] |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 436 | if self.tok == ']': |
| 437 | self.accept() |
| 438 | return expr |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 439 | if self.tok not in "{['tfn": |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 440 | raise QAPIParseError(self, 'Expected "{", "[", "]", string, ' |
| 441 | 'boolean or "null"') |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 442 | while True: |
Markus Armbruster | 5f3cd2b | 2013-07-27 17:41:59 +0200 | [diff] [blame] | 443 | expr.append(self.get_expr(True)) |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 444 | if self.tok == ']': |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 445 | self.accept() |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 446 | return expr |
| 447 | if self.tok != ',': |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 448 | raise QAPIParseError(self, 'Expected "," or "]"') |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 449 | self.accept() |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 450 | |
Markus Armbruster | 5f3cd2b | 2013-07-27 17:41:59 +0200 | [diff] [blame] | 451 | def get_expr(self, nested): |
| 452 | if self.tok != '{' and not nested: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 453 | raise QAPIParseError(self, 'Expected "{"') |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 454 | if self.tok == '{': |
| 455 | self.accept() |
| 456 | expr = self.get_members() |
| 457 | elif self.tok == '[': |
| 458 | self.accept() |
| 459 | expr = self.get_values() |
Fam Zheng | e53188a | 2015-05-04 09:05:18 -0600 | [diff] [blame] | 460 | elif self.tok in "'tfn": |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 461 | expr = self.val |
| 462 | self.accept() |
Markus Armbruster | 6974ccd | 2013-07-27 17:41:58 +0200 | [diff] [blame] | 463 | else: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 464 | raise QAPIParseError(self, 'Expected "{", "[" or string') |
Markus Armbruster | c7a3f25 | 2013-07-27 17:41:55 +0200 | [diff] [blame] | 465 | return expr |
Kevin Wolf | bd9927f | 2013-07-01 16:31:50 +0200 | [diff] [blame] | 466 | |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 467 | def get_doc(self, info): |
| 468 | if self.val != '##': |
| 469 | raise QAPIParseError(self, "Junk after '##' at start of " |
| 470 | "documentation comment") |
| 471 | |
| 472 | doc = QAPIDoc(self, info) |
| 473 | self.accept(False) |
| 474 | while self.tok == '#': |
| 475 | if self.val.startswith('##'): |
| 476 | # End of doc comment |
| 477 | if self.val != '##': |
| 478 | raise QAPIParseError(self, "Junk after '##' at end of " |
| 479 | "documentation comment") |
| 480 | self.accept() |
| 481 | return doc |
| 482 | else: |
| 483 | doc.append(self.val) |
| 484 | self.accept(False) |
| 485 | |
| 486 | raise QAPIParseError(self, "Documentation comment must end with '##'") |
| 487 | |
| 488 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 489 | # |
| 490 | # Semantic analysis of schema expressions |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 491 | # TODO fold into QAPISchema |
| 492 | # TODO catching name collisions in generated code would be nice |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 493 | # |
| 494 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 495 | |
Eric Blake | 14f00c6 | 2016-03-03 09:16:43 -0700 | [diff] [blame] | 496 | def find_base_members(base): |
Eric Blake | ac4338f | 2016-03-17 16:48:39 -0600 | [diff] [blame] | 497 | if isinstance(base, dict): |
| 498 | return base |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 499 | base_struct_define = find_struct(base) |
| 500 | if not base_struct_define: |
| 501 | return None |
| 502 | return base_struct_define['data'] |
| 503 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 504 | |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 505 | # Return the qtype of an alternate branch, or None on error. |
| 506 | def find_alternate_member_qtype(qapi_type): |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 507 | if qapi_type in builtin_types: |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 508 | return builtin_types[qapi_type] |
| 509 | elif find_struct(qapi_type): |
| 510 | return "QTYPE_QDICT" |
| 511 | elif find_enum(qapi_type): |
| 512 | return "QTYPE_QSTRING" |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 513 | elif find_union(qapi_type): |
| 514 | return "QTYPE_QDICT" |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 515 | return None |
| 516 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 517 | |
Wenchao Xia | bceae76 | 2014-03-06 17:08:56 -0800 | [diff] [blame] | 518 | # Return the discriminator enum define if discriminator is specified as an |
| 519 | # enum type, otherwise return None. |
| 520 | def discriminator_find_enum_define(expr): |
| 521 | base = expr.get('base') |
| 522 | discriminator = expr.get('discriminator') |
| 523 | |
| 524 | if not (discriminator and base): |
| 525 | return None |
| 526 | |
Eric Blake | 14f00c6 | 2016-03-03 09:16:43 -0700 | [diff] [blame] | 527 | base_members = find_base_members(base) |
| 528 | if not base_members: |
Wenchao Xia | bceae76 | 2014-03-06 17:08:56 -0800 | [diff] [blame] | 529 | return None |
| 530 | |
Eric Blake | 14f00c6 | 2016-03-03 09:16:43 -0700 | [diff] [blame] | 531 | discriminator_type = base_members.get(discriminator) |
Wenchao Xia | bceae76 | 2014-03-06 17:08:56 -0800 | [diff] [blame] | 532 | if not discriminator_type: |
| 533 | return None |
| 534 | |
| 535 | return find_enum(discriminator_type) |
| 536 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 537 | |
Eric Blake | 59a92fe | 2015-11-18 01:52:56 -0700 | [diff] [blame] | 538 | # Names must be letters, numbers, -, and _. They must start with letter, |
| 539 | # except for downstream extensions which must start with __RFQDN_. |
| 540 | # Dots are only valid in the downstream extension prefix. |
| 541 | valid_name = re.compile('^(__[a-zA-Z0-9.-]+_)?' |
| 542 | '[a-zA-Z][a-zA-Z0-9_-]*$') |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 543 | |
| 544 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 545 | def check_name(info, source, name, allow_optional=False, |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 546 | enum_member=False): |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 547 | global valid_name |
| 548 | membername = name |
| 549 | |
| 550 | if not isinstance(name, str): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 551 | raise QAPISemError(info, "%s requires a string name" % source) |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 552 | if name.startswith('*'): |
| 553 | membername = name[1:] |
| 554 | if not allow_optional: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 555 | raise QAPISemError(info, "%s does not allow optional name '%s'" |
| 556 | % (source, name)) |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 557 | # Enum members can start with a digit, because the generated C |
| 558 | # code always prefixes it with the enum name |
Eric Blake | 59a92fe | 2015-11-18 01:52:56 -0700 | [diff] [blame] | 559 | if enum_member and membername[0].isdigit(): |
| 560 | membername = 'D' + membername |
Eric Blake | 7599697 | 2016-03-17 16:48:29 -0600 | [diff] [blame] | 561 | # Reserve the entire 'q_' namespace for c_name(), and for 'q_empty' |
| 562 | # and 'q_obj_*' implicit type names. |
Eric Blake | 9fb081e | 2015-10-26 16:34:44 -0600 | [diff] [blame] | 563 | if not valid_name.match(membername) or \ |
| 564 | c_name(membername, False).startswith('q_'): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 565 | raise QAPISemError(info, "%s uses invalid name '%s'" % (source, name)) |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 566 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 567 | |
| 568 | def add_name(name, info, meta, implicit=False): |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 569 | global all_names |
| 570 | check_name(info, "'%s'" % meta, name) |
Markus Armbruster | d90675f | 2015-07-31 11:33:52 +0200 | [diff] [blame] | 571 | # FIXME should reject names that differ only in '_' vs. '.' |
| 572 | # vs. '-', because they're liable to clash in generated C. |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 573 | if name in all_names: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 574 | raise QAPISemError(info, "%s '%s' is already defined" |
| 575 | % (all_names[name], name)) |
Eric Blake | 255960d | 2015-10-26 16:34:43 -0600 | [diff] [blame] | 576 | if not implicit and (name.endswith('Kind') or name.endswith('List')): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 577 | raise QAPISemError(info, "%s '%s' should not end in '%s'" |
| 578 | % (meta, name, name[-4:])) |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 579 | all_names[name] = meta |
| 580 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 581 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 582 | def add_struct(definition, info): |
| 583 | global struct_types |
| 584 | name = definition['struct'] |
| 585 | add_name(name, info, 'struct') |
| 586 | struct_types.append(definition) |
| 587 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 588 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 589 | def find_struct(name): |
| 590 | global struct_types |
| 591 | for struct in struct_types: |
| 592 | if struct['struct'] == name: |
| 593 | return struct |
| 594 | return None |
| 595 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 596 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 597 | def add_union(definition, info): |
| 598 | global union_types |
| 599 | name = definition['union'] |
| 600 | add_name(name, info, 'union') |
| 601 | union_types.append(definition) |
| 602 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 603 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 604 | def find_union(name): |
| 605 | global union_types |
| 606 | for union in union_types: |
| 607 | if union['union'] == name: |
| 608 | return union |
| 609 | return None |
| 610 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 611 | |
| 612 | def add_enum(name, info, enum_values=None, implicit=False): |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 613 | global enum_types |
| 614 | add_name(name, info, 'enum', implicit) |
| 615 | enum_types.append({"enum_name": name, "enum_values": enum_values}) |
| 616 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 617 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 618 | def find_enum(name): |
| 619 | global enum_types |
| 620 | for enum in enum_types: |
| 621 | if enum['enum_name'] == name: |
| 622 | return enum |
| 623 | return None |
| 624 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 625 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 626 | def is_enum(name): |
| 627 | return find_enum(name) is not None |
| 628 | |
| 629 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 630 | def check_type(info, source, value, allow_array=False, |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 631 | allow_dict=False, allow_optional=False, |
| 632 | allow_metas=[]): |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 633 | global all_names |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 634 | |
| 635 | if value is None: |
| 636 | return |
| 637 | |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 638 | # Check if array type for value is okay |
| 639 | if isinstance(value, list): |
| 640 | if not allow_array: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 641 | raise QAPISemError(info, "%s cannot be an array" % source) |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 642 | if len(value) != 1 or not isinstance(value[0], str): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 643 | raise QAPISemError(info, |
| 644 | "%s: array type must contain single type name" % |
| 645 | source) |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 646 | value = value[0] |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 647 | |
| 648 | # Check if type name for value is okay |
| 649 | if isinstance(value, str): |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 650 | if value not in all_names: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 651 | raise QAPISemError(info, "%s uses unknown type '%s'" |
| 652 | % (source, value)) |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 653 | if not all_names[value] in allow_metas: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 654 | raise QAPISemError(info, "%s cannot use %s type '%s'" % |
| 655 | (source, all_names[value], value)) |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 656 | return |
| 657 | |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 658 | if not allow_dict: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 659 | raise QAPISemError(info, "%s should be a type name" % source) |
Markus Armbruster | c6b71e5 | 2015-08-31 17:28:52 +0200 | [diff] [blame] | 660 | |
| 661 | if not isinstance(value, OrderedDict): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 662 | raise QAPISemError(info, |
| 663 | "%s should be a dictionary or type name" % source) |
Markus Armbruster | c6b71e5 | 2015-08-31 17:28:52 +0200 | [diff] [blame] | 664 | |
| 665 | # value is a dictionary, check that each member is okay |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 666 | for (key, arg) in value.items(): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 667 | check_name(info, "Member of %s" % source, key, |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 668 | allow_optional=allow_optional) |
Eric Blake | 5e59baf | 2015-10-26 16:35:02 -0600 | [diff] [blame] | 669 | if c_name(key, False) == 'u' or c_name(key, False).startswith('has_'): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 670 | raise QAPISemError(info, "Member of %s uses reserved name '%s'" |
| 671 | % (source, key)) |
Eric Blake | 6b5abc7 | 2015-05-04 09:05:33 -0600 | [diff] [blame] | 672 | # Todo: allow dictionaries to represent default values of |
| 673 | # an optional argument. |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 674 | check_type(info, "Member '%s' of %s" % (key, source), arg, |
Markus Armbruster | 2d21291 | 2015-09-16 13:06:27 +0200 | [diff] [blame] | 675 | allow_array=True, |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 676 | allow_metas=['built-in', 'union', 'alternate', 'struct', |
Eric Blake | 6b5abc7 | 2015-05-04 09:05:33 -0600 | [diff] [blame] | 677 | 'enum']) |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 678 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 679 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 680 | def check_command(expr, info): |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 681 | name = expr['command'] |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 682 | boxed = expr.get('boxed', False) |
Eric Blake | 2cbf099 | 2015-05-04 09:05:24 -0600 | [diff] [blame] | 683 | |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 684 | args_meta = ['struct'] |
| 685 | if boxed: |
| 686 | args_meta += ['union', 'alternate'] |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 687 | check_type(info, "'data' for command '%s'" % name, |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 688 | expr.get('data'), allow_dict=not boxed, allow_optional=True, |
| 689 | allow_metas=args_meta) |
Eric Blake | 10d4d99 | 2015-05-04 09:05:23 -0600 | [diff] [blame] | 690 | returns_meta = ['union', 'struct'] |
| 691 | if name in returns_whitelist: |
| 692 | returns_meta += ['built-in', 'alternate', 'enum'] |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 693 | check_type(info, "'returns' for command '%s'" % name, |
Markus Armbruster | 9b090d4 | 2015-07-31 17:59:38 +0200 | [diff] [blame] | 694 | expr.get('returns'), allow_array=True, |
Markus Armbruster | 2d21291 | 2015-09-16 13:06:27 +0200 | [diff] [blame] | 695 | allow_optional=True, allow_metas=returns_meta) |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 696 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 697 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 698 | def check_event(expr, info): |
Eric Blake | 4dc2e69 | 2015-05-04 09:05:17 -0600 | [diff] [blame] | 699 | global events |
| 700 | name = expr['event'] |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 701 | boxed = expr.get('boxed', False) |
Eric Blake | 4dc2e69 | 2015-05-04 09:05:17 -0600 | [diff] [blame] | 702 | |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 703 | meta = ['struct'] |
| 704 | if boxed: |
| 705 | meta += ['union', 'alternate'] |
Eric Blake | 4dc2e69 | 2015-05-04 09:05:17 -0600 | [diff] [blame] | 706 | events.append(name) |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 707 | check_type(info, "'data' for event '%s'" % name, |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 708 | expr.get('data'), allow_dict=not boxed, allow_optional=True, |
| 709 | allow_metas=meta) |
Wenchao Xia | 21cd70d | 2014-06-18 08:43:28 +0200 | [diff] [blame] | 710 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 711 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 712 | def check_union(expr, info): |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 713 | name = expr['union'] |
| 714 | base = expr.get('base') |
| 715 | discriminator = expr.get('discriminator') |
| 716 | members = expr['data'] |
| 717 | |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 718 | # Two types of unions, determined by discriminator. |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 719 | |
| 720 | # With no discriminator it is a simple union. |
| 721 | if discriminator is None: |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 722 | enum_define = None |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 723 | allow_metas = ['built-in', 'union', 'alternate', 'struct', 'enum'] |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 724 | if base is not None: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 725 | raise QAPISemError(info, "Simple union '%s' must not have a base" % |
| 726 | name) |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 727 | |
| 728 | # Else, it's a flat union. |
| 729 | else: |
Eric Blake | ac4338f | 2016-03-17 16:48:39 -0600 | [diff] [blame] | 730 | # The object must have a string or dictionary 'base'. |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 731 | check_type(info, "'base' for union '%s'" % name, |
Eric Blake | ac4338f | 2016-03-17 16:48:39 -0600 | [diff] [blame] | 732 | base, allow_dict=True, allow_optional=True, |
| 733 | allow_metas=['struct']) |
Eric Blake | 376863e | 2015-09-29 16:21:07 -0600 | [diff] [blame] | 734 | if not base: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 735 | raise QAPISemError(info, "Flat union '%s' must have a base" |
| 736 | % name) |
Eric Blake | 14f00c6 | 2016-03-03 09:16:43 -0700 | [diff] [blame] | 737 | base_members = find_base_members(base) |
| 738 | assert base_members |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 739 | |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 740 | # The value of member 'discriminator' must name a non-optional |
Eric Blake | fd41dd4 | 2015-05-04 09:05:25 -0600 | [diff] [blame] | 741 | # member of the base struct. |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 742 | check_name(info, "Discriminator of flat union '%s'" % name, |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 743 | discriminator) |
Eric Blake | 14f00c6 | 2016-03-03 09:16:43 -0700 | [diff] [blame] | 744 | discriminator_type = base_members.get(discriminator) |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 745 | if not discriminator_type: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 746 | raise QAPISemError(info, |
| 747 | "Discriminator '%s' is not a member of base " |
| 748 | "struct '%s'" |
| 749 | % (discriminator, base)) |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 750 | enum_define = find_enum(discriminator_type) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 751 | allow_metas = ['struct'] |
Wenchao Xia | 5223070 | 2014-03-04 18:44:39 -0800 | [diff] [blame] | 752 | # Do not allow string discriminator |
| 753 | if not enum_define: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 754 | raise QAPISemError(info, |
| 755 | "Discriminator '%s' must be of enumeration " |
| 756 | "type" % discriminator) |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 757 | |
Eric Blake | 02a57ae | 2016-02-17 23:48:16 -0700 | [diff] [blame] | 758 | # Check every branch; don't allow an empty union |
| 759 | if len(members) == 0: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 760 | raise QAPISemError(info, "Union '%s' cannot have empty 'data'" % name) |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 761 | for (key, value) in members.items(): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 762 | check_name(info, "Member of union '%s'" % name, key) |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 763 | |
Eric Blake | 01cfbaa | 2015-12-01 22:20:58 -0700 | [diff] [blame] | 764 | # Each value must name a known type |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 765 | check_type(info, "Member '%s' of union '%s'" % (key, name), |
Markus Armbruster | f9a1427 | 2015-06-10 13:07:43 +0200 | [diff] [blame] | 766 | value, allow_array=not base, allow_metas=allow_metas) |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 767 | |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 768 | # If the discriminator names an enum type, then all members |
Eric Blake | 61a9466 | 2015-11-18 01:52:49 -0700 | [diff] [blame] | 769 | # of 'data' must also be members of the enum type. |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 770 | if enum_define: |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 771 | if key not in enum_define['enum_values']: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 772 | raise QAPISemError(info, |
| 773 | "Discriminator value '%s' is not found in " |
| 774 | "enum '%s'" |
| 775 | % (key, enum_define["enum_name"])) |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 776 | |
Eric Blake | d0b1823 | 2016-07-13 21:50:13 -0600 | [diff] [blame] | 777 | # If discriminator is user-defined, ensure all values are covered |
| 778 | if enum_define: |
| 779 | for value in enum_define['enum_values']: |
| 780 | if value not in members.keys(): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 781 | raise QAPISemError(info, "Union '%s' data missing '%s' branch" |
| 782 | % (name, value)) |
Eric Blake | d0b1823 | 2016-07-13 21:50:13 -0600 | [diff] [blame] | 783 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 784 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 785 | def check_alternate(expr, info): |
Eric Blake | ab916fa | 2015-05-04 09:05:13 -0600 | [diff] [blame] | 786 | name = expr['alternate'] |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 787 | members = expr['data'] |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 788 | types_seen = {} |
Eric Blake | 44bd127 | 2015-05-04 09:05:08 -0600 | [diff] [blame] | 789 | |
Eric Blake | 02a57ae | 2016-02-17 23:48:16 -0700 | [diff] [blame] | 790 | # Check every branch; require at least two branches |
| 791 | if len(members) < 2: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 792 | raise QAPISemError(info, |
| 793 | "Alternate '%s' should have at least two branches " |
| 794 | "in 'data'" % name) |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 795 | for (key, value) in members.items(): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 796 | check_name(info, "Member of alternate '%s'" % name, key) |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 797 | |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 798 | # Ensure alternates have no type conflicts. |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 799 | check_type(info, "Member '%s' of alternate '%s'" % (key, name), |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 800 | value, |
| 801 | allow_metas=['built-in', 'union', 'struct', 'enum']) |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 802 | qtype = find_alternate_member_qtype(value) |
Eric Blake | 4653430 | 2016-02-17 23:48:17 -0700 | [diff] [blame] | 803 | if not qtype: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 804 | raise QAPISemError(info, "Alternate '%s' member '%s' cannot use " |
| 805 | "type '%s'" % (name, key, value)) |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 806 | if qtype in types_seen: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 807 | raise QAPISemError(info, "Alternate '%s' member '%s' can't " |
| 808 | "be distinguished from member '%s'" |
| 809 | % (name, key, types_seen[qtype])) |
Eric Blake | 811d04f | 2015-05-04 09:05:10 -0600 | [diff] [blame] | 810 | types_seen[qtype] = key |
Wenchao Xia | b86b05e | 2014-03-04 18:44:34 -0800 | [diff] [blame] | 811 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 812 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 813 | def check_enum(expr, info): |
Eric Blake | cf39359 | 2015-05-04 09:05:04 -0600 | [diff] [blame] | 814 | name = expr['enum'] |
| 815 | members = expr.get('data') |
Daniel P. Berrange | 351d36e | 2015-08-26 14:21:20 +0100 | [diff] [blame] | 816 | prefix = expr.get('prefix') |
Eric Blake | cf39359 | 2015-05-04 09:05:04 -0600 | [diff] [blame] | 817 | |
| 818 | if not isinstance(members, list): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 819 | raise QAPISemError(info, |
| 820 | "Enum '%s' requires an array for 'data'" % name) |
Daniel P. Berrange | 351d36e | 2015-08-26 14:21:20 +0100 | [diff] [blame] | 821 | if prefix is not None and not isinstance(prefix, str): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 822 | raise QAPISemError(info, |
| 823 | "Enum '%s' requires a string for 'prefix'" % name) |
Eric Blake | cf39359 | 2015-05-04 09:05:04 -0600 | [diff] [blame] | 824 | for member in members: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 825 | check_name(info, "Member of enum '%s'" % name, member, |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 826 | enum_member=True) |
Eric Blake | cf39359 | 2015-05-04 09:05:04 -0600 | [diff] [blame] | 827 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 828 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 829 | def check_struct(expr, info): |
Eric Blake | fd41dd4 | 2015-05-04 09:05:25 -0600 | [diff] [blame] | 830 | name = expr['struct'] |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 831 | members = expr['data'] |
| 832 | |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 833 | check_type(info, "'data' for struct '%s'" % name, members, |
Eric Blake | c9e0a79 | 2015-05-04 09:05:22 -0600 | [diff] [blame] | 834 | allow_dict=True, allow_optional=True) |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 835 | check_type(info, "'base' for struct '%s'" % name, expr.get('base'), |
Eric Blake | dd883c6 | 2015-05-04 09:05:21 -0600 | [diff] [blame] | 836 | allow_metas=['struct']) |
| 837 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 838 | |
Eric Blake | 0545f6b | 2015-05-04 09:05:15 -0600 | [diff] [blame] | 839 | def check_keys(expr_elem, meta, required, optional=[]): |
| 840 | expr = expr_elem['expr'] |
| 841 | info = expr_elem['info'] |
| 842 | name = expr[meta] |
| 843 | if not isinstance(name, str): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 844 | raise QAPISemError(info, "'%s' key must have a string value" % meta) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 845 | required = required + [meta] |
Eric Blake | 0545f6b | 2015-05-04 09:05:15 -0600 | [diff] [blame] | 846 | for (key, value) in expr.items(): |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 847 | if key not in required and key not in optional: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 848 | raise QAPISemError(info, "Unknown key '%s' in %s '%s'" |
| 849 | % (key, meta, name)) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 850 | if (key == 'gen' or key == 'success-response') and value is not False: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 851 | raise QAPISemError(info, |
| 852 | "'%s' of %s '%s' should only use false value" |
| 853 | % (key, meta, name)) |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 854 | if key == 'boxed' and value is not True: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 855 | raise QAPISemError(info, |
| 856 | "'%s' of %s '%s' should only use true value" |
| 857 | % (key, meta, name)) |
Eric Blake | 0545f6b | 2015-05-04 09:05:15 -0600 | [diff] [blame] | 858 | for key in required: |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 859 | if key not in expr: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 860 | raise QAPISemError(info, "Key '%s' is missing from %s '%s'" |
| 861 | % (key, meta, name)) |
Eric Blake | 0545f6b | 2015-05-04 09:05:15 -0600 | [diff] [blame] | 862 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 863 | |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 864 | def check_exprs(exprs): |
| 865 | global all_names |
| 866 | |
| 867 | # Learn the types and check for valid expression keys |
| 868 | for builtin in builtin_types.keys(): |
| 869 | all_names[builtin] = 'built-in' |
| 870 | for expr_elem in exprs: |
| 871 | expr = expr_elem['expr'] |
| 872 | info = expr_elem['info'] |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 873 | |
Markus Armbruster | bc52d03 | 2017-03-15 13:56:51 +0100 | [diff] [blame] | 874 | if 'doc' not in expr_elem and doc_required: |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 875 | raise QAPISemError(info, |
| 876 | "Expression missing documentation comment") |
| 877 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 878 | if 'enum' in expr: |
Daniel P. Berrange | 351d36e | 2015-08-26 14:21:20 +0100 | [diff] [blame] | 879 | check_keys(expr_elem, 'enum', ['data'], ['prefix']) |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 880 | add_enum(expr['enum'], info, expr['data']) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 881 | elif 'union' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 882 | check_keys(expr_elem, 'union', ['data'], |
| 883 | ['base', 'discriminator']) |
| 884 | add_union(expr, info) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 885 | elif 'alternate' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 886 | check_keys(expr_elem, 'alternate', ['data']) |
| 887 | add_name(expr['alternate'], info, 'alternate') |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 888 | elif 'struct' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 889 | check_keys(expr_elem, 'struct', ['data'], ['base']) |
| 890 | add_struct(expr, info) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 891 | elif 'command' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 892 | check_keys(expr_elem, 'command', [], |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 893 | ['data', 'returns', 'gen', 'success-response', 'boxed']) |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 894 | add_name(expr['command'], info, 'command') |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 895 | elif 'event' in expr: |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 896 | check_keys(expr_elem, 'event', [], ['data', 'boxed']) |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 897 | add_name(expr['event'], info, 'event') |
| 898 | else: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 899 | raise QAPISemError(expr_elem['info'], |
| 900 | "Expression is missing metatype") |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 901 | |
| 902 | # Try again for hidden UnionKind enum |
| 903 | for expr_elem in exprs: |
| 904 | expr = expr_elem['expr'] |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 905 | if 'union' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 906 | if not discriminator_find_enum_define(expr): |
| 907 | add_enum('%sKind' % expr['union'], expr_elem['info'], |
| 908 | implicit=True) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 909 | elif 'alternate' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 910 | add_enum('%sKind' % expr['alternate'], expr_elem['info'], |
| 911 | implicit=True) |
| 912 | |
| 913 | # Validate that exprs make sense |
| 914 | for expr_elem in exprs: |
| 915 | expr = expr_elem['expr'] |
| 916 | info = expr_elem['info'] |
| 917 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 918 | if 'enum' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 919 | check_enum(expr, info) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 920 | elif 'union' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 921 | check_union(expr, info) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 922 | elif 'alternate' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 923 | check_alternate(expr, info) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 924 | elif 'struct' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 925 | check_struct(expr, info) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 926 | elif 'command' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 927 | check_command(expr, info) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 928 | elif 'event' in expr: |
Markus Armbruster | 4d076d6 | 2015-06-10 08:55:21 +0200 | [diff] [blame] | 929 | check_event(expr, info) |
| 930 | else: |
| 931 | assert False, 'unexpected meta type' |
| 932 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 933 | return exprs |
Eric Blake | 0545f6b | 2015-05-04 09:05:15 -0600 | [diff] [blame] | 934 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 935 | |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 936 | def check_freeform_doc(doc): |
| 937 | if doc.symbol: |
| 938 | raise QAPISemError(doc.info, |
| 939 | "Documention for '%s' is not followed" |
| 940 | " by the definition" % doc.symbol) |
| 941 | |
| 942 | body = str(doc.body) |
| 943 | if re.search(r'@\S+:', body, re.MULTILINE): |
| 944 | raise QAPISemError(doc.info, |
| 945 | "Free-form documentation block must not contain" |
| 946 | " @NAME: sections") |
| 947 | |
| 948 | |
| 949 | def check_definition_doc(doc, expr, info): |
| 950 | for i in ('enum', 'union', 'alternate', 'struct', 'command', 'event'): |
| 951 | if i in expr: |
| 952 | meta = i |
| 953 | break |
| 954 | |
| 955 | name = expr[meta] |
| 956 | if doc.symbol != name: |
| 957 | raise QAPISemError(info, "Definition of '%s' follows documentation" |
| 958 | " for '%s'" % (name, doc.symbol)) |
| 959 | if doc.has_section('Returns') and 'command' not in expr: |
| 960 | raise QAPISemError(info, "'Returns:' is only valid for commands") |
| 961 | |
| 962 | if meta == 'union': |
| 963 | args = expr.get('base', []) |
| 964 | else: |
| 965 | args = expr.get('data', []) |
| 966 | if isinstance(args, str): |
| 967 | return |
| 968 | if isinstance(args, dict): |
| 969 | args = args.keys() |
| 970 | assert isinstance(args, list) |
| 971 | |
| 972 | if (meta == 'alternate' |
| 973 | or (meta == 'union' and not expr.get('discriminator'))): |
| 974 | args.append('type') |
| 975 | |
| 976 | for arg in args: |
| 977 | if arg[0] == '*': |
| 978 | opt = True |
| 979 | desc = doc.args.get(arg[1:]) |
| 980 | else: |
| 981 | opt = False |
| 982 | desc = doc.args.get(arg) |
| 983 | if not desc: |
| 984 | continue |
| 985 | desc_opt = "#optional" in str(desc) |
| 986 | if desc_opt and not opt: |
| 987 | raise QAPISemError(info, "Description has #optional, " |
| 988 | "but the declaration doesn't") |
| 989 | if not desc_opt and opt: |
| 990 | # silently fix the doc |
| 991 | # TODO either fix the schema and make this an error, |
| 992 | # or drop #optional entirely |
| 993 | desc.append("#optional") |
| 994 | |
| 995 | doc_args = set(doc.args.keys()) |
| 996 | args = set([name.strip('*') for name in args]) |
| 997 | if not doc_args.issubset(args): |
| 998 | raise QAPISemError(info, "The following documented members are not in " |
| 999 | "the declaration: %s" % ", ".join(doc_args - args)) |
| 1000 | |
| 1001 | |
| 1002 | def check_docs(docs): |
| 1003 | for doc in docs: |
| 1004 | for section in doc.args.values() + doc.sections: |
| 1005 | content = str(section) |
| 1006 | if not content or content.isspace(): |
| 1007 | raise QAPISemError(doc.info, |
| 1008 | "Empty doc section '%s'" % section.name) |
| 1009 | |
| 1010 | if not doc.expr: |
| 1011 | check_freeform_doc(doc) |
| 1012 | else: |
| 1013 | check_definition_doc(doc, doc.expr, doc.info) |
| 1014 | |
| 1015 | return docs |
| 1016 | |
| 1017 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1018 | # |
| 1019 | # Schema compiler frontend |
| 1020 | # |
| 1021 | |
| 1022 | class QAPISchemaEntity(object): |
| 1023 | def __init__(self, name, info): |
| 1024 | assert isinstance(name, str) |
| 1025 | self.name = name |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1026 | # For explicitly defined entities, info points to the (explicit) |
| 1027 | # definition. For builtins (and their arrays), info is None. |
| 1028 | # For implicitly defined entities, info points to a place that |
| 1029 | # triggered the implicit definition (there may be more than one |
| 1030 | # such place). |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1031 | self.info = info |
| 1032 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1033 | def c_name(self): |
| 1034 | return c_name(self.name) |
| 1035 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1036 | def check(self, schema): |
| 1037 | pass |
| 1038 | |
Eric Blake | 49823c4 | 2015-10-12 22:22:27 -0600 | [diff] [blame] | 1039 | def is_implicit(self): |
| 1040 | return not self.info |
| 1041 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1042 | def visit(self, visitor): |
| 1043 | pass |
| 1044 | |
| 1045 | |
| 1046 | class QAPISchemaVisitor(object): |
| 1047 | def visit_begin(self, schema): |
| 1048 | pass |
| 1049 | |
| 1050 | def visit_end(self): |
| 1051 | pass |
| 1052 | |
Eric Blake | 25a0d9c | 2015-10-12 22:22:21 -0600 | [diff] [blame] | 1053 | def visit_needed(self, entity): |
| 1054 | # Default to visiting everything |
| 1055 | return True |
| 1056 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1057 | def visit_builtin_type(self, name, info, json_type): |
| 1058 | pass |
| 1059 | |
| 1060 | def visit_enum_type(self, name, info, values, prefix): |
| 1061 | pass |
| 1062 | |
| 1063 | def visit_array_type(self, name, info, element_type): |
| 1064 | pass |
| 1065 | |
| 1066 | def visit_object_type(self, name, info, base, members, variants): |
| 1067 | pass |
| 1068 | |
Markus Armbruster | 39a1815 | 2015-09-16 13:06:28 +0200 | [diff] [blame] | 1069 | def visit_object_type_flat(self, name, info, members, variants): |
| 1070 | pass |
| 1071 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1072 | def visit_alternate_type(self, name, info, variants): |
| 1073 | pass |
| 1074 | |
| 1075 | def visit_command(self, name, info, arg_type, ret_type, |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1076 | gen, success_response, boxed): |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1077 | pass |
| 1078 | |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1079 | def visit_event(self, name, info, arg_type, boxed): |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1080 | pass |
| 1081 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1082 | |
| 1083 | class QAPISchemaType(QAPISchemaEntity): |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1084 | # Return the C type for common use. |
| 1085 | # For the types we commonly box, this is a pointer type. |
| 1086 | def c_type(self): |
| 1087 | pass |
| 1088 | |
| 1089 | # Return the C type to be used in a parameter list. |
| 1090 | def c_param_type(self): |
| 1091 | return self.c_type() |
| 1092 | |
| 1093 | # Return the C type to be used where we suppress boxing. |
| 1094 | def c_unboxed_type(self): |
| 1095 | return self.c_type() |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1096 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1097 | def json_type(self): |
| 1098 | pass |
| 1099 | |
| 1100 | def alternate_qtype(self): |
| 1101 | json2qtype = { |
| 1102 | 'string': 'QTYPE_QSTRING', |
| 1103 | 'number': 'QTYPE_QFLOAT', |
| 1104 | 'int': 'QTYPE_QINT', |
| 1105 | 'boolean': 'QTYPE_QBOOL', |
| 1106 | 'object': 'QTYPE_QDICT' |
| 1107 | } |
| 1108 | return json2qtype.get(self.json_type()) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1109 | |
| 1110 | |
| 1111 | class QAPISchemaBuiltinType(QAPISchemaType): |
Eric Blake | 861877a | 2016-03-17 16:48:36 -0600 | [diff] [blame] | 1112 | def __init__(self, name, json_type, c_type): |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1113 | QAPISchemaType.__init__(self, name, None) |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1114 | assert not c_type or isinstance(c_type, str) |
| 1115 | assert json_type in ('string', 'number', 'int', 'boolean', 'null', |
| 1116 | 'value') |
| 1117 | self._json_type_name = json_type |
| 1118 | self._c_type_name = c_type |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1119 | |
| 1120 | def c_name(self): |
| 1121 | return self.name |
| 1122 | |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1123 | def c_type(self): |
| 1124 | return self._c_type_name |
| 1125 | |
| 1126 | def c_param_type(self): |
| 1127 | if self.name == 'str': |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1128 | return 'const ' + self._c_type_name |
| 1129 | return self._c_type_name |
| 1130 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1131 | def json_type(self): |
| 1132 | return self._json_type_name |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1133 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1134 | def visit(self, visitor): |
| 1135 | visitor.visit_builtin_type(self.name, self.info, self.json_type()) |
| 1136 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1137 | |
| 1138 | class QAPISchemaEnumType(QAPISchemaType): |
| 1139 | def __init__(self, name, info, values, prefix): |
| 1140 | QAPISchemaType.__init__(self, name, info) |
| 1141 | for v in values: |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1142 | assert isinstance(v, QAPISchemaMember) |
| 1143 | v.set_owner(name) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1144 | assert prefix is None or isinstance(prefix, str) |
| 1145 | self.values = values |
| 1146 | self.prefix = prefix |
| 1147 | |
| 1148 | def check(self, schema): |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1149 | seen = {} |
| 1150 | for v in self.values: |
| 1151 | v.check_clash(self.info, seen) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1152 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1153 | def is_implicit(self): |
| 1154 | # See QAPISchema._make_implicit_enum_type() |
Eric Blake | 8712fa5 | 2015-10-26 16:34:41 -0600 | [diff] [blame] | 1155 | return self.name.endswith('Kind') |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1156 | |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1157 | def c_type(self): |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1158 | return c_name(self.name) |
| 1159 | |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1160 | def member_names(self): |
| 1161 | return [v.name for v in self.values] |
| 1162 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1163 | def json_type(self): |
| 1164 | return 'string' |
| 1165 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1166 | def visit(self, visitor): |
| 1167 | visitor.visit_enum_type(self.name, self.info, |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1168 | self.member_names(), self.prefix) |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1169 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1170 | |
| 1171 | class QAPISchemaArrayType(QAPISchemaType): |
| 1172 | def __init__(self, name, info, element_type): |
| 1173 | QAPISchemaType.__init__(self, name, info) |
| 1174 | assert isinstance(element_type, str) |
| 1175 | self._element_type_name = element_type |
| 1176 | self.element_type = None |
| 1177 | |
| 1178 | def check(self, schema): |
| 1179 | self.element_type = schema.lookup_type(self._element_type_name) |
| 1180 | assert self.element_type |
| 1181 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1182 | def is_implicit(self): |
| 1183 | return True |
| 1184 | |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1185 | def c_type(self): |
| 1186 | return c_name(self.name) + pointer_suffix |
| 1187 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1188 | def json_type(self): |
| 1189 | return 'array' |
| 1190 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1191 | def visit(self, visitor): |
| 1192 | visitor.visit_array_type(self.name, self.info, self.element_type) |
| 1193 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1194 | |
| 1195 | class QAPISchemaObjectType(QAPISchemaType): |
| 1196 | def __init__(self, name, info, base, local_members, variants): |
Eric Blake | da34a9b | 2015-11-18 01:52:36 -0700 | [diff] [blame] | 1197 | # struct has local_members, optional base, and no variants |
| 1198 | # flat union has base, variants, and no local_members |
| 1199 | # simple union has local_members, variants, and no base |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1200 | QAPISchemaType.__init__(self, name, info) |
| 1201 | assert base is None or isinstance(base, str) |
| 1202 | for m in local_members: |
| 1203 | assert isinstance(m, QAPISchemaObjectTypeMember) |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1204 | m.set_owner(name) |
| 1205 | if variants is not None: |
| 1206 | assert isinstance(variants, QAPISchemaObjectTypeVariants) |
| 1207 | variants.set_owner(name) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1208 | self._base_name = base |
| 1209 | self.base = None |
| 1210 | self.local_members = local_members |
| 1211 | self.variants = variants |
| 1212 | self.members = None |
| 1213 | |
| 1214 | def check(self, schema): |
Eric Blake | bac5429 | 2015-12-01 22:20:59 -0700 | [diff] [blame] | 1215 | if self.members is False: # check for cycles |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1216 | raise QAPISemError(self.info, |
| 1217 | "Object %s contains itself" % self.name) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1218 | if self.members: |
| 1219 | return |
| 1220 | self.members = False # mark as being checked |
Markus Armbruster | 23a4b2c | 2015-11-18 01:52:43 -0700 | [diff] [blame] | 1221 | seen = OrderedDict() |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1222 | if self._base_name: |
| 1223 | self.base = schema.lookup_type(self._base_name) |
| 1224 | assert isinstance(self.base, QAPISchemaObjectType) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1225 | self.base.check(schema) |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1226 | self.base.check_clash(schema, self.info, seen) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1227 | for m in self.local_members: |
Markus Armbruster | e564e2d | 2015-11-18 01:52:40 -0700 | [diff] [blame] | 1228 | m.check(schema) |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1229 | m.check_clash(self.info, seen) |
Markus Armbruster | 14ff846 | 2015-11-18 01:52:45 -0700 | [diff] [blame] | 1230 | self.members = seen.values() |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1231 | if self.variants: |
Markus Armbruster | cdc5fa3 | 2015-11-18 01:52:41 -0700 | [diff] [blame] | 1232 | self.variants.check(schema, seen) |
Markus Armbruster | 14ff846 | 2015-11-18 01:52:45 -0700 | [diff] [blame] | 1233 | assert self.variants.tag_member in self.members |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1234 | self.variants.check_clash(schema, self.info, seen) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1235 | |
Eric Blake | 14f00c6 | 2016-03-03 09:16:43 -0700 | [diff] [blame] | 1236 | # Check that the members of this type do not cause duplicate JSON members, |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1237 | # and update seen to track the members seen so far. Report any errors |
| 1238 | # on behalf of info, which is not necessarily self.info |
| 1239 | def check_clash(self, schema, info, seen): |
Eric Blake | c2183d2 | 2015-11-18 01:52:47 -0700 | [diff] [blame] | 1240 | assert not self.variants # not implemented |
| 1241 | for m in self.members: |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1242 | m.check_clash(info, seen) |
Eric Blake | c2183d2 | 2015-11-18 01:52:47 -0700 | [diff] [blame] | 1243 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1244 | def is_implicit(self): |
Eric Blake | 7599697 | 2016-03-17 16:48:29 -0600 | [diff] [blame] | 1245 | # See QAPISchema._make_implicit_object_type(), as well as |
| 1246 | # _def_predefineds() |
| 1247 | return self.name.startswith('q_') |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1248 | |
Eric Blake | b616770 | 2016-07-13 21:50:16 -0600 | [diff] [blame] | 1249 | def is_empty(self): |
| 1250 | assert self.members is not None |
| 1251 | return not self.members and not self.variants |
| 1252 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1253 | def c_name(self): |
Eric Blake | cd50a25 | 2016-07-13 21:50:14 -0600 | [diff] [blame] | 1254 | assert self.name != 'q_empty' |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1255 | return QAPISchemaType.c_name(self) |
| 1256 | |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1257 | def c_type(self): |
Eric Blake | 49823c4 | 2015-10-12 22:22:27 -0600 | [diff] [blame] | 1258 | assert not self.is_implicit() |
Eric Blake | becceed | 2016-02-17 23:48:26 -0700 | [diff] [blame] | 1259 | return c_name(self.name) + pointer_suffix |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1260 | |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1261 | def c_unboxed_type(self): |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1262 | return c_name(self.name) |
| 1263 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1264 | def json_type(self): |
| 1265 | return 'object' |
| 1266 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1267 | def visit(self, visitor): |
| 1268 | visitor.visit_object_type(self.name, self.info, |
| 1269 | self.base, self.local_members, self.variants) |
Markus Armbruster | 39a1815 | 2015-09-16 13:06:28 +0200 | [diff] [blame] | 1270 | visitor.visit_object_type_flat(self.name, self.info, |
| 1271 | self.members, self.variants) |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1272 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1273 | |
Eric Blake | d44f9ac | 2015-12-01 22:20:54 -0700 | [diff] [blame] | 1274 | class QAPISchemaMember(object): |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1275 | role = 'member' |
| 1276 | |
Eric Blake | d44f9ac | 2015-12-01 22:20:54 -0700 | [diff] [blame] | 1277 | def __init__(self, name): |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1278 | assert isinstance(name, str) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1279 | self.name = name |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1280 | self.owner = None |
| 1281 | |
| 1282 | def set_owner(self, name): |
| 1283 | assert not self.owner |
| 1284 | self.owner = name |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1285 | |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1286 | def check_clash(self, info, seen): |
| 1287 | cname = c_name(self.name) |
Markus Armbruster | 2cfbae3 | 2017-03-15 13:56:55 +0100 | [diff] [blame^] | 1288 | if cname.lower() != cname and self.owner not in name_case_whitelist: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1289 | raise QAPISemError(info, |
| 1290 | "%s should not use uppercase" % self.describe()) |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1291 | if cname in seen: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1292 | raise QAPISemError(info, "%s collides with %s" % |
| 1293 | (self.describe(), seen[cname].describe())) |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1294 | seen[cname] = self |
Markus Armbruster | 577de12 | 2015-11-18 01:52:44 -0700 | [diff] [blame] | 1295 | |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1296 | def _pretty_owner(self): |
| 1297 | owner = self.owner |
Eric Blake | 7599697 | 2016-03-17 16:48:29 -0600 | [diff] [blame] | 1298 | if owner.startswith('q_obj_'): |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1299 | # See QAPISchema._make_implicit_object_type() - reverse the |
| 1300 | # mapping there to create a nice human-readable description |
Eric Blake | 7599697 | 2016-03-17 16:48:29 -0600 | [diff] [blame] | 1301 | owner = owner[6:] |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1302 | if owner.endswith('-arg'): |
| 1303 | return '(parameter of %s)' % owner[:-4] |
Eric Blake | ac4338f | 2016-03-17 16:48:39 -0600 | [diff] [blame] | 1304 | elif owner.endswith('-base'): |
| 1305 | return '(base of %s)' % owner[:-5] |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1306 | else: |
| 1307 | assert owner.endswith('-wrapper') |
| 1308 | # Unreachable and not implemented |
| 1309 | assert False |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1310 | if owner.endswith('Kind'): |
| 1311 | # See QAPISchema._make_implicit_enum_type() |
| 1312 | return '(branch of %s)' % owner[:-4] |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1313 | return '(%s of %s)' % (self.role, owner) |
| 1314 | |
| 1315 | def describe(self): |
| 1316 | return "'%s' %s" % (self.name, self._pretty_owner()) |
| 1317 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1318 | |
Eric Blake | d44f9ac | 2015-12-01 22:20:54 -0700 | [diff] [blame] | 1319 | class QAPISchemaObjectTypeMember(QAPISchemaMember): |
| 1320 | def __init__(self, name, typ, optional): |
| 1321 | QAPISchemaMember.__init__(self, name) |
| 1322 | assert isinstance(typ, str) |
| 1323 | assert isinstance(optional, bool) |
| 1324 | self._type_name = typ |
| 1325 | self.type = None |
| 1326 | self.optional = optional |
| 1327 | |
| 1328 | def check(self, schema): |
| 1329 | assert self.owner |
| 1330 | self.type = schema.lookup_type(self._type_name) |
| 1331 | assert self.type |
| 1332 | |
| 1333 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1334 | class QAPISchemaObjectTypeVariants(object): |
Eric Blake | 46292ba | 2015-10-12 22:22:29 -0600 | [diff] [blame] | 1335 | def __init__(self, tag_name, tag_member, variants): |
| 1336 | # Flat unions pass tag_name but not tag_member. |
| 1337 | # Simple unions and alternates pass tag_member but not tag_name. |
| 1338 | # After check(), tag_member is always set, and tag_name remains |
| 1339 | # a reliable witness of being used by a flat union. |
| 1340 | assert bool(tag_member) != bool(tag_name) |
| 1341 | assert (isinstance(tag_name, str) or |
| 1342 | isinstance(tag_member, QAPISchemaObjectTypeMember)) |
Eric Blake | 02a57ae | 2016-02-17 23:48:16 -0700 | [diff] [blame] | 1343 | assert len(variants) > 0 |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1344 | for v in variants: |
| 1345 | assert isinstance(v, QAPISchemaObjectTypeVariant) |
Eric Blake | da9cb19 | 2016-07-13 21:50:15 -0600 | [diff] [blame] | 1346 | self._tag_name = tag_name |
Eric Blake | 46292ba | 2015-10-12 22:22:29 -0600 | [diff] [blame] | 1347 | self.tag_member = tag_member |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1348 | self.variants = variants |
| 1349 | |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1350 | def set_owner(self, name): |
| 1351 | for v in self.variants: |
| 1352 | v.set_owner(name) |
| 1353 | |
Markus Armbruster | cdc5fa3 | 2015-11-18 01:52:41 -0700 | [diff] [blame] | 1354 | def check(self, schema, seen): |
Markus Armbruster | 14ff846 | 2015-11-18 01:52:45 -0700 | [diff] [blame] | 1355 | if not self.tag_member: # flat union |
Eric Blake | da9cb19 | 2016-07-13 21:50:15 -0600 | [diff] [blame] | 1356 | self.tag_member = seen[c_name(self._tag_name)] |
| 1357 | assert self._tag_name == self.tag_member.name |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1358 | assert isinstance(self.tag_member.type, QAPISchemaEnumType) |
| 1359 | for v in self.variants: |
Eric Blake | 10565ca | 2015-11-18 01:52:48 -0700 | [diff] [blame] | 1360 | v.check(schema) |
Eric Blake | 0426d53 | 2015-12-01 22:20:48 -0700 | [diff] [blame] | 1361 | # Union names must match enum values; alternate names are |
| 1362 | # checked separately. Use 'seen' to tell the two apart. |
| 1363 | if seen: |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1364 | assert v.name in self.tag_member.type.member_names() |
Eric Blake | 0426d53 | 2015-12-01 22:20:48 -0700 | [diff] [blame] | 1365 | assert isinstance(v.type, QAPISchemaObjectType) |
Eric Blake | b807a1e | 2015-11-18 01:52:46 -0700 | [diff] [blame] | 1366 | v.type.check(schema) |
| 1367 | |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1368 | def check_clash(self, schema, info, seen): |
Eric Blake | b807a1e | 2015-11-18 01:52:46 -0700 | [diff] [blame] | 1369 | for v in self.variants: |
| 1370 | # Reset seen map for each variant, since qapi names from one |
| 1371 | # branch do not affect another branch |
Eric Blake | b807a1e | 2015-11-18 01:52:46 -0700 | [diff] [blame] | 1372 | assert isinstance(v.type, QAPISchemaObjectType) |
Eric Blake | 27b60ab | 2015-11-18 01:52:51 -0700 | [diff] [blame] | 1373 | v.type.check_clash(schema, info, dict(seen)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1374 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1375 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1376 | class QAPISchemaObjectTypeVariant(QAPISchemaObjectTypeMember): |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1377 | role = 'branch' |
| 1378 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1379 | def __init__(self, name, typ): |
| 1380 | QAPISchemaObjectTypeMember.__init__(self, name, typ, False) |
| 1381 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1382 | |
| 1383 | class QAPISchemaAlternateType(QAPISchemaType): |
| 1384 | def __init__(self, name, info, variants): |
| 1385 | QAPISchemaType.__init__(self, name, info) |
| 1386 | assert isinstance(variants, QAPISchemaObjectTypeVariants) |
Eric Blake | da9cb19 | 2016-07-13 21:50:15 -0600 | [diff] [blame] | 1387 | assert variants.tag_member |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1388 | variants.set_owner(name) |
| 1389 | variants.tag_member.set_owner(self.name) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1390 | self.variants = variants |
| 1391 | |
| 1392 | def check(self, schema): |
Markus Armbruster | e564e2d | 2015-11-18 01:52:40 -0700 | [diff] [blame] | 1393 | self.variants.tag_member.check(schema) |
Eric Blake | b807a1e | 2015-11-18 01:52:46 -0700 | [diff] [blame] | 1394 | # Not calling self.variants.check_clash(), because there's nothing |
| 1395 | # to clash with |
Markus Armbruster | cdc5fa3 | 2015-11-18 01:52:41 -0700 | [diff] [blame] | 1396 | self.variants.check(schema, {}) |
Eric Blake | 0426d53 | 2015-12-01 22:20:48 -0700 | [diff] [blame] | 1397 | # Alternate branch names have no relation to the tag enum values; |
| 1398 | # so we have to check for potential name collisions ourselves. |
| 1399 | seen = {} |
| 1400 | for v in self.variants.variants: |
| 1401 | v.check_clash(self.info, seen) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1402 | |
Eric Blake | 4040d99 | 2016-03-17 16:48:28 -0600 | [diff] [blame] | 1403 | def c_type(self): |
| 1404 | return c_name(self.name) + pointer_suffix |
| 1405 | |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1406 | def json_type(self): |
| 1407 | return 'value' |
| 1408 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1409 | def visit(self, visitor): |
| 1410 | visitor.visit_alternate_type(self.name, self.info, self.variants) |
| 1411 | |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 1412 | def is_empty(self): |
| 1413 | return False |
| 1414 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1415 | |
| 1416 | class QAPISchemaCommand(QAPISchemaEntity): |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1417 | def __init__(self, name, info, arg_type, ret_type, gen, success_response, |
| 1418 | boxed): |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1419 | QAPISchemaEntity.__init__(self, name, info) |
| 1420 | assert not arg_type or isinstance(arg_type, str) |
| 1421 | assert not ret_type or isinstance(ret_type, str) |
| 1422 | self._arg_type_name = arg_type |
| 1423 | self.arg_type = None |
| 1424 | self._ret_type_name = ret_type |
| 1425 | self.ret_type = None |
| 1426 | self.gen = gen |
| 1427 | self.success_response = success_response |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1428 | self.boxed = boxed |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1429 | |
| 1430 | def check(self, schema): |
| 1431 | if self._arg_type_name: |
| 1432 | self.arg_type = schema.lookup_type(self._arg_type_name) |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 1433 | assert (isinstance(self.arg_type, QAPISchemaObjectType) or |
| 1434 | isinstance(self.arg_type, QAPISchemaAlternateType)) |
| 1435 | self.arg_type.check(schema) |
| 1436 | if self.boxed: |
| 1437 | if self.arg_type.is_empty(): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1438 | raise QAPISemError(self.info, |
| 1439 | "Cannot use 'boxed' with empty type") |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 1440 | else: |
| 1441 | assert not isinstance(self.arg_type, QAPISchemaAlternateType) |
| 1442 | assert not self.arg_type.variants |
| 1443 | elif self.boxed: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1444 | raise QAPISemError(self.info, "Use of 'boxed' requires 'data'") |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1445 | if self._ret_type_name: |
| 1446 | self.ret_type = schema.lookup_type(self._ret_type_name) |
| 1447 | assert isinstance(self.ret_type, QAPISchemaType) |
| 1448 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1449 | def visit(self, visitor): |
| 1450 | visitor.visit_command(self.name, self.info, |
| 1451 | self.arg_type, self.ret_type, |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1452 | self.gen, self.success_response, self.boxed) |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1453 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1454 | |
| 1455 | class QAPISchemaEvent(QAPISchemaEntity): |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1456 | def __init__(self, name, info, arg_type, boxed): |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1457 | QAPISchemaEntity.__init__(self, name, info) |
| 1458 | assert not arg_type or isinstance(arg_type, str) |
| 1459 | self._arg_type_name = arg_type |
| 1460 | self.arg_type = None |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1461 | self.boxed = boxed |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1462 | |
| 1463 | def check(self, schema): |
| 1464 | if self._arg_type_name: |
| 1465 | self.arg_type = schema.lookup_type(self._arg_type_name) |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 1466 | assert (isinstance(self.arg_type, QAPISchemaObjectType) or |
| 1467 | isinstance(self.arg_type, QAPISchemaAlternateType)) |
| 1468 | self.arg_type.check(schema) |
| 1469 | if self.boxed: |
| 1470 | if self.arg_type.is_empty(): |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1471 | raise QAPISemError(self.info, |
| 1472 | "Cannot use 'boxed' with empty type") |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 1473 | else: |
| 1474 | assert not isinstance(self.arg_type, QAPISchemaAlternateType) |
| 1475 | assert not self.arg_type.variants |
| 1476 | elif self.boxed: |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1477 | raise QAPISemError(self.info, "Use of 'boxed' requires 'data'") |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1478 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1479 | def visit(self, visitor): |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1480 | visitor.visit_event(self.name, self.info, self.arg_type, self.boxed) |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1481 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1482 | |
| 1483 | class QAPISchema(object): |
| 1484 | def __init__(self, fname): |
| 1485 | try: |
Marc-André Lureau | 3313b61 | 2017-01-13 15:41:29 +0100 | [diff] [blame] | 1486 | parser = QAPISchemaParser(open(fname, "r")) |
| 1487 | self.exprs = check_exprs(parser.exprs) |
| 1488 | self.docs = check_docs(parser.docs) |
Eric Blake | 7618b91 | 2015-10-12 22:22:22 -0600 | [diff] [blame] | 1489 | self._entity_dict = {} |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1490 | self._predefining = True |
Eric Blake | 7618b91 | 2015-10-12 22:22:22 -0600 | [diff] [blame] | 1491 | self._def_predefineds() |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1492 | self._predefining = False |
Eric Blake | 7618b91 | 2015-10-12 22:22:22 -0600 | [diff] [blame] | 1493 | self._def_exprs() |
| 1494 | self.check() |
Marc-André Lureau | 4148c29 | 2017-01-13 15:41:25 +0100 | [diff] [blame] | 1495 | except QAPIError as err: |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1496 | print >>sys.stderr, err |
| 1497 | exit(1) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1498 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1499 | def _def_entity(self, ent): |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1500 | # Only the predefined types are allowed to not have info |
| 1501 | assert ent.info or self._predefining |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1502 | assert ent.name not in self._entity_dict |
| 1503 | self._entity_dict[ent.name] = ent |
| 1504 | |
| 1505 | def lookup_entity(self, name, typ=None): |
| 1506 | ent = self._entity_dict.get(name) |
| 1507 | if typ and not isinstance(ent, typ): |
| 1508 | return None |
| 1509 | return ent |
| 1510 | |
| 1511 | def lookup_type(self, name): |
| 1512 | return self.lookup_entity(name, QAPISchemaType) |
| 1513 | |
Eric Blake | 861877a | 2016-03-17 16:48:36 -0600 | [diff] [blame] | 1514 | def _def_builtin_type(self, name, json_type, c_type): |
| 1515 | self._def_entity(QAPISchemaBuiltinType(name, json_type, c_type)) |
Eric Blake | 9f08c8e | 2015-10-12 22:22:28 -0600 | [diff] [blame] | 1516 | # TODO As long as we have QAPI_TYPES_BUILTIN to share multiple |
| 1517 | # qapi-types.h from a single .c, all arrays of builtins must be |
| 1518 | # declared in the first file whether or not they are used. Nicer |
| 1519 | # would be to use lazy instantiation, while figuring out how to |
| 1520 | # avoid compilation issues with multiple qapi-types.h. |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1521 | self._make_array_type(name, None) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1522 | |
| 1523 | def _def_predefineds(self): |
Eric Blake | 861877a | 2016-03-17 16:48:36 -0600 | [diff] [blame] | 1524 | for t in [('str', 'string', 'char' + pointer_suffix), |
| 1525 | ('number', 'number', 'double'), |
| 1526 | ('int', 'int', 'int64_t'), |
| 1527 | ('int8', 'int', 'int8_t'), |
| 1528 | ('int16', 'int', 'int16_t'), |
| 1529 | ('int32', 'int', 'int32_t'), |
| 1530 | ('int64', 'int', 'int64_t'), |
| 1531 | ('uint8', 'int', 'uint8_t'), |
| 1532 | ('uint16', 'int', 'uint16_t'), |
| 1533 | ('uint32', 'int', 'uint32_t'), |
| 1534 | ('uint64', 'int', 'uint64_t'), |
| 1535 | ('size', 'int', 'uint64_t'), |
| 1536 | ('bool', 'boolean', 'bool'), |
| 1537 | ('any', 'value', 'QObject' + pointer_suffix)]: |
Markus Armbruster | f51d8c3 | 2015-09-16 13:06:06 +0200 | [diff] [blame] | 1538 | self._def_builtin_type(*t) |
Eric Blake | 7599697 | 2016-03-17 16:48:29 -0600 | [diff] [blame] | 1539 | self.the_empty_object_type = QAPISchemaObjectType('q_empty', None, |
| 1540 | None, [], None) |
Markus Armbruster | 39a1815 | 2015-09-16 13:06:28 +0200 | [diff] [blame] | 1541 | self._def_entity(self.the_empty_object_type) |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1542 | qtype_values = self._make_enum_members(['none', 'qnull', 'qint', |
| 1543 | 'qstring', 'qdict', 'qlist', |
| 1544 | 'qfloat', 'qbool']) |
| 1545 | self._def_entity(QAPISchemaEnumType('QType', None, qtype_values, |
Eric Blake | 7264f5c | 2015-12-01 22:20:47 -0700 | [diff] [blame] | 1546 | 'QTYPE')) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1547 | |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1548 | def _make_enum_members(self, values): |
| 1549 | return [QAPISchemaMember(v) for v in values] |
| 1550 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1551 | def _make_implicit_enum_type(self, name, info, values): |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1552 | # See also QAPISchemaObjectTypeMember._pretty_owner() |
Eric Blake | 49823c4 | 2015-10-12 22:22:27 -0600 | [diff] [blame] | 1553 | name = name + 'Kind' # Use namespace reserved by add_name() |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1554 | self._def_entity(QAPISchemaEnumType( |
| 1555 | name, info, self._make_enum_members(values), None)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1556 | return name |
| 1557 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1558 | def _make_array_type(self, element_type, info): |
Eric Blake | 255960d | 2015-10-26 16:34:43 -0600 | [diff] [blame] | 1559 | name = element_type + 'List' # Use namespace reserved by add_name() |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1560 | if not self.lookup_type(name): |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1561 | self._def_entity(QAPISchemaArrayType(name, info, element_type)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1562 | return name |
| 1563 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1564 | def _make_implicit_object_type(self, name, info, role, members): |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1565 | if not members: |
| 1566 | return None |
Eric Blake | 88d4ef8 | 2015-11-18 01:52:50 -0700 | [diff] [blame] | 1567 | # See also QAPISchemaObjectTypeMember._pretty_owner() |
Eric Blake | 7599697 | 2016-03-17 16:48:29 -0600 | [diff] [blame] | 1568 | name = 'q_obj_%s-%s' % (name, role) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1569 | if not self.lookup_entity(name, QAPISchemaObjectType): |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1570 | self._def_entity(QAPISchemaObjectType(name, info, None, |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1571 | members, None)) |
| 1572 | return name |
| 1573 | |
| 1574 | def _def_enum_type(self, expr, info): |
| 1575 | name = expr['enum'] |
| 1576 | data = expr['data'] |
| 1577 | prefix = expr.get('prefix') |
Eric Blake | 93bda4d | 2015-12-01 22:20:55 -0700 | [diff] [blame] | 1578 | self._def_entity(QAPISchemaEnumType( |
| 1579 | name, info, self._make_enum_members(data), prefix)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1580 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1581 | def _make_member(self, name, typ, info): |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1582 | optional = False |
| 1583 | if name.startswith('*'): |
| 1584 | name = name[1:] |
| 1585 | optional = True |
| 1586 | if isinstance(typ, list): |
| 1587 | assert len(typ) == 1 |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1588 | typ = self._make_array_type(typ[0], info) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1589 | return QAPISchemaObjectTypeMember(name, typ, optional) |
| 1590 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1591 | def _make_members(self, data, info): |
| 1592 | return [self._make_member(key, value, info) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1593 | for (key, value) in data.iteritems()] |
| 1594 | |
| 1595 | def _def_struct_type(self, expr, info): |
| 1596 | name = expr['struct'] |
| 1597 | base = expr.get('base') |
| 1598 | data = expr['data'] |
| 1599 | self._def_entity(QAPISchemaObjectType(name, info, base, |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1600 | self._make_members(data, info), |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1601 | None)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1602 | |
| 1603 | def _make_variant(self, case, typ): |
| 1604 | return QAPISchemaObjectTypeVariant(case, typ) |
| 1605 | |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1606 | def _make_simple_variant(self, case, typ, info): |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1607 | if isinstance(typ, list): |
| 1608 | assert len(typ) == 1 |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1609 | typ = self._make_array_type(typ[0], info) |
| 1610 | typ = self._make_implicit_object_type( |
| 1611 | typ, info, 'wrapper', [self._make_member('data', typ, info)]) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1612 | return QAPISchemaObjectTypeVariant(case, typ) |
| 1613 | |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1614 | def _def_union_type(self, expr, info): |
| 1615 | name = expr['union'] |
| 1616 | data = expr['data'] |
| 1617 | base = expr.get('base') |
| 1618 | tag_name = expr.get('discriminator') |
Eric Blake | 46292ba | 2015-10-12 22:22:29 -0600 | [diff] [blame] | 1619 | tag_member = None |
Eric Blake | ac4338f | 2016-03-17 16:48:39 -0600 | [diff] [blame] | 1620 | if isinstance(base, dict): |
| 1621 | base = (self._make_implicit_object_type( |
| 1622 | name, info, 'base', self._make_members(base, info))) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1623 | if tag_name: |
| 1624 | variants = [self._make_variant(key, value) |
| 1625 | for (key, value) in data.iteritems()] |
Eric Blake | da34a9b | 2015-11-18 01:52:36 -0700 | [diff] [blame] | 1626 | members = [] |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1627 | else: |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1628 | variants = [self._make_simple_variant(key, value, info) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1629 | for (key, value) in data.iteritems()] |
Eric Blake | 9d3f349 | 2015-12-01 22:20:50 -0700 | [diff] [blame] | 1630 | typ = self._make_implicit_enum_type(name, info, |
| 1631 | [v.name for v in variants]) |
| 1632 | tag_member = QAPISchemaObjectTypeMember('type', typ, False) |
Eric Blake | da34a9b | 2015-11-18 01:52:36 -0700 | [diff] [blame] | 1633 | members = [tag_member] |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1634 | self._def_entity( |
Eric Blake | da34a9b | 2015-11-18 01:52:36 -0700 | [diff] [blame] | 1635 | QAPISchemaObjectType(name, info, base, members, |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1636 | QAPISchemaObjectTypeVariants(tag_name, |
Eric Blake | 46292ba | 2015-10-12 22:22:29 -0600 | [diff] [blame] | 1637 | tag_member, |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1638 | variants))) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1639 | |
| 1640 | def _def_alternate_type(self, expr, info): |
| 1641 | name = expr['alternate'] |
| 1642 | data = expr['data'] |
| 1643 | variants = [self._make_variant(key, value) |
| 1644 | for (key, value) in data.iteritems()] |
Eric Blake | 0426d53 | 2015-12-01 22:20:48 -0700 | [diff] [blame] | 1645 | tag_member = QAPISchemaObjectTypeMember('type', 'QType', False) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1646 | self._def_entity( |
| 1647 | QAPISchemaAlternateType(name, info, |
| 1648 | QAPISchemaObjectTypeVariants(None, |
Eric Blake | 46292ba | 2015-10-12 22:22:29 -0600 | [diff] [blame] | 1649 | tag_member, |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1650 | variants))) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1651 | |
| 1652 | def _def_command(self, expr, info): |
| 1653 | name = expr['command'] |
| 1654 | data = expr.get('data') |
| 1655 | rets = expr.get('returns') |
| 1656 | gen = expr.get('gen', True) |
| 1657 | success_response = expr.get('success-response', True) |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1658 | boxed = expr.get('boxed', False) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1659 | if isinstance(data, OrderedDict): |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1660 | data = self._make_implicit_object_type( |
| 1661 | name, info, 'arg', self._make_members(data, info)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1662 | if isinstance(rets, list): |
| 1663 | assert len(rets) == 1 |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1664 | rets = self._make_array_type(rets[0], info) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1665 | self._def_entity(QAPISchemaCommand(name, info, data, rets, gen, |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1666 | success_response, boxed)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1667 | |
| 1668 | def _def_event(self, expr, info): |
| 1669 | name = expr['event'] |
| 1670 | data = expr.get('data') |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1671 | boxed = expr.get('boxed', False) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1672 | if isinstance(data, OrderedDict): |
Eric Blake | 99df528 | 2015-10-12 22:22:32 -0600 | [diff] [blame] | 1673 | data = self._make_implicit_object_type( |
| 1674 | name, info, 'arg', self._make_members(data, info)) |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1675 | self._def_entity(QAPISchemaEvent(name, info, data, boxed)) |
Markus Armbruster | ac88219 | 2015-09-16 13:06:05 +0200 | [diff] [blame] | 1676 | |
| 1677 | def _def_exprs(self): |
| 1678 | for expr_elem in self.exprs: |
| 1679 | expr = expr_elem['expr'] |
| 1680 | info = expr_elem['info'] |
| 1681 | if 'enum' in expr: |
| 1682 | self._def_enum_type(expr, info) |
| 1683 | elif 'struct' in expr: |
| 1684 | self._def_struct_type(expr, info) |
| 1685 | elif 'union' in expr: |
| 1686 | self._def_union_type(expr, info) |
| 1687 | elif 'alternate' in expr: |
| 1688 | self._def_alternate_type(expr, info) |
| 1689 | elif 'command' in expr: |
| 1690 | self._def_command(expr, info) |
| 1691 | elif 'event' in expr: |
| 1692 | self._def_event(expr, info) |
| 1693 | else: |
| 1694 | assert False |
| 1695 | |
| 1696 | def check(self): |
| 1697 | for ent in self._entity_dict.values(): |
| 1698 | ent.check(self) |
| 1699 | |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1700 | def visit(self, visitor): |
Eric Blake | 25a0d9c | 2015-10-12 22:22:21 -0600 | [diff] [blame] | 1701 | visitor.visit_begin(self) |
| 1702 | for (name, entity) in sorted(self._entity_dict.items()): |
| 1703 | if visitor.visit_needed(entity): |
| 1704 | entity.visit(visitor) |
Markus Armbruster | 3f7dc21 | 2015-09-16 13:06:07 +0200 | [diff] [blame] | 1705 | visitor.visit_end() |
| 1706 | |
Markus Armbruster | 2caba36 | 2013-07-27 17:41:56 +0200 | [diff] [blame] | 1707 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 1708 | # |
| 1709 | # Code generation helpers |
| 1710 | # |
| 1711 | |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1712 | def camel_case(name): |
| 1713 | new_name = '' |
| 1714 | first = True |
| 1715 | for ch in name: |
| 1716 | if ch in ['_', '-']: |
| 1717 | first = True |
| 1718 | elif first: |
| 1719 | new_name += ch.upper() |
| 1720 | first = False |
| 1721 | else: |
| 1722 | new_name += ch.lower() |
| 1723 | return new_name |
| 1724 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1725 | |
Markus Armbruster | 849bc53 | 2015-05-14 06:50:53 -0600 | [diff] [blame] | 1726 | # ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1 |
| 1727 | # ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2 |
| 1728 | # ENUM24_Name -> ENUM24_NAME |
| 1729 | def camel_to_upper(value): |
| 1730 | c_fun_str = c_name(value, False) |
| 1731 | if value.isupper(): |
| 1732 | return c_fun_str |
| 1733 | |
| 1734 | new_name = '' |
| 1735 | l = len(c_fun_str) |
| 1736 | for i in range(l): |
| 1737 | c = c_fun_str[i] |
| 1738 | # When c is upper and no "_" appears before, do more checks |
| 1739 | if c.isupper() and (i > 0) and c_fun_str[i - 1] != "_": |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1740 | if i < l - 1 and c_fun_str[i + 1].islower(): |
| 1741 | new_name += '_' |
| 1742 | elif c_fun_str[i - 1].isdigit(): |
Markus Armbruster | 849bc53 | 2015-05-14 06:50:53 -0600 | [diff] [blame] | 1743 | new_name += '_' |
| 1744 | new_name += c |
| 1745 | return new_name.lstrip('_').upper() |
| 1746 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1747 | |
Daniel P. Berrange | 351d36e | 2015-08-26 14:21:20 +0100 | [diff] [blame] | 1748 | def c_enum_const(type_name, const_name, prefix=None): |
| 1749 | if prefix is not None: |
| 1750 | type_name = prefix |
Eric Blake | d20a580 | 2015-11-18 01:53:01 -0700 | [diff] [blame] | 1751 | return camel_to_upper(type_name) + '_' + c_name(const_name, False).upper() |
Markus Armbruster | 849bc53 | 2015-05-14 06:50:53 -0600 | [diff] [blame] | 1752 | |
Eric Blake | 18df515 | 2015-05-14 06:50:48 -0600 | [diff] [blame] | 1753 | c_name_trans = string.maketrans('.-', '__') |
Markus Armbruster | 4729926 | 2015-05-14 06:50:47 -0600 | [diff] [blame] | 1754 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1755 | |
Eric Blake | c6405b5 | 2015-05-14 06:50:55 -0600 | [diff] [blame] | 1756 | # Map @name to a valid C identifier. |
| 1757 | # If @protect, avoid returning certain ticklish identifiers (like |
| 1758 | # C keywords) by prepending "q_". |
| 1759 | # |
| 1760 | # Used for converting 'name' from a 'name':'type' qapi definition |
| 1761 | # into a generated struct member, as well as converting type names |
| 1762 | # into substrings of a generated C function name. |
| 1763 | # '__a.b_c' -> '__a_b_c', 'x-foo' -> 'x_foo' |
| 1764 | # protect=True: 'int' -> 'q_int'; protect=False: 'int' -> 'int' |
Eric Blake | 18df515 | 2015-05-14 06:50:48 -0600 | [diff] [blame] | 1765 | def c_name(name, protect=True): |
Blue Swirl | 427a1a2 | 2012-07-30 15:46:55 +0000 | [diff] [blame] | 1766 | # ANSI X3J11/88-090, 3.1.1 |
| 1767 | c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue', |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1768 | 'default', 'do', 'double', 'else', 'enum', 'extern', |
| 1769 | 'float', 'for', 'goto', 'if', 'int', 'long', 'register', |
| 1770 | 'return', 'short', 'signed', 'sizeof', 'static', |
| 1771 | 'struct', 'switch', 'typedef', 'union', 'unsigned', |
| 1772 | 'void', 'volatile', 'while']) |
Blue Swirl | 427a1a2 | 2012-07-30 15:46:55 +0000 | [diff] [blame] | 1773 | # ISO/IEC 9899:1999, 6.4.1 |
| 1774 | c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary']) |
| 1775 | # ISO/IEC 9899:2011, 6.4.1 |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1776 | c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic', |
| 1777 | '_Noreturn', '_Static_assert', '_Thread_local']) |
Blue Swirl | 427a1a2 | 2012-07-30 15:46:55 +0000 | [diff] [blame] | 1778 | # GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html |
| 1779 | # excluding _.* |
| 1780 | gcc_words = set(['asm', 'typeof']) |
Tomoki Sekiyama | 6f88009 | 2013-08-07 11:39:43 -0400 | [diff] [blame] | 1781 | # C++ ISO/IEC 14882:2003 2.11 |
| 1782 | cpp_words = set(['bool', 'catch', 'class', 'const_cast', 'delete', |
| 1783 | 'dynamic_cast', 'explicit', 'false', 'friend', 'mutable', |
| 1784 | 'namespace', 'new', 'operator', 'private', 'protected', |
| 1785 | 'public', 'reinterpret_cast', 'static_cast', 'template', |
| 1786 | 'this', 'throw', 'true', 'try', 'typeid', 'typename', |
| 1787 | 'using', 'virtual', 'wchar_t', |
| 1788 | # alternative representations |
| 1789 | 'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not', |
| 1790 | 'not_eq', 'or', 'or_eq', 'xor', 'xor_eq']) |
Paolo Bonzini | 1057725 | 2012-09-19 16:31:07 +0200 | [diff] [blame] | 1791 | # namespace pollution: |
Eric Blake | 86ae191 | 2016-02-02 07:51:41 -0700 | [diff] [blame] | 1792 | polluted_words = set(['unix', 'errno', 'mips', 'sparc']) |
Eric Blake | c43567c | 2015-11-18 01:52:52 -0700 | [diff] [blame] | 1793 | name = name.translate(c_name_trans) |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1794 | if protect and (name in c89_words | c99_words | c11_words | gcc_words |
| 1795 | | cpp_words | polluted_words): |
Blue Swirl | 427a1a2 | 2012-07-30 15:46:55 +0000 | [diff] [blame] | 1796 | return "q_" + name |
Eric Blake | c43567c | 2015-11-18 01:52:52 -0700 | [diff] [blame] | 1797 | return name |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1798 | |
Amos Kong | 05dfb26 | 2014-06-10 19:25:53 +0800 | [diff] [blame] | 1799 | eatspace = '\033EATSPACE.' |
Eric Blake | d557344 | 2015-05-14 06:50:54 -0600 | [diff] [blame] | 1800 | pointer_suffix = ' *' + eatspace |
Amos Kong | 05dfb26 | 2014-06-10 19:25:53 +0800 | [diff] [blame] | 1801 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1802 | |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1803 | def genindent(count): |
| 1804 | ret = "" |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1805 | for _ in range(count): |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1806 | ret += " " |
| 1807 | return ret |
| 1808 | |
| 1809 | indent_level = 0 |
| 1810 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1811 | |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1812 | def push_indent(indent_amount=4): |
| 1813 | global indent_level |
| 1814 | indent_level += indent_amount |
| 1815 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1816 | |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1817 | def pop_indent(indent_amount=4): |
| 1818 | global indent_level |
| 1819 | indent_level -= indent_amount |
| 1820 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1821 | |
Markus Armbruster | 77e703b | 2015-06-24 19:27:32 +0200 | [diff] [blame] | 1822 | # Generate @code with @kwds interpolated. |
| 1823 | # Obey indent_level, and strip eatspace. |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1824 | def cgen(code, **kwds): |
Markus Armbruster | 77e703b | 2015-06-24 19:27:32 +0200 | [diff] [blame] | 1825 | raw = code % kwds |
| 1826 | if indent_level: |
| 1827 | indent = genindent(indent_level) |
Markus Armbruster | 2752e5b | 2015-09-07 17:45:55 +0200 | [diff] [blame] | 1828 | # re.subn() lacks flags support before Python 2.7, use re.compile() |
| 1829 | raw = re.subn(re.compile("^.", re.MULTILINE), |
| 1830 | indent + r'\g<0>', raw) |
Markus Armbruster | 77e703b | 2015-06-24 19:27:32 +0200 | [diff] [blame] | 1831 | raw = raw[0] |
| 1832 | return re.sub(re.escape(eatspace) + ' *', '', raw) |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1833 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1834 | |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1835 | def mcgen(code, **kwds): |
Markus Armbruster | 77e703b | 2015-06-24 19:27:32 +0200 | [diff] [blame] | 1836 | if code[0] == '\n': |
| 1837 | code = code[1:] |
| 1838 | return cgen(code, **kwds) |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1839 | |
Michael Roth | 0f923be | 2011-07-19 14:50:39 -0500 | [diff] [blame] | 1840 | |
| 1841 | def guardname(filename): |
Markus Armbruster | 00dfc3b | 2015-06-27 07:27:21 +0200 | [diff] [blame] | 1842 | return c_name(filename, protect=False).upper() |
Michael Roth | c0afa9c | 2013-05-10 17:46:00 -0500 | [diff] [blame] | 1843 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1844 | |
Michael Roth | c0afa9c | 2013-05-10 17:46:00 -0500 | [diff] [blame] | 1845 | def guardstart(name): |
| 1846 | return mcgen(''' |
| 1847 | |
| 1848 | #ifndef %(name)s |
| 1849 | #define %(name)s |
| 1850 | |
| 1851 | ''', |
| 1852 | name=guardname(name)) |
| 1853 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1854 | |
Michael Roth | c0afa9c | 2013-05-10 17:46:00 -0500 | [diff] [blame] | 1855 | def guardend(name): |
| 1856 | return mcgen(''' |
| 1857 | |
| 1858 | #endif /* %(name)s */ |
| 1859 | |
| 1860 | ''', |
| 1861 | name=guardname(name)) |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 1862 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1863 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1864 | def gen_enum_lookup(name, values, prefix=None): |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1865 | ret = mcgen(''' |
| 1866 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1867 | const char *const %(c_name)s_lookup[] = { |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1868 | ''', |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1869 | c_name=c_name(name)) |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1870 | for value in values: |
| 1871 | index = c_enum_const(name, value, prefix) |
| 1872 | ret += mcgen(''' |
| 1873 | [%(index)s] = "%(value)s", |
| 1874 | ''', |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1875 | index=index, value=value) |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1876 | |
Eric Blake | 7fb1cf1 | 2015-11-18 01:52:57 -0700 | [diff] [blame] | 1877 | max_index = c_enum_const(name, '_MAX', prefix) |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1878 | ret += mcgen(''' |
| 1879 | [%(max_index)s] = NULL, |
| 1880 | }; |
| 1881 | ''', |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1882 | max_index=max_index) |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1883 | return ret |
| 1884 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1885 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1886 | def gen_enum(name, values, prefix=None): |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1887 | # append automatically generated _MAX value |
Eric Blake | 7fb1cf1 | 2015-11-18 01:52:57 -0700 | [diff] [blame] | 1888 | enum_values = values + ['_MAX'] |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1889 | |
| 1890 | ret = mcgen(''' |
| 1891 | |
| 1892 | typedef enum %(c_name)s { |
| 1893 | ''', |
| 1894 | c_name=c_name(name)) |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1895 | |
| 1896 | i = 0 |
| 1897 | for value in enum_values: |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1898 | ret += mcgen(''' |
| 1899 | %(c_enum)s = %(i)d, |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1900 | ''', |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1901 | c_enum=c_enum_const(name, value, prefix), |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1902 | i=i) |
| 1903 | i += 1 |
| 1904 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1905 | ret += mcgen(''' |
| 1906 | } %(c_name)s; |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1907 | ''', |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1908 | c_name=c_name(name)) |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1909 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 1910 | ret += mcgen(''' |
| 1911 | |
| 1912 | extern const char *const %(c_name)s_lookup[]; |
| 1913 | ''', |
| 1914 | c_name=c_name(name)) |
| 1915 | return ret |
Markus Armbruster | efd2eaa | 2015-09-16 13:06:12 +0200 | [diff] [blame] | 1916 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1917 | |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1918 | def gen_params(arg_type, boxed, extra): |
Markus Armbruster | 03b4367 | 2015-09-16 13:06:20 +0200 | [diff] [blame] | 1919 | if not arg_type: |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 1920 | assert not boxed |
Markus Armbruster | 03b4367 | 2015-09-16 13:06:20 +0200 | [diff] [blame] | 1921 | return extra |
Markus Armbruster | 03b4367 | 2015-09-16 13:06:20 +0200 | [diff] [blame] | 1922 | ret = '' |
| 1923 | sep = '' |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1924 | if boxed: |
Eric Blake | c818408 | 2016-07-13 21:50:20 -0600 | [diff] [blame] | 1925 | ret += '%s arg' % arg_type.c_param_type() |
| 1926 | sep = ', ' |
Eric Blake | 48825ca | 2016-07-13 21:50:19 -0600 | [diff] [blame] | 1927 | else: |
| 1928 | assert not arg_type.variants |
| 1929 | for memb in arg_type.members: |
| 1930 | ret += sep |
| 1931 | sep = ', ' |
| 1932 | if memb.optional: |
| 1933 | ret += 'bool has_%s, ' % c_name(memb.name) |
| 1934 | ret += '%s %s' % (memb.type.c_param_type(), |
| 1935 | c_name(memb.name)) |
Markus Armbruster | 03b4367 | 2015-09-16 13:06:20 +0200 | [diff] [blame] | 1936 | if extra: |
| 1937 | ret += sep + extra |
| 1938 | return ret |
| 1939 | |
Eric Blake | 1f35334 | 2015-09-29 16:21:13 -0600 | [diff] [blame] | 1940 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 1941 | # |
| 1942 | # Common command line parsing |
| 1943 | # |
| 1944 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1945 | |
| 1946 | def parse_command_line(extra_options="", extra_long_options=[]): |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 1947 | |
| 1948 | try: |
| 1949 | opts, args = getopt.gnu_getopt(sys.argv[1:], |
Markus Armbruster | 16d80f6 | 2015-04-02 13:32:16 +0200 | [diff] [blame] | 1950 | "chp:o:" + extra_options, |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 1951 | ["source", "header", "prefix=", |
Markus Armbruster | 16d80f6 | 2015-04-02 13:32:16 +0200 | [diff] [blame] | 1952 | "output-dir="] + extra_long_options) |
Markus Armbruster | 291928a | 2015-12-18 08:52:41 +0100 | [diff] [blame] | 1953 | except getopt.GetoptError as err: |
Markus Armbruster | b454096 | 2015-04-02 13:17:34 +0200 | [diff] [blame] | 1954 | print >>sys.stderr, "%s: %s" % (sys.argv[0], str(err)) |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 1955 | sys.exit(1) |
| 1956 | |
| 1957 | output_dir = "" |
| 1958 | prefix = "" |
| 1959 | do_c = False |
| 1960 | do_h = False |
| 1961 | extra_opts = [] |
| 1962 | |
| 1963 | for oa in opts: |
| 1964 | o, a = oa |
| 1965 | if o in ("-p", "--prefix"): |
Markus Armbruster | 1cf47a1 | 2015-07-01 13:13:54 +0200 | [diff] [blame] | 1966 | match = re.match('([A-Za-z_.-][A-Za-z0-9_.-]*)?', a) |
| 1967 | if match.end() != len(a): |
| 1968 | print >>sys.stderr, \ |
| 1969 | "%s: 'funny character '%s' in argument of --prefix" \ |
| 1970 | % (sys.argv[0], a[match.end()]) |
| 1971 | sys.exit(1) |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 1972 | prefix = a |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 1973 | elif o in ("-o", "--output-dir"): |
| 1974 | output_dir = a + "/" |
| 1975 | elif o in ("-c", "--source"): |
| 1976 | do_c = True |
| 1977 | elif o in ("-h", "--header"): |
| 1978 | do_h = True |
| 1979 | else: |
| 1980 | extra_opts.append(oa) |
| 1981 | |
| 1982 | if not do_c and not do_h: |
| 1983 | do_c = True |
| 1984 | do_h = True |
| 1985 | |
Markus Armbruster | 16d80f6 | 2015-04-02 13:32:16 +0200 | [diff] [blame] | 1986 | if len(args) != 1: |
| 1987 | print >>sys.stderr, "%s: need exactly one argument" % sys.argv[0] |
Markus Armbruster | b454096 | 2015-04-02 13:17:34 +0200 | [diff] [blame] | 1988 | sys.exit(1) |
Markus Armbruster | 5441404 | 2015-06-09 16:22:45 +0200 | [diff] [blame] | 1989 | fname = args[0] |
Markus Armbruster | b454096 | 2015-04-02 13:17:34 +0200 | [diff] [blame] | 1990 | |
Markus Armbruster | 5441404 | 2015-06-09 16:22:45 +0200 | [diff] [blame] | 1991 | return (fname, output_dir, do_c, do_h, prefix, extra_opts) |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 1992 | |
Markus Armbruster | 00e4b28 | 2015-06-10 10:04:36 +0200 | [diff] [blame] | 1993 | # |
| 1994 | # Generate output files with boilerplate |
| 1995 | # |
| 1996 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 1997 | |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 1998 | def open_output(output_dir, do_c, do_h, prefix, c_file, h_file, |
| 1999 | c_comment, h_comment): |
Markus Armbruster | 00dfc3b | 2015-06-27 07:27:21 +0200 | [diff] [blame] | 2000 | guard = guardname(prefix + h_file) |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 2001 | c_file = output_dir + prefix + c_file |
| 2002 | h_file = output_dir + prefix + h_file |
| 2003 | |
Markus Armbruster | c4f498f | 2015-09-03 10:24:25 +0200 | [diff] [blame] | 2004 | if output_dir: |
| 2005 | try: |
| 2006 | os.makedirs(output_dir) |
Markus Armbruster | 291928a | 2015-12-18 08:52:41 +0100 | [diff] [blame] | 2007 | except os.error as e: |
Markus Armbruster | c4f498f | 2015-09-03 10:24:25 +0200 | [diff] [blame] | 2008 | if e.errno != errno.EEXIST: |
| 2009 | raise |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 2010 | |
| 2011 | def maybe_open(really, name, opt): |
| 2012 | if really: |
| 2013 | return open(name, opt) |
| 2014 | else: |
| 2015 | import StringIO |
| 2016 | return StringIO.StringIO() |
| 2017 | |
| 2018 | fdef = maybe_open(do_c, c_file, 'w') |
| 2019 | fdecl = maybe_open(do_h, h_file, 'w') |
| 2020 | |
| 2021 | fdef.write(mcgen(''' |
| 2022 | /* AUTOMATICALLY GENERATED, DO NOT MODIFY */ |
| 2023 | %(comment)s |
| 2024 | ''', |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 2025 | comment=c_comment)) |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 2026 | |
| 2027 | fdecl.write(mcgen(''' |
| 2028 | /* AUTOMATICALLY GENERATED, DO NOT MODIFY */ |
| 2029 | %(comment)s |
| 2030 | #ifndef %(guard)s |
| 2031 | #define %(guard)s |
| 2032 | |
| 2033 | ''', |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 2034 | comment=h_comment, guard=guard)) |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 2035 | |
| 2036 | return (fdef, fdecl) |
| 2037 | |
Eric Blake | 437db25 | 2015-09-29 16:21:02 -0600 | [diff] [blame] | 2038 | |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 2039 | def close_output(fdef, fdecl): |
| 2040 | fdecl.write(''' |
| 2041 | #endif |
| 2042 | ''') |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 2043 | fdecl.close() |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 2044 | fdef.close() |