qapi.py 71 KB

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