2
0

qapi.py 54 KB

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