qapi.py 58 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749
  1. #
  2. # QAPI helper library
  3. #
  4. # Copyright IBM, Corp. 2011
  5. # Copyright (c) 2013-2016 Red Hat Inc.
  6. #
  7. # Authors:
  8. # Anthony Liguori <aliguori@us.ibm.com>
  9. # Markus Armbruster <armbru@redhat.com>
  10. #
  11. # This work is licensed under the terms of the GNU GPL, version 2.
  12. # See the COPYING file in the top-level directory.
  13. import re
  14. from ordereddict import OrderedDict
  15. import errno
  16. import getopt
  17. import os
  18. import sys
  19. import string
  20. builtin_types = {
  21. 'str': 'QTYPE_QSTRING',
  22. 'int': 'QTYPE_QINT',
  23. 'number': 'QTYPE_QFLOAT',
  24. 'bool': 'QTYPE_QBOOL',
  25. 'int8': 'QTYPE_QINT',
  26. 'int16': 'QTYPE_QINT',
  27. 'int32': 'QTYPE_QINT',
  28. 'int64': 'QTYPE_QINT',
  29. 'uint8': 'QTYPE_QINT',
  30. 'uint16': 'QTYPE_QINT',
  31. 'uint32': 'QTYPE_QINT',
  32. 'uint64': 'QTYPE_QINT',
  33. 'size': 'QTYPE_QINT',
  34. 'any': None, # any QType possible, actually
  35. 'QType': 'QTYPE_QSTRING',
  36. }
  37. # Whitelist of commands allowed to return a non-dictionary
  38. returns_whitelist = [
  39. # From QMP:
  40. 'human-monitor-command',
  41. 'qom-get',
  42. 'query-migrate-cache-size',
  43. 'query-tpm-models',
  44. 'query-tpm-types',
  45. 'ringbuf-read',
  46. # From QGA:
  47. 'guest-file-open',
  48. 'guest-fsfreeze-freeze',
  49. 'guest-fsfreeze-freeze-list',
  50. 'guest-fsfreeze-status',
  51. 'guest-fsfreeze-thaw',
  52. 'guest-get-time',
  53. 'guest-set-vcpus',
  54. 'guest-sync',
  55. 'guest-sync-delimited',
  56. ]
  57. # Whitelist of entities allowed to violate case conventions
  58. case_whitelist = [
  59. # From QMP:
  60. 'ACPISlotType', # DIMM, visible through query-acpi-ospm-status
  61. 'CpuInfoBase', # CPU, visible through query-cpu
  62. 'CpuInfoMIPS', # PC, visible through query-cpu
  63. 'CpuInfoTricore', # PC, visible through query-cpu
  64. 'QapiErrorClass', # all members, visible through errors
  65. 'UuidInfo', # UUID, visible through query-uuid
  66. 'X86CPURegister32', # all members, visible indirectly through qom-get
  67. ]
  68. enum_types = []
  69. struct_types = []
  70. union_types = []
  71. events = []
  72. all_names = {}
  73. #
  74. # Parsing the schema into expressions
  75. #
  76. def error_path(parent):
  77. res = ""
  78. while parent:
  79. res = ("In file included from %s:%d:\n" % (parent['file'],
  80. parent['line'])) + res
  81. parent = parent['parent']
  82. return res
  83. class QAPISchemaError(Exception):
  84. def __init__(self, schema, msg):
  85. Exception.__init__(self)
  86. self.fname = schema.fname
  87. self.msg = msg
  88. self.col = 1
  89. self.line = schema.line
  90. for ch in schema.src[schema.line_pos:schema.pos]:
  91. if ch == '\t':
  92. self.col = (self.col + 7) % 8 + 1
  93. else:
  94. self.col += 1
  95. self.info = schema.incl_info
  96. def __str__(self):
  97. return error_path(self.info) + \
  98. "%s:%d:%d: %s" % (self.fname, self.line, self.col, self.msg)
  99. class QAPIExprError(Exception):
  100. def __init__(self, expr_info, msg):
  101. Exception.__init__(self)
  102. assert expr_info
  103. self.info = expr_info
  104. self.msg = msg
  105. def __str__(self):
  106. return error_path(self.info['parent']) + \
  107. "%s:%d: %s" % (self.info['file'], self.info['line'], self.msg)
  108. class QAPISchemaParser(object):
  109. def __init__(self, fp, previously_included=[], incl_info=None):
  110. abs_fname = os.path.abspath(fp.name)
  111. fname = fp.name
  112. self.fname = fname
  113. previously_included.append(abs_fname)
  114. self.incl_info = incl_info
  115. self.src = fp.read()
  116. if self.src == '' or self.src[-1] != '\n':
  117. self.src += '\n'
  118. self.cursor = 0
  119. self.line = 1
  120. self.line_pos = 0
  121. self.exprs = []
  122. self.accept()
  123. while self.tok is not None:
  124. expr_info = {'file': fname, 'line': self.line,
  125. 'parent': self.incl_info}
  126. expr = self.get_expr(False)
  127. if isinstance(expr, dict) and "include" in expr:
  128. if len(expr) != 1:
  129. raise QAPIExprError(expr_info,
  130. "Invalid 'include' directive")
  131. include = expr["include"]
  132. if not isinstance(include, str):
  133. raise QAPIExprError(expr_info,
  134. "Value of 'include' must be a string")
  135. incl_abs_fname = os.path.join(os.path.dirname(abs_fname),
  136. include)
  137. # catch inclusion cycle
  138. inf = expr_info
  139. while inf:
  140. if incl_abs_fname == os.path.abspath(inf['file']):
  141. raise QAPIExprError(expr_info, "Inclusion loop for %s"
  142. % include)
  143. inf = inf['parent']
  144. # skip multiple include of the same file
  145. if incl_abs_fname in previously_included:
  146. continue
  147. try:
  148. fobj = open(incl_abs_fname, 'r')
  149. except IOError as e:
  150. raise QAPIExprError(expr_info,
  151. '%s: %s' % (e.strerror, include))
  152. exprs_include = QAPISchemaParser(fobj, previously_included,
  153. expr_info)
  154. self.exprs.extend(exprs_include.exprs)
  155. else:
  156. expr_elem = {'expr': expr,
  157. 'info': expr_info}
  158. self.exprs.append(expr_elem)
  159. def accept(self):
  160. while True:
  161. self.tok = self.src[self.cursor]
  162. self.pos = self.cursor
  163. self.cursor += 1
  164. self.val = None
  165. if self.tok == '#':
  166. self.cursor = self.src.find('\n', self.cursor)
  167. elif self.tok in "{}:,[]":
  168. return
  169. elif self.tok == "'":
  170. string = ''
  171. esc = False
  172. while True:
  173. ch = self.src[self.cursor]
  174. self.cursor += 1
  175. if ch == '\n':
  176. raise QAPISchemaError(self,
  177. 'Missing terminating "\'"')
  178. if esc:
  179. if ch == 'b':
  180. string += '\b'
  181. elif ch == 'f':
  182. string += '\f'
  183. elif ch == 'n':
  184. string += '\n'
  185. elif ch == 'r':
  186. string += '\r'
  187. elif ch == 't':
  188. string += '\t'
  189. elif ch == 'u':
  190. value = 0
  191. for _ in range(0, 4):
  192. ch = self.src[self.cursor]
  193. self.cursor += 1
  194. if ch not in "0123456789abcdefABCDEF":
  195. raise QAPISchemaError(self,
  196. '\\u escape needs 4 '
  197. 'hex digits')
  198. value = (value << 4) + int(ch, 16)
  199. # If Python 2 and 3 didn't disagree so much on
  200. # how to handle Unicode, then we could allow
  201. # Unicode string defaults. But most of QAPI is
  202. # ASCII-only, so we aren't losing much for now.
  203. if not value or value > 0x7f:
  204. raise QAPISchemaError(self,
  205. 'For now, \\u escape '
  206. 'only supports non-zero '
  207. 'values up to \\u007f')
  208. string += chr(value)
  209. elif ch in "\\/'\"":
  210. string += ch
  211. else:
  212. raise QAPISchemaError(self,
  213. "Unknown escape \\%s" % ch)
  214. esc = False
  215. elif ch == "\\":
  216. esc = True
  217. elif ch == "'":
  218. self.val = string
  219. return
  220. else:
  221. string += ch
  222. elif self.src.startswith("true", self.pos):
  223. self.val = True
  224. self.cursor += 3
  225. return
  226. elif self.src.startswith("false", self.pos):
  227. self.val = False
  228. self.cursor += 4
  229. return
  230. elif self.src.startswith("null", self.pos):
  231. self.val = None
  232. self.cursor += 3
  233. return
  234. elif self.tok == '\n':
  235. if self.cursor == len(self.src):
  236. self.tok = None
  237. return
  238. self.line += 1
  239. self.line_pos = self.cursor
  240. elif not self.tok.isspace():
  241. raise QAPISchemaError(self, 'Stray "%s"' % self.tok)
  242. def get_members(self):
  243. expr = OrderedDict()
  244. if self.tok == '}':
  245. self.accept()
  246. return expr
  247. if self.tok != "'":
  248. raise QAPISchemaError(self, 'Expected string or "}"')
  249. while True:
  250. key = self.val
  251. self.accept()
  252. if self.tok != ':':
  253. raise QAPISchemaError(self, 'Expected ":"')
  254. self.accept()
  255. if key in expr:
  256. raise QAPISchemaError(self, 'Duplicate key "%s"' % key)
  257. expr[key] = self.get_expr(True)
  258. if self.tok == '}':
  259. self.accept()
  260. return expr
  261. if self.tok != ',':
  262. raise QAPISchemaError(self, 'Expected "," or "}"')
  263. self.accept()
  264. if self.tok != "'":
  265. raise QAPISchemaError(self, 'Expected string')
  266. def get_values(self):
  267. expr = []
  268. if self.tok == ']':
  269. self.accept()
  270. return expr
  271. if self.tok not in "{['tfn":
  272. raise QAPISchemaError(self, 'Expected "{", "[", "]", string, '
  273. 'boolean or "null"')
  274. while True:
  275. expr.append(self.get_expr(True))
  276. if self.tok == ']':
  277. self.accept()
  278. return expr
  279. if self.tok != ',':
  280. raise QAPISchemaError(self, 'Expected "," or "]"')
  281. self.accept()
  282. def get_expr(self, nested):
  283. if self.tok != '{' and not nested:
  284. raise QAPISchemaError(self, 'Expected "{"')
  285. if self.tok == '{':
  286. self.accept()
  287. expr = self.get_members()
  288. elif self.tok == '[':
  289. self.accept()
  290. expr = self.get_values()
  291. elif self.tok in "'tfn":
  292. expr = self.val
  293. self.accept()
  294. else:
  295. raise QAPISchemaError(self, 'Expected "{", "[" or string')
  296. return expr
  297. #
  298. # Semantic analysis of schema expressions
  299. # TODO fold into QAPISchema
  300. # TODO catching name collisions in generated code would be nice
  301. #
  302. def find_base_members(base):
  303. base_struct_define = find_struct(base)
  304. if not base_struct_define:
  305. return None
  306. return base_struct_define['data']
  307. # Return the qtype of an alternate branch, or None on error.
  308. def find_alternate_member_qtype(qapi_type):
  309. if qapi_type in builtin_types:
  310. return builtin_types[qapi_type]
  311. elif find_struct(qapi_type):
  312. return "QTYPE_QDICT"
  313. elif find_enum(qapi_type):
  314. return "QTYPE_QSTRING"
  315. elif find_union(qapi_type):
  316. return "QTYPE_QDICT"
  317. return None
  318. # Return the discriminator enum define if discriminator is specified as an
  319. # enum type, otherwise return None.
  320. def discriminator_find_enum_define(expr):
  321. base = expr.get('base')
  322. discriminator = expr.get('discriminator')
  323. if not (discriminator and base):
  324. return None
  325. base_members = find_base_members(base)
  326. if not base_members:
  327. return None
  328. discriminator_type = base_members.get(discriminator)
  329. if not discriminator_type:
  330. return None
  331. return find_enum(discriminator_type)
  332. # Names must be letters, numbers, -, and _. They must start with letter,
  333. # except for downstream extensions which must start with __RFQDN_.
  334. # Dots are only valid in the downstream extension prefix.
  335. valid_name = re.compile('^(__[a-zA-Z0-9.-]+_)?'
  336. '[a-zA-Z][a-zA-Z0-9_-]*$')
  337. def check_name(expr_info, source, name, allow_optional=False,
  338. enum_member=False):
  339. global valid_name
  340. membername = name
  341. if not isinstance(name, str):
  342. raise QAPIExprError(expr_info,
  343. "%s requires a string name" % source)
  344. if name.startswith('*'):
  345. membername = name[1:]
  346. if not allow_optional:
  347. raise QAPIExprError(expr_info,
  348. "%s does not allow optional name '%s'"
  349. % (source, name))
  350. # Enum members can start with a digit, because the generated C
  351. # code always prefixes it with the enum name
  352. if enum_member and membername[0].isdigit():
  353. membername = 'D' + membername
  354. # Reserve the entire 'q_' namespace for c_name(), and for 'q_empty'
  355. # and 'q_obj_*' implicit type names.
  356. if not valid_name.match(membername) or \
  357. c_name(membername, False).startswith('q_'):
  358. raise QAPIExprError(expr_info,
  359. "%s uses invalid name '%s'" % (source, name))
  360. def add_name(name, info, meta, implicit=False):
  361. global all_names
  362. check_name(info, "'%s'" % meta, name)
  363. # FIXME should reject names that differ only in '_' vs. '.'
  364. # vs. '-', because they're liable to clash in generated C.
  365. if name in all_names:
  366. raise QAPIExprError(info,
  367. "%s '%s' is already defined"
  368. % (all_names[name], name))
  369. if not implicit and (name.endswith('Kind') or name.endswith('List')):
  370. raise QAPIExprError(info,
  371. "%s '%s' should not end in '%s'"
  372. % (meta, name, name[-4:]))
  373. all_names[name] = meta
  374. def add_struct(definition, info):
  375. global struct_types
  376. name = definition['struct']
  377. add_name(name, info, 'struct')
  378. struct_types.append(definition)
  379. def find_struct(name):
  380. global struct_types
  381. for struct in struct_types:
  382. if struct['struct'] == name:
  383. return struct
  384. return None
  385. def add_union(definition, info):
  386. global union_types
  387. name = definition['union']
  388. add_name(name, info, 'union')
  389. union_types.append(definition)
  390. def find_union(name):
  391. global union_types
  392. for union in union_types:
  393. if union['union'] == name:
  394. return union
  395. return None
  396. def add_enum(name, info, enum_values=None, implicit=False):
  397. global enum_types
  398. add_name(name, info, 'enum', implicit)
  399. enum_types.append({"enum_name": name, "enum_values": enum_values})
  400. def find_enum(name):
  401. global enum_types
  402. for enum in enum_types:
  403. if enum['enum_name'] == name:
  404. return enum
  405. return None
  406. def is_enum(name):
  407. return find_enum(name) is not None
  408. def check_type(expr_info, source, value, allow_array=False,
  409. allow_dict=False, allow_optional=False,
  410. allow_metas=[]):
  411. global all_names
  412. if value is None:
  413. return
  414. # Check if array type for value is okay
  415. if isinstance(value, list):
  416. if not allow_array:
  417. raise QAPIExprError(expr_info,
  418. "%s cannot be an array" % source)
  419. if len(value) != 1 or not isinstance(value[0], str):
  420. raise QAPIExprError(expr_info,
  421. "%s: array type must contain single type name"
  422. % source)
  423. value = value[0]
  424. # Check if type name for value is okay
  425. if isinstance(value, str):
  426. if value not in all_names:
  427. raise QAPIExprError(expr_info,
  428. "%s uses unknown type '%s'"
  429. % (source, value))
  430. if not all_names[value] in allow_metas:
  431. raise QAPIExprError(expr_info,
  432. "%s cannot use %s type '%s'"
  433. % (source, all_names[value], value))
  434. return
  435. if not allow_dict:
  436. raise QAPIExprError(expr_info,
  437. "%s should be a type name" % source)
  438. if not isinstance(value, OrderedDict):
  439. raise QAPIExprError(expr_info,
  440. "%s should be a dictionary or type name" % source)
  441. # value is a dictionary, check that each member is okay
  442. for (key, arg) in value.items():
  443. check_name(expr_info, "Member of %s" % source, key,
  444. allow_optional=allow_optional)
  445. if c_name(key, False) == 'u' or c_name(key, False).startswith('has_'):
  446. raise QAPIExprError(expr_info,
  447. "Member of %s uses reserved name '%s'"
  448. % (source, key))
  449. # Todo: allow dictionaries to represent default values of
  450. # an optional argument.
  451. check_type(expr_info, "Member '%s' of %s" % (key, source), arg,
  452. allow_array=True,
  453. allow_metas=['built-in', 'union', 'alternate', 'struct',
  454. 'enum'])
  455. def check_command(expr, expr_info):
  456. name = expr['command']
  457. check_type(expr_info, "'data' for command '%s'" % name,
  458. expr.get('data'), allow_dict=True, allow_optional=True,
  459. allow_metas=['struct'])
  460. returns_meta = ['union', 'struct']
  461. if name in returns_whitelist:
  462. returns_meta += ['built-in', 'alternate', 'enum']
  463. check_type(expr_info, "'returns' for command '%s'" % name,
  464. expr.get('returns'), allow_array=True,
  465. allow_optional=True, allow_metas=returns_meta)
  466. def check_event(expr, expr_info):
  467. global events
  468. name = expr['event']
  469. events.append(name)
  470. check_type(expr_info, "'data' for event '%s'" % name,
  471. expr.get('data'), allow_dict=True, allow_optional=True,
  472. allow_metas=['struct'])
  473. def check_union(expr, expr_info):
  474. name = expr['union']
  475. base = expr.get('base')
  476. discriminator = expr.get('discriminator')
  477. members = expr['data']
  478. # Two types of unions, determined by discriminator.
  479. # With no discriminator it is a simple union.
  480. if discriminator is None:
  481. enum_define = None
  482. allow_metas = ['built-in', 'union', 'alternate', 'struct', 'enum']
  483. if base is not None:
  484. raise QAPIExprError(expr_info,
  485. "Simple union '%s' must not have a base"
  486. % name)
  487. # Else, it's a flat union.
  488. else:
  489. # The object must have a string member 'base'.
  490. check_type(expr_info, "'base' for union '%s'" % name,
  491. base, allow_metas=['struct'])
  492. if not base:
  493. raise QAPIExprError(expr_info,
  494. "Flat union '%s' must have a base"
  495. % name)
  496. base_members = find_base_members(base)
  497. assert base_members
  498. # The value of member 'discriminator' must name a non-optional
  499. # member of the base struct.
  500. check_name(expr_info, "Discriminator of flat union '%s'" % name,
  501. discriminator)
  502. discriminator_type = base_members.get(discriminator)
  503. if not discriminator_type:
  504. raise QAPIExprError(expr_info,
  505. "Discriminator '%s' is not a member of base "
  506. "struct '%s'"
  507. % (discriminator, base))
  508. enum_define = find_enum(discriminator_type)
  509. allow_metas = ['struct']
  510. # Do not allow string discriminator
  511. if not enum_define:
  512. raise QAPIExprError(expr_info,
  513. "Discriminator '%s' must be of enumeration "
  514. "type" % discriminator)
  515. # Check every branch; don't allow an empty union
  516. if len(members) == 0:
  517. raise QAPIExprError(expr_info,
  518. "Union '%s' cannot have empty 'data'" % name)
  519. for (key, value) in members.items():
  520. check_name(expr_info, "Member of union '%s'" % name, key)
  521. # Each value must name a known type
  522. check_type(expr_info, "Member '%s' of union '%s'" % (key, name),
  523. value, allow_array=not base, allow_metas=allow_metas)
  524. # If the discriminator names an enum type, then all members
  525. # of 'data' must also be members of the enum type.
  526. if enum_define:
  527. if key not in enum_define['enum_values']:
  528. raise QAPIExprError(expr_info,
  529. "Discriminator value '%s' is not found in "
  530. "enum '%s'" %
  531. (key, enum_define["enum_name"]))
  532. def check_alternate(expr, expr_info):
  533. name = expr['alternate']
  534. members = expr['data']
  535. types_seen = {}
  536. # Check every branch; require at least two branches
  537. if len(members) < 2:
  538. raise QAPIExprError(expr_info,
  539. "Alternate '%s' should have at least two branches "
  540. "in 'data'" % name)
  541. for (key, value) in members.items():
  542. check_name(expr_info, "Member of alternate '%s'" % name, key)
  543. # Ensure alternates have no type conflicts.
  544. check_type(expr_info, "Member '%s' of alternate '%s'" % (key, name),
  545. value,
  546. allow_metas=['built-in', 'union', 'struct', 'enum'])
  547. qtype = find_alternate_member_qtype(value)
  548. if not qtype:
  549. raise QAPIExprError(expr_info,
  550. "Alternate '%s' member '%s' cannot use "
  551. "type '%s'" % (name, key, value))
  552. if qtype in types_seen:
  553. raise QAPIExprError(expr_info,
  554. "Alternate '%s' member '%s' can't "
  555. "be distinguished from member '%s'"
  556. % (name, key, types_seen[qtype]))
  557. types_seen[qtype] = key
  558. def check_enum(expr, expr_info):
  559. name = expr['enum']
  560. members = expr.get('data')
  561. prefix = expr.get('prefix')
  562. if not isinstance(members, list):
  563. raise QAPIExprError(expr_info,
  564. "Enum '%s' requires an array for 'data'" % name)
  565. if prefix is not None and not isinstance(prefix, str):
  566. raise QAPIExprError(expr_info,
  567. "Enum '%s' requires a string for 'prefix'" % name)
  568. for member in members:
  569. check_name(expr_info, "Member of enum '%s'" % name, member,
  570. enum_member=True)
  571. def check_struct(expr, expr_info):
  572. name = expr['struct']
  573. members = expr['data']
  574. check_type(expr_info, "'data' for struct '%s'" % name, members,
  575. allow_dict=True, allow_optional=True)
  576. check_type(expr_info, "'base' for struct '%s'" % name, expr.get('base'),
  577. allow_metas=['struct'])
  578. def check_keys(expr_elem, meta, required, optional=[]):
  579. expr = expr_elem['expr']
  580. info = expr_elem['info']
  581. name = expr[meta]
  582. if not isinstance(name, str):
  583. raise QAPIExprError(info,
  584. "'%s' key must have a string value" % meta)
  585. required = required + [meta]
  586. for (key, value) in expr.items():
  587. if key not in required and key not in optional:
  588. raise QAPIExprError(info,
  589. "Unknown key '%s' in %s '%s'"
  590. % (key, meta, name))
  591. if (key == 'gen' or key == 'success-response') and value is not False:
  592. raise QAPIExprError(info,
  593. "'%s' of %s '%s' should only use false value"
  594. % (key, meta, name))
  595. for key in required:
  596. if key not in expr:
  597. raise QAPIExprError(info,
  598. "Key '%s' is missing from %s '%s'"
  599. % (key, meta, name))
  600. def check_exprs(exprs):
  601. global all_names
  602. # Learn the types and check for valid expression keys
  603. for builtin in builtin_types.keys():
  604. all_names[builtin] = 'built-in'
  605. for expr_elem in exprs:
  606. expr = expr_elem['expr']
  607. info = expr_elem['info']
  608. if 'enum' in expr:
  609. check_keys(expr_elem, 'enum', ['data'], ['prefix'])
  610. add_enum(expr['enum'], info, expr['data'])
  611. elif 'union' in expr:
  612. check_keys(expr_elem, 'union', ['data'],
  613. ['base', 'discriminator'])
  614. add_union(expr, info)
  615. elif 'alternate' in expr:
  616. check_keys(expr_elem, 'alternate', ['data'])
  617. add_name(expr['alternate'], info, 'alternate')
  618. elif 'struct' in expr:
  619. check_keys(expr_elem, 'struct', ['data'], ['base'])
  620. add_struct(expr, info)
  621. elif 'command' in expr:
  622. check_keys(expr_elem, 'command', [],
  623. ['data', 'returns', 'gen', 'success-response'])
  624. add_name(expr['command'], info, 'command')
  625. elif 'event' in expr:
  626. check_keys(expr_elem, 'event', [], ['data'])
  627. add_name(expr['event'], info, 'event')
  628. else:
  629. raise QAPIExprError(expr_elem['info'],
  630. "Expression is missing metatype")
  631. # Try again for hidden UnionKind enum
  632. for expr_elem in exprs:
  633. expr = expr_elem['expr']
  634. if 'union' in expr:
  635. if not discriminator_find_enum_define(expr):
  636. add_enum('%sKind' % expr['union'], expr_elem['info'],
  637. implicit=True)
  638. elif 'alternate' in expr:
  639. add_enum('%sKind' % expr['alternate'], expr_elem['info'],
  640. implicit=True)
  641. # Validate that exprs make sense
  642. for expr_elem in exprs:
  643. expr = expr_elem['expr']
  644. info = expr_elem['info']
  645. if 'enum' in expr:
  646. check_enum(expr, info)
  647. elif 'union' in expr:
  648. check_union(expr, info)
  649. elif 'alternate' in expr:
  650. check_alternate(expr, info)
  651. elif 'struct' in expr:
  652. check_struct(expr, info)
  653. elif 'command' in expr:
  654. check_command(expr, info)
  655. elif 'event' in expr:
  656. check_event(expr, info)
  657. else:
  658. assert False, 'unexpected meta type'
  659. return exprs
  660. #
  661. # Schema compiler frontend
  662. #
  663. class QAPISchemaEntity(object):
  664. def __init__(self, name, info):
  665. assert isinstance(name, str)
  666. self.name = name
  667. # For explicitly defined entities, info points to the (explicit)
  668. # definition. For builtins (and their arrays), info is None.
  669. # For implicitly defined entities, info points to a place that
  670. # triggered the implicit definition (there may be more than one
  671. # such place).
  672. self.info = info
  673. def c_name(self):
  674. return c_name(self.name)
  675. def check(self, schema):
  676. pass
  677. def is_implicit(self):
  678. return not self.info
  679. def visit(self, visitor):
  680. pass
  681. class QAPISchemaVisitor(object):
  682. def visit_begin(self, schema):
  683. pass
  684. def visit_end(self):
  685. pass
  686. def visit_needed(self, entity):
  687. # Default to visiting everything
  688. return True
  689. def visit_builtin_type(self, name, info, json_type):
  690. pass
  691. def visit_enum_type(self, name, info, values, prefix):
  692. pass
  693. def visit_array_type(self, name, info, element_type):
  694. pass
  695. def visit_object_type(self, name, info, base, members, variants):
  696. pass
  697. def visit_object_type_flat(self, name, info, members, variants):
  698. pass
  699. def visit_alternate_type(self, name, info, variants):
  700. pass
  701. def visit_command(self, name, info, arg_type, ret_type,
  702. gen, success_response):
  703. pass
  704. def visit_event(self, name, info, arg_type):
  705. pass
  706. class QAPISchemaType(QAPISchemaEntity):
  707. # Return the C type for common use.
  708. # For the types we commonly box, this is a pointer type.
  709. def c_type(self):
  710. pass
  711. # Return the C type to be used in a parameter list.
  712. def c_param_type(self):
  713. return self.c_type()
  714. # Return the C type to be used where we suppress boxing.
  715. def c_unboxed_type(self):
  716. return self.c_type()
  717. def json_type(self):
  718. pass
  719. def alternate_qtype(self):
  720. json2qtype = {
  721. 'string': 'QTYPE_QSTRING',
  722. 'number': 'QTYPE_QFLOAT',
  723. 'int': 'QTYPE_QINT',
  724. 'boolean': 'QTYPE_QBOOL',
  725. 'object': 'QTYPE_QDICT'
  726. }
  727. return json2qtype.get(self.json_type())
  728. class QAPISchemaBuiltinType(QAPISchemaType):
  729. def __init__(self, name, json_type, c_type):
  730. QAPISchemaType.__init__(self, name, None)
  731. assert not c_type or isinstance(c_type, str)
  732. assert json_type in ('string', 'number', 'int', 'boolean', 'null',
  733. 'value')
  734. self._json_type_name = json_type
  735. self._c_type_name = c_type
  736. def c_name(self):
  737. return self.name
  738. def c_type(self):
  739. return self._c_type_name
  740. def c_param_type(self):
  741. if self.name == 'str':
  742. return 'const ' + self._c_type_name
  743. return self._c_type_name
  744. def json_type(self):
  745. return self._json_type_name
  746. def visit(self, visitor):
  747. visitor.visit_builtin_type(self.name, self.info, self.json_type())
  748. class QAPISchemaEnumType(QAPISchemaType):
  749. def __init__(self, name, info, values, prefix):
  750. QAPISchemaType.__init__(self, name, info)
  751. for v in values:
  752. assert isinstance(v, QAPISchemaMember)
  753. v.set_owner(name)
  754. assert prefix is None or isinstance(prefix, str)
  755. self.values = values
  756. self.prefix = prefix
  757. def check(self, schema):
  758. seen = {}
  759. for v in self.values:
  760. v.check_clash(self.info, seen)
  761. def is_implicit(self):
  762. # See QAPISchema._make_implicit_enum_type()
  763. return self.name.endswith('Kind')
  764. def c_type(self):
  765. return c_name(self.name)
  766. def member_names(self):
  767. return [v.name for v in self.values]
  768. def json_type(self):
  769. return 'string'
  770. def visit(self, visitor):
  771. visitor.visit_enum_type(self.name, self.info,
  772. self.member_names(), self.prefix)
  773. class QAPISchemaArrayType(QAPISchemaType):
  774. def __init__(self, name, info, element_type):
  775. QAPISchemaType.__init__(self, name, info)
  776. assert isinstance(element_type, str)
  777. self._element_type_name = element_type
  778. self.element_type = None
  779. def check(self, schema):
  780. self.element_type = schema.lookup_type(self._element_type_name)
  781. assert self.element_type
  782. def is_implicit(self):
  783. return True
  784. def c_type(self):
  785. return c_name(self.name) + pointer_suffix
  786. def json_type(self):
  787. return 'array'
  788. def visit(self, visitor):
  789. visitor.visit_array_type(self.name, self.info, self.element_type)
  790. class QAPISchemaObjectType(QAPISchemaType):
  791. def __init__(self, name, info, base, local_members, variants):
  792. # struct has local_members, optional base, and no variants
  793. # flat union has base, variants, and no local_members
  794. # simple union has local_members, variants, and no base
  795. QAPISchemaType.__init__(self, name, info)
  796. assert base is None or isinstance(base, str)
  797. for m in local_members:
  798. assert isinstance(m, QAPISchemaObjectTypeMember)
  799. m.set_owner(name)
  800. if variants is not None:
  801. assert isinstance(variants, QAPISchemaObjectTypeVariants)
  802. variants.set_owner(name)
  803. self._base_name = base
  804. self.base = None
  805. self.local_members = local_members
  806. self.variants = variants
  807. self.members = None
  808. def check(self, schema):
  809. if self.members is False: # check for cycles
  810. raise QAPIExprError(self.info,
  811. "Object %s contains itself" % self.name)
  812. if self.members:
  813. return
  814. self.members = False # mark as being checked
  815. seen = OrderedDict()
  816. if self._base_name:
  817. self.base = schema.lookup_type(self._base_name)
  818. assert isinstance(self.base, QAPISchemaObjectType)
  819. self.base.check(schema)
  820. self.base.check_clash(schema, self.info, seen)
  821. for m in self.local_members:
  822. m.check(schema)
  823. m.check_clash(self.info, seen)
  824. self.members = seen.values()
  825. if self.variants:
  826. self.variants.check(schema, seen)
  827. assert self.variants.tag_member in self.members
  828. self.variants.check_clash(schema, self.info, seen)
  829. # Check that the members of this type do not cause duplicate JSON members,
  830. # and update seen to track the members seen so far. Report any errors
  831. # on behalf of info, which is not necessarily self.info
  832. def check_clash(self, schema, info, seen):
  833. assert not self.variants # not implemented
  834. for m in self.members:
  835. m.check_clash(info, seen)
  836. def is_implicit(self):
  837. # See QAPISchema._make_implicit_object_type(), as well as
  838. # _def_predefineds()
  839. return self.name.startswith('q_')
  840. def c_name(self):
  841. return QAPISchemaType.c_name(self)
  842. def c_type(self):
  843. assert not self.is_implicit()
  844. return c_name(self.name) + pointer_suffix
  845. def c_unboxed_type(self):
  846. return c_name(self.name)
  847. def json_type(self):
  848. return 'object'
  849. def visit(self, visitor):
  850. visitor.visit_object_type(self.name, self.info,
  851. self.base, self.local_members, self.variants)
  852. visitor.visit_object_type_flat(self.name, self.info,
  853. self.members, self.variants)
  854. class QAPISchemaMember(object):
  855. role = 'member'
  856. def __init__(self, name):
  857. assert isinstance(name, str)
  858. self.name = name
  859. self.owner = None
  860. def set_owner(self, name):
  861. assert not self.owner
  862. self.owner = name
  863. def check_clash(self, info, seen):
  864. cname = c_name(self.name)
  865. if cname.lower() != cname and self.owner not in case_whitelist:
  866. raise QAPIExprError(info,
  867. "%s should not use uppercase" % self.describe())
  868. if cname in seen:
  869. raise QAPIExprError(info,
  870. "%s collides with %s"
  871. % (self.describe(), seen[cname].describe()))
  872. seen[cname] = self
  873. def _pretty_owner(self):
  874. owner = self.owner
  875. if owner.startswith('q_obj_'):
  876. # See QAPISchema._make_implicit_object_type() - reverse the
  877. # mapping there to create a nice human-readable description
  878. owner = owner[6:]
  879. if owner.endswith('-arg'):
  880. return '(parameter of %s)' % owner[:-4]
  881. else:
  882. assert owner.endswith('-wrapper')
  883. # Unreachable and not implemented
  884. assert False
  885. if owner.endswith('Kind'):
  886. # See QAPISchema._make_implicit_enum_type()
  887. return '(branch of %s)' % owner[:-4]
  888. return '(%s of %s)' % (self.role, owner)
  889. def describe(self):
  890. return "'%s' %s" % (self.name, self._pretty_owner())
  891. class QAPISchemaObjectTypeMember(QAPISchemaMember):
  892. def __init__(self, name, typ, optional):
  893. QAPISchemaMember.__init__(self, name)
  894. assert isinstance(typ, str)
  895. assert isinstance(optional, bool)
  896. self._type_name = typ
  897. self.type = None
  898. self.optional = optional
  899. def check(self, schema):
  900. assert self.owner
  901. self.type = schema.lookup_type(self._type_name)
  902. assert self.type
  903. class QAPISchemaObjectTypeVariants(object):
  904. def __init__(self, tag_name, tag_member, variants):
  905. # Flat unions pass tag_name but not tag_member.
  906. # Simple unions and alternates pass tag_member but not tag_name.
  907. # After check(), tag_member is always set, and tag_name remains
  908. # a reliable witness of being used by a flat union.
  909. assert bool(tag_member) != bool(tag_name)
  910. assert (isinstance(tag_name, str) or
  911. isinstance(tag_member, QAPISchemaObjectTypeMember))
  912. assert len(variants) > 0
  913. for v in variants:
  914. assert isinstance(v, QAPISchemaObjectTypeVariant)
  915. self.tag_name = tag_name
  916. self.tag_member = tag_member
  917. self.variants = variants
  918. def set_owner(self, name):
  919. for v in self.variants:
  920. v.set_owner(name)
  921. def check(self, schema, seen):
  922. if not self.tag_member: # flat union
  923. self.tag_member = seen[c_name(self.tag_name)]
  924. assert self.tag_name == self.tag_member.name
  925. assert isinstance(self.tag_member.type, QAPISchemaEnumType)
  926. for v in self.variants:
  927. v.check(schema)
  928. # Union names must match enum values; alternate names are
  929. # checked separately. Use 'seen' to tell the two apart.
  930. if seen:
  931. assert v.name in self.tag_member.type.member_names()
  932. assert isinstance(v.type, QAPISchemaObjectType)
  933. v.type.check(schema)
  934. def check_clash(self, schema, info, seen):
  935. for v in self.variants:
  936. # Reset seen map for each variant, since qapi names from one
  937. # branch do not affect another branch
  938. assert isinstance(v.type, QAPISchemaObjectType)
  939. v.type.check_clash(schema, info, dict(seen))
  940. class QAPISchemaObjectTypeVariant(QAPISchemaObjectTypeMember):
  941. role = 'branch'
  942. def __init__(self, name, typ):
  943. QAPISchemaObjectTypeMember.__init__(self, name, typ, False)
  944. class QAPISchemaAlternateType(QAPISchemaType):
  945. def __init__(self, name, info, variants):
  946. QAPISchemaType.__init__(self, name, info)
  947. assert isinstance(variants, QAPISchemaObjectTypeVariants)
  948. assert not variants.tag_name
  949. variants.set_owner(name)
  950. variants.tag_member.set_owner(self.name)
  951. self.variants = variants
  952. def check(self, schema):
  953. self.variants.tag_member.check(schema)
  954. # Not calling self.variants.check_clash(), because there's nothing
  955. # to clash with
  956. self.variants.check(schema, {})
  957. # Alternate branch names have no relation to the tag enum values;
  958. # so we have to check for potential name collisions ourselves.
  959. seen = {}
  960. for v in self.variants.variants:
  961. v.check_clash(self.info, seen)
  962. def c_type(self):
  963. return c_name(self.name) + pointer_suffix
  964. def json_type(self):
  965. return 'value'
  966. def visit(self, visitor):
  967. visitor.visit_alternate_type(self.name, self.info, self.variants)
  968. class QAPISchemaCommand(QAPISchemaEntity):
  969. def __init__(self, name, info, arg_type, ret_type, gen, success_response):
  970. QAPISchemaEntity.__init__(self, name, info)
  971. assert not arg_type or isinstance(arg_type, str)
  972. assert not ret_type or isinstance(ret_type, str)
  973. self._arg_type_name = arg_type
  974. self.arg_type = None
  975. self._ret_type_name = ret_type
  976. self.ret_type = None
  977. self.gen = gen
  978. self.success_response = success_response
  979. def check(self, schema):
  980. if self._arg_type_name:
  981. self.arg_type = schema.lookup_type(self._arg_type_name)
  982. assert isinstance(self.arg_type, QAPISchemaObjectType)
  983. assert not self.arg_type.variants # not implemented
  984. if self._ret_type_name:
  985. self.ret_type = schema.lookup_type(self._ret_type_name)
  986. assert isinstance(self.ret_type, QAPISchemaType)
  987. def visit(self, visitor):
  988. visitor.visit_command(self.name, self.info,
  989. self.arg_type, self.ret_type,
  990. self.gen, self.success_response)
  991. class QAPISchemaEvent(QAPISchemaEntity):
  992. def __init__(self, name, info, arg_type):
  993. QAPISchemaEntity.__init__(self, name, info)
  994. assert not arg_type or isinstance(arg_type, str)
  995. self._arg_type_name = arg_type
  996. self.arg_type = None
  997. def check(self, schema):
  998. if self._arg_type_name:
  999. self.arg_type = schema.lookup_type(self._arg_type_name)
  1000. assert isinstance(self.arg_type, QAPISchemaObjectType)
  1001. assert not self.arg_type.variants # not implemented
  1002. def visit(self, visitor):
  1003. visitor.visit_event(self.name, self.info, self.arg_type)
  1004. class QAPISchema(object):
  1005. def __init__(self, fname):
  1006. try:
  1007. self.exprs = check_exprs(QAPISchemaParser(open(fname, "r")).exprs)
  1008. self._entity_dict = {}
  1009. self._predefining = True
  1010. self._def_predefineds()
  1011. self._predefining = False
  1012. self._def_exprs()
  1013. self.check()
  1014. except (QAPISchemaError, QAPIExprError) as err:
  1015. print >>sys.stderr, err
  1016. exit(1)
  1017. def _def_entity(self, ent):
  1018. # Only the predefined types are allowed to not have info
  1019. assert ent.info or self._predefining
  1020. assert ent.name not in self._entity_dict
  1021. self._entity_dict[ent.name] = ent
  1022. def lookup_entity(self, name, typ=None):
  1023. ent = self._entity_dict.get(name)
  1024. if typ and not isinstance(ent, typ):
  1025. return None
  1026. return ent
  1027. def lookup_type(self, name):
  1028. return self.lookup_entity(name, QAPISchemaType)
  1029. def _def_builtin_type(self, name, json_type, c_type):
  1030. self._def_entity(QAPISchemaBuiltinType(name, json_type, c_type))
  1031. # TODO As long as we have QAPI_TYPES_BUILTIN to share multiple
  1032. # qapi-types.h from a single .c, all arrays of builtins must be
  1033. # declared in the first file whether or not they are used. Nicer
  1034. # would be to use lazy instantiation, while figuring out how to
  1035. # avoid compilation issues with multiple qapi-types.h.
  1036. self._make_array_type(name, None)
  1037. def _def_predefineds(self):
  1038. for t in [('str', 'string', 'char' + pointer_suffix),
  1039. ('number', 'number', 'double'),
  1040. ('int', 'int', 'int64_t'),
  1041. ('int8', 'int', 'int8_t'),
  1042. ('int16', 'int', 'int16_t'),
  1043. ('int32', 'int', 'int32_t'),
  1044. ('int64', 'int', 'int64_t'),
  1045. ('uint8', 'int', 'uint8_t'),
  1046. ('uint16', 'int', 'uint16_t'),
  1047. ('uint32', 'int', 'uint32_t'),
  1048. ('uint64', 'int', 'uint64_t'),
  1049. ('size', 'int', 'uint64_t'),
  1050. ('bool', 'boolean', 'bool'),
  1051. ('any', 'value', 'QObject' + pointer_suffix)]:
  1052. self._def_builtin_type(*t)
  1053. self.the_empty_object_type = QAPISchemaObjectType('q_empty', None,
  1054. None, [], None)
  1055. self._def_entity(self.the_empty_object_type)
  1056. qtype_values = self._make_enum_members(['none', 'qnull', 'qint',
  1057. 'qstring', 'qdict', 'qlist',
  1058. 'qfloat', 'qbool'])
  1059. self._def_entity(QAPISchemaEnumType('QType', None, qtype_values,
  1060. 'QTYPE'))
  1061. def _make_enum_members(self, values):
  1062. return [QAPISchemaMember(v) for v in values]
  1063. def _make_implicit_enum_type(self, name, info, values):
  1064. # See also QAPISchemaObjectTypeMember._pretty_owner()
  1065. name = name + 'Kind' # Use namespace reserved by add_name()
  1066. self._def_entity(QAPISchemaEnumType(
  1067. name, info, self._make_enum_members(values), None))
  1068. return name
  1069. def _make_array_type(self, element_type, info):
  1070. name = element_type + 'List' # Use namespace reserved by add_name()
  1071. if not self.lookup_type(name):
  1072. self._def_entity(QAPISchemaArrayType(name, info, element_type))
  1073. return name
  1074. def _make_implicit_object_type(self, name, info, role, members):
  1075. if not members:
  1076. return None
  1077. # See also QAPISchemaObjectTypeMember._pretty_owner()
  1078. name = 'q_obj_%s-%s' % (name, role)
  1079. if not self.lookup_entity(name, QAPISchemaObjectType):
  1080. self._def_entity(QAPISchemaObjectType(name, info, None,
  1081. members, None))
  1082. return name
  1083. def _def_enum_type(self, expr, info):
  1084. name = expr['enum']
  1085. data = expr['data']
  1086. prefix = expr.get('prefix')
  1087. self._def_entity(QAPISchemaEnumType(
  1088. name, info, self._make_enum_members(data), prefix))
  1089. def _make_member(self, name, typ, info):
  1090. optional = False
  1091. if name.startswith('*'):
  1092. name = name[1:]
  1093. optional = True
  1094. if isinstance(typ, list):
  1095. assert len(typ) == 1
  1096. typ = self._make_array_type(typ[0], info)
  1097. return QAPISchemaObjectTypeMember(name, typ, optional)
  1098. def _make_members(self, data, info):
  1099. return [self._make_member(key, value, info)
  1100. for (key, value) in data.iteritems()]
  1101. def _def_struct_type(self, expr, info):
  1102. name = expr['struct']
  1103. base = expr.get('base')
  1104. data = expr['data']
  1105. self._def_entity(QAPISchemaObjectType(name, info, base,
  1106. self._make_members(data, info),
  1107. None))
  1108. def _make_variant(self, case, typ):
  1109. return QAPISchemaObjectTypeVariant(case, typ)
  1110. def _make_simple_variant(self, case, typ, info):
  1111. if isinstance(typ, list):
  1112. assert len(typ) == 1
  1113. typ = self._make_array_type(typ[0], info)
  1114. typ = self._make_implicit_object_type(
  1115. typ, info, 'wrapper', [self._make_member('data', typ, info)])
  1116. return QAPISchemaObjectTypeVariant(case, typ)
  1117. def _def_union_type(self, expr, info):
  1118. name = expr['union']
  1119. data = expr['data']
  1120. base = expr.get('base')
  1121. tag_name = expr.get('discriminator')
  1122. tag_member = None
  1123. if tag_name:
  1124. variants = [self._make_variant(key, value)
  1125. for (key, value) in data.iteritems()]
  1126. members = []
  1127. else:
  1128. variants = [self._make_simple_variant(key, value, info)
  1129. for (key, value) in data.iteritems()]
  1130. typ = self._make_implicit_enum_type(name, info,
  1131. [v.name for v in variants])
  1132. tag_member = QAPISchemaObjectTypeMember('type', typ, False)
  1133. members = [tag_member]
  1134. self._def_entity(
  1135. QAPISchemaObjectType(name, info, base, members,
  1136. QAPISchemaObjectTypeVariants(tag_name,
  1137. tag_member,
  1138. variants)))
  1139. def _def_alternate_type(self, expr, info):
  1140. name = expr['alternate']
  1141. data = expr['data']
  1142. variants = [self._make_variant(key, value)
  1143. for (key, value) in data.iteritems()]
  1144. tag_member = QAPISchemaObjectTypeMember('type', 'QType', False)
  1145. self._def_entity(
  1146. QAPISchemaAlternateType(name, info,
  1147. QAPISchemaObjectTypeVariants(None,
  1148. tag_member,
  1149. variants)))
  1150. def _def_command(self, expr, info):
  1151. name = expr['command']
  1152. data = expr.get('data')
  1153. rets = expr.get('returns')
  1154. gen = expr.get('gen', True)
  1155. success_response = expr.get('success-response', True)
  1156. if isinstance(data, OrderedDict):
  1157. data = self._make_implicit_object_type(
  1158. name, info, 'arg', self._make_members(data, info))
  1159. if isinstance(rets, list):
  1160. assert len(rets) == 1
  1161. rets = self._make_array_type(rets[0], info)
  1162. self._def_entity(QAPISchemaCommand(name, info, data, rets, gen,
  1163. success_response))
  1164. def _def_event(self, expr, info):
  1165. name = expr['event']
  1166. data = expr.get('data')
  1167. if isinstance(data, OrderedDict):
  1168. data = self._make_implicit_object_type(
  1169. name, info, 'arg', self._make_members(data, info))
  1170. self._def_entity(QAPISchemaEvent(name, info, data))
  1171. def _def_exprs(self):
  1172. for expr_elem in self.exprs:
  1173. expr = expr_elem['expr']
  1174. info = expr_elem['info']
  1175. if 'enum' in expr:
  1176. self._def_enum_type(expr, info)
  1177. elif 'struct' in expr:
  1178. self._def_struct_type(expr, info)
  1179. elif 'union' in expr:
  1180. self._def_union_type(expr, info)
  1181. elif 'alternate' in expr:
  1182. self._def_alternate_type(expr, info)
  1183. elif 'command' in expr:
  1184. self._def_command(expr, info)
  1185. elif 'event' in expr:
  1186. self._def_event(expr, info)
  1187. else:
  1188. assert False
  1189. def check(self):
  1190. for ent in self._entity_dict.values():
  1191. ent.check(self)
  1192. def visit(self, visitor):
  1193. visitor.visit_begin(self)
  1194. for (name, entity) in sorted(self._entity_dict.items()):
  1195. if visitor.visit_needed(entity):
  1196. entity.visit(visitor)
  1197. visitor.visit_end()
  1198. #
  1199. # Code generation helpers
  1200. #
  1201. def camel_case(name):
  1202. new_name = ''
  1203. first = True
  1204. for ch in name:
  1205. if ch in ['_', '-']:
  1206. first = True
  1207. elif first:
  1208. new_name += ch.upper()
  1209. first = False
  1210. else:
  1211. new_name += ch.lower()
  1212. return new_name
  1213. # ENUMName -> ENUM_NAME, EnumName1 -> ENUM_NAME1
  1214. # ENUM_NAME -> ENUM_NAME, ENUM_NAME1 -> ENUM_NAME1, ENUM_Name2 -> ENUM_NAME2
  1215. # ENUM24_Name -> ENUM24_NAME
  1216. def camel_to_upper(value):
  1217. c_fun_str = c_name(value, False)
  1218. if value.isupper():
  1219. return c_fun_str
  1220. new_name = ''
  1221. l = len(c_fun_str)
  1222. for i in range(l):
  1223. c = c_fun_str[i]
  1224. # When c is upper and no "_" appears before, do more checks
  1225. if c.isupper() and (i > 0) and c_fun_str[i - 1] != "_":
  1226. if i < l - 1 and c_fun_str[i + 1].islower():
  1227. new_name += '_'
  1228. elif c_fun_str[i - 1].isdigit():
  1229. new_name += '_'
  1230. new_name += c
  1231. return new_name.lstrip('_').upper()
  1232. def c_enum_const(type_name, const_name, prefix=None):
  1233. if prefix is not None:
  1234. type_name = prefix
  1235. return camel_to_upper(type_name) + '_' + c_name(const_name, False).upper()
  1236. c_name_trans = string.maketrans('.-', '__')
  1237. # Map @name to a valid C identifier.
  1238. # If @protect, avoid returning certain ticklish identifiers (like
  1239. # C keywords) by prepending "q_".
  1240. #
  1241. # Used for converting 'name' from a 'name':'type' qapi definition
  1242. # into a generated struct member, as well as converting type names
  1243. # into substrings of a generated C function name.
  1244. # '__a.b_c' -> '__a_b_c', 'x-foo' -> 'x_foo'
  1245. # protect=True: 'int' -> 'q_int'; protect=False: 'int' -> 'int'
  1246. def c_name(name, protect=True):
  1247. # ANSI X3J11/88-090, 3.1.1
  1248. c89_words = set(['auto', 'break', 'case', 'char', 'const', 'continue',
  1249. 'default', 'do', 'double', 'else', 'enum', 'extern',
  1250. 'float', 'for', 'goto', 'if', 'int', 'long', 'register',
  1251. 'return', 'short', 'signed', 'sizeof', 'static',
  1252. 'struct', 'switch', 'typedef', 'union', 'unsigned',
  1253. 'void', 'volatile', 'while'])
  1254. # ISO/IEC 9899:1999, 6.4.1
  1255. c99_words = set(['inline', 'restrict', '_Bool', '_Complex', '_Imaginary'])
  1256. # ISO/IEC 9899:2011, 6.4.1
  1257. c11_words = set(['_Alignas', '_Alignof', '_Atomic', '_Generic',
  1258. '_Noreturn', '_Static_assert', '_Thread_local'])
  1259. # GCC http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/C-Extensions.html
  1260. # excluding _.*
  1261. gcc_words = set(['asm', 'typeof'])
  1262. # C++ ISO/IEC 14882:2003 2.11
  1263. cpp_words = set(['bool', 'catch', 'class', 'const_cast', 'delete',
  1264. 'dynamic_cast', 'explicit', 'false', 'friend', 'mutable',
  1265. 'namespace', 'new', 'operator', 'private', 'protected',
  1266. 'public', 'reinterpret_cast', 'static_cast', 'template',
  1267. 'this', 'throw', 'true', 'try', 'typeid', 'typename',
  1268. 'using', 'virtual', 'wchar_t',
  1269. # alternative representations
  1270. 'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
  1271. 'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
  1272. # namespace pollution:
  1273. polluted_words = set(['unix', 'errno', 'mips', 'sparc'])
  1274. name = name.translate(c_name_trans)
  1275. if protect and (name in c89_words | c99_words | c11_words | gcc_words
  1276. | cpp_words | polluted_words):
  1277. return "q_" + name
  1278. return name
  1279. eatspace = '\033EATSPACE.'
  1280. pointer_suffix = ' *' + eatspace
  1281. def genindent(count):
  1282. ret = ""
  1283. for _ in range(count):
  1284. ret += " "
  1285. return ret
  1286. indent_level = 0
  1287. def push_indent(indent_amount=4):
  1288. global indent_level
  1289. indent_level += indent_amount
  1290. def pop_indent(indent_amount=4):
  1291. global indent_level
  1292. indent_level -= indent_amount
  1293. # Generate @code with @kwds interpolated.
  1294. # Obey indent_level, and strip eatspace.
  1295. def cgen(code, **kwds):
  1296. raw = code % kwds
  1297. if indent_level:
  1298. indent = genindent(indent_level)
  1299. # re.subn() lacks flags support before Python 2.7, use re.compile()
  1300. raw = re.subn(re.compile("^.", re.MULTILINE),
  1301. indent + r'\g<0>', raw)
  1302. raw = raw[0]
  1303. return re.sub(re.escape(eatspace) + ' *', '', raw)
  1304. def mcgen(code, **kwds):
  1305. if code[0] == '\n':
  1306. code = code[1:]
  1307. return cgen(code, **kwds)
  1308. def guardname(filename):
  1309. return c_name(filename, protect=False).upper()
  1310. def guardstart(name):
  1311. return mcgen('''
  1312. #ifndef %(name)s
  1313. #define %(name)s
  1314. ''',
  1315. name=guardname(name))
  1316. def guardend(name):
  1317. return mcgen('''
  1318. #endif /* %(name)s */
  1319. ''',
  1320. name=guardname(name))
  1321. def gen_enum_lookup(name, values, prefix=None):
  1322. ret = mcgen('''
  1323. const char *const %(c_name)s_lookup[] = {
  1324. ''',
  1325. c_name=c_name(name))
  1326. for value in values:
  1327. index = c_enum_const(name, value, prefix)
  1328. ret += mcgen('''
  1329. [%(index)s] = "%(value)s",
  1330. ''',
  1331. index=index, value=value)
  1332. max_index = c_enum_const(name, '_MAX', prefix)
  1333. ret += mcgen('''
  1334. [%(max_index)s] = NULL,
  1335. };
  1336. ''',
  1337. max_index=max_index)
  1338. return ret
  1339. def gen_enum(name, values, prefix=None):
  1340. # append automatically generated _MAX value
  1341. enum_values = values + ['_MAX']
  1342. ret = mcgen('''
  1343. typedef enum %(c_name)s {
  1344. ''',
  1345. c_name=c_name(name))
  1346. i = 0
  1347. for value in enum_values:
  1348. ret += mcgen('''
  1349. %(c_enum)s = %(i)d,
  1350. ''',
  1351. c_enum=c_enum_const(name, value, prefix),
  1352. i=i)
  1353. i += 1
  1354. ret += mcgen('''
  1355. } %(c_name)s;
  1356. ''',
  1357. c_name=c_name(name))
  1358. ret += mcgen('''
  1359. extern const char *const %(c_name)s_lookup[];
  1360. ''',
  1361. c_name=c_name(name))
  1362. return ret
  1363. def gen_params(arg_type, extra):
  1364. if not arg_type:
  1365. return extra
  1366. assert not arg_type.variants
  1367. ret = ''
  1368. sep = ''
  1369. for memb in arg_type.members:
  1370. ret += sep
  1371. sep = ', '
  1372. if memb.optional:
  1373. ret += 'bool has_%s, ' % c_name(memb.name)
  1374. ret += '%s %s' % (memb.type.c_param_type(), c_name(memb.name))
  1375. if extra:
  1376. ret += sep + extra
  1377. return ret
  1378. def gen_err_check():
  1379. return mcgen('''
  1380. if (err) {
  1381. goto out;
  1382. }
  1383. ''')
  1384. #
  1385. # Common command line parsing
  1386. #
  1387. def parse_command_line(extra_options="", extra_long_options=[]):
  1388. try:
  1389. opts, args = getopt.gnu_getopt(sys.argv[1:],
  1390. "chp:o:" + extra_options,
  1391. ["source", "header", "prefix=",
  1392. "output-dir="] + extra_long_options)
  1393. except getopt.GetoptError as err:
  1394. print >>sys.stderr, "%s: %s" % (sys.argv[0], str(err))
  1395. sys.exit(1)
  1396. output_dir = ""
  1397. prefix = ""
  1398. do_c = False
  1399. do_h = False
  1400. extra_opts = []
  1401. for oa in opts:
  1402. o, a = oa
  1403. if o in ("-p", "--prefix"):
  1404. match = re.match('([A-Za-z_.-][A-Za-z0-9_.-]*)?', a)
  1405. if match.end() != len(a):
  1406. print >>sys.stderr, \
  1407. "%s: 'funny character '%s' in argument of --prefix" \
  1408. % (sys.argv[0], a[match.end()])
  1409. sys.exit(1)
  1410. prefix = a
  1411. elif o in ("-o", "--output-dir"):
  1412. output_dir = a + "/"
  1413. elif o in ("-c", "--source"):
  1414. do_c = True
  1415. elif o in ("-h", "--header"):
  1416. do_h = True
  1417. else:
  1418. extra_opts.append(oa)
  1419. if not do_c and not do_h:
  1420. do_c = True
  1421. do_h = True
  1422. if len(args) != 1:
  1423. print >>sys.stderr, "%s: need exactly one argument" % sys.argv[0]
  1424. sys.exit(1)
  1425. fname = args[0]
  1426. return (fname, output_dir, do_c, do_h, prefix, extra_opts)
  1427. #
  1428. # Generate output files with boilerplate
  1429. #
  1430. def open_output(output_dir, do_c, do_h, prefix, c_file, h_file,
  1431. c_comment, h_comment):
  1432. guard = guardname(prefix + h_file)
  1433. c_file = output_dir + prefix + c_file
  1434. h_file = output_dir + prefix + h_file
  1435. if output_dir:
  1436. try:
  1437. os.makedirs(output_dir)
  1438. except os.error as e:
  1439. if e.errno != errno.EEXIST:
  1440. raise
  1441. def maybe_open(really, name, opt):
  1442. if really:
  1443. return open(name, opt)
  1444. else:
  1445. import StringIO
  1446. return StringIO.StringIO()
  1447. fdef = maybe_open(do_c, c_file, 'w')
  1448. fdecl = maybe_open(do_h, h_file, 'w')
  1449. fdef.write(mcgen('''
  1450. /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
  1451. %(comment)s
  1452. ''',
  1453. comment=c_comment))
  1454. fdecl.write(mcgen('''
  1455. /* AUTOMATICALLY GENERATED, DO NOT MODIFY */
  1456. %(comment)s
  1457. #ifndef %(guard)s
  1458. #define %(guard)s
  1459. ''',
  1460. comment=h_comment, guard=guard))
  1461. return (fdef, fdecl)
  1462. def close_output(fdef, fdecl):
  1463. fdecl.write('''
  1464. #endif
  1465. ''')
  1466. fdecl.close()
  1467. fdef.close()