src/tools/vppapigen/vppapigen.py

   1 #!/usr/bin/env python3
   2
   3 import ply.lex as lex
   4 import ply.yacc as yacc
   5 import sys
   6 import argparse
   7 import keyword
   8 import logging
   9 import binascii
  10 import os
  11 import sys
  12 from subprocess import Popen, PIPE
  13
  14 assert sys.version_info >= (3, 6), \
  15     "Not supported Python version: {}".format(sys.version)
  16 log = logging.getLogger('vppapigen')
  17
  18 # Ensure we don't leave temporary files around
  19 sys.dont_write_bytecode = True
  20
  21 #
  22 # VPP API language
  23 #
  24
  25 # Global dictionary of new types (including enums)
  26 global_types = {}
  27
  28 seen_imports = {}
  29
  30
  31 def global_type_add(name, obj):
  32     '''Add new type to the dictionary of types '''
  33     type_name = 'vl_api_' + name + '_t'
  34     if type_name in global_types:
  35         raise KeyError("Attempted redefinition of {!r} with {!r}.".format(
  36             name, obj))
  37     global_types[type_name] = obj
  38
  39
  40 # All your trace are belong to us!
  41 def exception_handler(exception_type, exception, traceback):
  42     print("%s: %s" % (exception_type.__name__, exception))
  43
  44
  45 #
  46 # Lexer
  47 #
  48 class VPPAPILexer(object):
  49     def __init__(self, filename):
  50         self.filename = filename
  51
  52     reserved = {
  53         'service': 'SERVICE',
  54         'rpc': 'RPC',
  55         'returns': 'RETURNS',
  56         'null': 'NULL',
  57         'stream': 'STREAM',
  58         'events': 'EVENTS',
  59         'define': 'DEFINE',
  60         'typedef': 'TYPEDEF',
  61         'enum': 'ENUM',
  62         'typeonly': 'TYPEONLY',
  63         'manual_print': 'MANUAL_PRINT',
  64         'manual_endian': 'MANUAL_ENDIAN',
  65         'dont_trace': 'DONT_TRACE',
  66         'autoreply': 'AUTOREPLY',
  67         'option': 'OPTION',
  68         'u8': 'U8',
  69         'u16': 'U16',
  70         'u32': 'U32',
  71         'u64': 'U64',
  72         'i8': 'I8',
  73         'i16': 'I16',
  74         'i32': 'I32',
  75         'i64': 'I64',
  76         'f64': 'F64',
  77         'bool': 'BOOL',
  78         'string': 'STRING',
  79         'import': 'IMPORT',
  80         'true': 'TRUE',
  81         'false': 'FALSE',
  82         'union': 'UNION',
  83     }
  84
  85     tokens = ['STRING_LITERAL',
  86               'ID', 'NUM'] + list(reserved.values())
  87
  88     t_ignore_LINE_COMMENT = '//.*'
  89
  90     def t_FALSE(self, t):
  91         r'false'
  92         t.value = False
  93         return t
  94
  95     def t_TRUE(self, t):
  96         r'false'
  97         t.value = True
  98         return t
  99
 100     def t_NUM(self, t):
 101         r'0[xX][0-9a-fA-F]+|-?\d+\.?\d*'
 102         base = 16 if t.value.startswith('0x') else 10
 103         if '.' in t.value:
 104             t.value = float(t.value)
 105         else:
 106             t.value = int(t.value, base)
 107         return t
 108
 109     def t_ID(self, t):
 110         r'[a-zA-Z_][a-zA-Z_0-9]*'
 111         # Check for reserved words
 112         t.type = VPPAPILexer.reserved.get(t.value, 'ID')
 113         return t
 114
 115     # C string
 116     def t_STRING_LITERAL(self, t):
 117         r'\"([^\\\n]|(\\.))*?\"'
 118         t.value = str(t.value).replace("\"", "")
 119         return t
 120
 121     # C or C++ comment (ignore)
 122     def t_comment(self, t):
 123         r'(/\*(.|\n)*?\*/)|(//.*)'
 124         t.lexer.lineno += t.value.count('\n')
 125
 126     # Error handling rule
 127     def t_error(self, t):
 128         raise ParseError("Illegal character '{}' ({})"
 129                          "in {}: line {}".format(t.value[0],
 130                                                  hex(ord(t.value[0])),
 131                                                  self.filename,
 132                                                  t.lexer.lineno))
 133         t.lexer.skip(1)
 134
 135     # Define a rule so we can track line numbers
 136     def t_newline(self, t):
 137         r'\n+'
 138         t.lexer.lineno += len(t.value)
 139
 140     literals = ":{}[];=.,"
 141
 142     # A string containing ignored characters (spaces and tabs)
 143     t_ignore = ' \t'
 144
 145
 146 def crc_block_combine(block, crc):
 147     s = str(block).encode()
 148     return binascii.crc32(s, crc) & 0xffffffff
 149
 150
 151 def vla_is_last_check(name, block):
 152     vla = False
 153     for i, b in enumerate(block):
 154         if isinstance(b, Array) and b.vla:
 155             vla = True
 156             if i + 1 < len(block):
 157                 raise ValueError(
 158                     'VLA field "{}" must be the last field in message "{}"'
 159                     .format(b.fieldname, name))
 160         elif b.fieldtype.startswith('vl_api_'):
 161             if global_types[b.fieldtype].vla:
 162                 vla = True
 163                 if i + 1 < len(block):
 164                     raise ValueError(
 165                         'VLA field "{}" must be the last '
 166                         'field in message "{}"'
 167                         .format(b.fieldname, name))
 168         elif b.fieldtype == 'string' and b.length == 0:
 169             vla = True
 170             if i + 1 < len(block):
 171                 raise ValueError(
 172                     'VLA field "{}" must be the last '
 173                     'field in message "{}"'
 174                     .format(b.fieldname, name))
 175     return vla
 176
 177
 178 class Service():
 179     def __init__(self, caller, reply, events=None, stream=False):
 180         self.caller = caller
 181         self.reply = reply
 182         self.stream = stream
 183         self.events = [] if events is None else events
 184
 185
 186 class Typedef():
 187     def __init__(self, name, flags, block):
 188         self.name = name
 189         self.flags = flags
 190         self.block = block
 191         self.crc = str(block).encode()
 192         self.manual_print = False
 193         self.manual_endian = False
 194         for f in flags:
 195             if f == 'manual_print':
 196                 self.manual_print = True
 197             elif f == 'manual_endian':
 198                 self.manual_endian = True
 199
 200         global_type_add(name, self)
 201
 202         self.vla = vla_is_last_check(name, block)
 203
 204     def __repr__(self):
 205         return self.name + str(self.flags) + str(self.block)
 206
 207
 208 class Using():
 209     def __init__(self, name, flags, alias):
 210         self.name = name
 211         self.vla = False
 212         self.block = []
 213         self.manual_print = True
 214         self.manual_endian = True
 215
 216         self.manual_print = False
 217         self.manual_endian = False
 218         for f in flags:
 219             if f == 'manual_print':
 220                 self.manual_print = True
 221             elif f == 'manual_endian':
 222                 self.manual_endian = True
 223
 224         if isinstance(alias, Array):
 225             a = {'type': alias.fieldtype,
 226                  'length': alias.length}
 227         else:
 228             a = {'type': alias.fieldtype}
 229         self.alias = a
 230         self.crc = str(alias).encode()
 231         global_type_add(name, self)
 232
 233     def __repr__(self):
 234         return self.name + str(self.alias)
 235
 236
 237 class Union():
 238     def __init__(self, name, flags, block):
 239         self.type = 'Union'
 240         self.manual_print = False
 241         self.manual_endian = False
 242         self.name = name
 243
 244         for f in flags:
 245             if f == 'manual_print':
 246                 self.manual_print = True
 247             elif f == 'manual_endian':
 248                 self.manual_endian = True
 249
 250         self.block = block
 251         self.crc = str(block).encode()
 252         self.vla = vla_is_last_check(name, block)
 253
 254         global_type_add(name, self)
 255
 256     def __repr__(self):
 257         return str(self.block)
 258
 259
 260 class Define():
 261     def __init__(self, name, flags, block):
 262         self.name = name
 263         self.flags = flags
 264         self.block = block
 265         self.dont_trace = False
 266         self.manual_print = False
 267         self.manual_endian = False
 268         self.autoreply = False
 269         self.singular = False
 270         self.options = {}
 271         for f in flags:
 272             if f == 'dont_trace':
 273                 self.dont_trace = True
 274             elif f == 'manual_print':
 275                 self.manual_print = True
 276             elif f == 'manual_endian':
 277                 self.manual_endian = True
 278             elif f == 'autoreply':
 279                 self.autoreply = True
 280
 281         remove = []
 282         for b in block:
 283             if isinstance(b, Option):
 284                 if b[1] == 'singular' and b[2] == 'true':
 285                     self.singular = True
 286                 else:
 287                     self.options[b.option] = b.value
 288                 remove.append(b)
 289
 290         block = [x for x in block if x not in remove]
 291         self.block = block
 292         self.vla = vla_is_last_check(name, block)
 293         self.crc = str(block).encode()
 294
 295     def __repr__(self):
 296         return self.name + str(self.flags) + str(self.block)
 297
 298
 299 class Enum():
 300     def __init__(self, name, block, enumtype='u32'):
 301         self.name = name
 302         self.enumtype = enumtype
 303         self.vla = False
 304
 305         count = 0
 306         for i, b in enumerate(block):
 307             if type(b) is list:
 308                 count = b[1]
 309             else:
 310                 count += 1
 311                 block[i] = [b, count]
 312
 313         self.block = block
 314         self.crc = str(block).encode()
 315         global_type_add(name, self)
 316
 317     def __repr__(self):
 318         return self.name + str(self.block)
 319
 320
 321 class Import():
 322
 323     def __new__(cls, *args, **kwargs):
 324         if args[0] not in seen_imports:
 325             instance = super().__new__(cls)
 326             instance._initialized = False
 327             seen_imports[args[0]] = instance
 328
 329         return seen_imports[args[0]]
 330
 331     def __init__(self, filename, revision):
 332         if self._initialized:
 333             return
 334         else:
 335             self.filename = filename
 336             # Deal with imports
 337             parser = VPPAPI(filename=filename, revision=revision)
 338             dirlist = dirlist_get()
 339             f = filename
 340             for dir in dirlist:
 341                 f = os.path.join(dir, filename)
 342                 if os.path.exists(f):
 343                     break
 344             self.result = parser.parse_filename(f, None)
 345             self._initialized = True
 346
 347     def __repr__(self):
 348         return self.filename
 349
 350
 351 class Option():
 352     def __init__(self, option, value):
 353         self.type = 'Option'
 354         self.option = option
 355         self.value = value
 356         self.crc = str(option).encode()
 357
 358     def __repr__(self):
 359         return str(self.option)
 360
 361     def __getitem__(self, index):
 362         return self.option[index]
 363
 364
 365 class Array():
 366     def __init__(self, fieldtype, name, length, modern_vla=False):
 367         self.type = 'Array'
 368         self.fieldtype = fieldtype
 369         self.fieldname = name
 370         self.modern_vla = modern_vla
 371         if type(length) is str:
 372             self.lengthfield = length
 373             self.length = 0
 374             self.vla = True
 375         else:
 376             self.length = length
 377             self.lengthfield = None
 378             self.vla = False
 379
 380     def __repr__(self):
 381         return str([self.fieldtype, self.fieldname, self.length,
 382                     self.lengthfield])
 383
 384
 385 class Field():
 386     def __init__(self, fieldtype, name, limit=None):
 387         self.type = 'Field'
 388         self.fieldtype = fieldtype
 389
 390         if self.fieldtype == 'string':
 391             raise ValueError("The string type {!r} is an "
 392                              "array type ".format(name))
 393
 394         if name in keyword.kwlist:
 395             raise ValueError("Fieldname {!r} is a python keyword and is not "
 396                              "accessible via the python API. ".format(name))
 397         self.fieldname = name
 398         self.limit = limit
 399
 400     def __repr__(self):
 401         return str([self.fieldtype, self.fieldname])
 402
 403
 404 class Coord(object):
 405     """ Coordinates of a syntactic element. Consists of:
 406             - File name
 407             - Line number
 408             - (optional) column number, for the Lexer
 409     """
 410     __slots__ = ('file', 'line', 'column', '__weakref__')
 411
 412     def __init__(self, file, line, column=None):
 413         self.file = file
 414         self.line = line
 415         self.column = column
 416
 417     def __str__(self):
 418         str = "%s:%s" % (self.file, self.line)
 419         if self.column:
 420             str += ":%s" % self.column
 421         return str
 422
 423
 424 class ParseError(Exception):
 425     pass
 426
 427
 428 #
 429 # Grammar rules
 430 #
 431 class VPPAPIParser(object):
 432     tokens = VPPAPILexer.tokens
 433
 434     def __init__(self, filename, logger, revision=None):
 435         self.filename = filename
 436         self.logger = logger
 437         self.fields = []
 438         self.revision = revision
 439
 440     def _parse_error(self, msg, coord):
 441         raise ParseError("%s: %s" % (coord, msg))
 442
 443     def _parse_warning(self, msg, coord):
 444         if self.logger:
 445             self.logger.warning("%s: %s" % (coord, msg))
 446
 447     def _coord(self, lineno, column=None):
 448         return Coord(
 449                 file=self.filename,
 450                 line=lineno, column=column)
 451
 452     def _token_coord(self, p, token_idx):
 453         """ Returns the coordinates for the YaccProduction object 'p' indexed
 454             with 'token_idx'. The coordinate includes the 'lineno' and
 455             'column'. Both follow the lex semantic, starting from 1.
 456         """
 457         last_cr = p.lexer.lexdata.rfind('\n', 0, p.lexpos(token_idx))
 458         if last_cr < 0:
 459             last_cr = -1
 460         column = (p.lexpos(token_idx) - (last_cr))
 461         return self._coord(p.lineno(token_idx), column)
 462
 463     def p_slist(self, p):
 464         '''slist : stmt
 465                  | slist stmt'''
 466         if len(p) == 2:
 467             p[0] = [p[1]]
 468         else:
 469             p[0] = p[1] + [p[2]]
 470
 471     def p_stmt(self, p):
 472         '''stmt : define
 473                 | typedef
 474                 | option
 475                 | import
 476                 | enum
 477                 | union
 478                 | service'''
 479         p[0] = p[1]
 480
 481     def p_import(self, p):
 482         '''import : IMPORT STRING_LITERAL ';' '''
 483         p[0] = Import(p[2], revision=self.revision)
 484
 485     def p_service(self, p):
 486         '''service : SERVICE '{' service_statements '}' ';' '''
 487         p[0] = p[3]
 488
 489     def p_service_statements(self, p):
 490         '''service_statements : service_statement
 491                         | service_statements service_statement'''
 492         if len(p) == 2:
 493             p[0] = [p[1]]
 494         else:
 495             p[0] = p[1] + [p[2]]
 496
 497     def p_service_statement(self, p):
 498         '''service_statement : RPC ID RETURNS NULL ';'
 499                              | RPC ID RETURNS ID ';'
 500                              | RPC ID RETURNS STREAM ID ';'
 501                              | RPC ID RETURNS ID EVENTS event_list ';' '''
 502         if p[2] == p[4]:
 503             # Verify that caller and reply differ
 504             self._parse_error(
 505                 'Reply ID ({}) should not be equal to Caller ID'.format(p[2]),
 506                 self._token_coord(p, 1))
 507         if len(p) == 8:
 508             p[0] = Service(p[2], p[4], p[6])
 509         elif len(p) == 7:
 510             p[0] = Service(p[2], p[5], stream=True)
 511         else:
 512             p[0] = Service(p[2], p[4])
 513
 514     def p_event_list(self, p):
 515         '''event_list : events
 516                       | event_list events '''
 517         if len(p) == 2:
 518             p[0] = [p[1]]
 519         else:
 520             p[0] = p[1] + [p[2]]
 521
 522     def p_event(self, p):
 523         '''events : ID
 524                   | ID ',' '''
 525         p[0] = p[1]
 526
 527     def p_enum(self, p):
 528         '''enum : ENUM ID '{' enum_statements '}' ';' '''
 529         p[0] = Enum(p[2], p[4])
 530
 531     def p_enum_type(self, p):
 532         ''' enum : ENUM ID ':' enum_size '{' enum_statements '}' ';' '''
 533         if len(p) == 9:
 534             p[0] = Enum(p[2], p[6], enumtype=p[4])
 535         else:
 536             p[0] = Enum(p[2], p[4])
 537
 538     def p_enum_size(self, p):
 539         ''' enum_size : U8
 540                       | U16
 541                       | U32 '''
 542         p[0] = p[1]
 543
 544     def p_define(self, p):
 545         '''define : DEFINE ID '{' block_statements_opt '}' ';' '''
 546         self.fields = []
 547         p[0] = Define(p[2], [], p[4])
 548
 549     def p_define_flist(self, p):
 550         '''define : flist DEFINE ID '{' block_statements_opt '}' ';' '''
 551         # Legacy typedef
 552         if 'typeonly' in p[1]:
 553             self._parse_error('legacy typedef. use typedef: {} {}[{}];'
 554                               .format(p[1], p[2], p[4]),
 555                               self._token_coord(p, 1))
 556         else:
 557             p[0] = Define(p[3], p[1], p[5])
 558
 559     def p_flist(self, p):
 560         '''flist : flag
 561                  | flist flag'''
 562         if len(p) == 2:
 563             p[0] = [p[1]]
 564         else:
 565             p[0] = p[1] + [p[2]]
 566
 567     def p_flag(self, p):
 568         '''flag : MANUAL_PRINT
 569                 | MANUAL_ENDIAN
 570                 | DONT_TRACE
 571                 | TYPEONLY
 572                 | AUTOREPLY'''
 573         if len(p) == 1:
 574             return
 575         p[0] = p[1]
 576
 577     def p_typedef(self, p):
 578         '''typedef : TYPEDEF ID '{' block_statements_opt '}' ';' '''
 579         p[0] = Typedef(p[2], [], p[4])
 580
 581     def p_typedef_flist(self, p):
 582         '''typedef : flist TYPEDEF ID '{' block_statements_opt '}' ';' '''
 583         p[0] = Typedef(p[3], p[1], p[5])
 584
 585     def p_typedef_alias(self, p):
 586         '''typedef : TYPEDEF declaration '''
 587         p[0] = Using(p[2].fieldname, [], p[2])
 588
 589     def p_typedef_alias_flist(self, p):
 590         '''typedef : flist TYPEDEF declaration '''
 591         p[0] = Using(p[3].fieldname, p[1], p[3])
 592
 593     def p_block_statements_opt(self, p):
 594         '''block_statements_opt : block_statements '''
 595         p[0] = p[1]
 596
 597     def p_block_statements(self, p):
 598         '''block_statements : block_statement
 599                             | block_statements block_statement'''
 600         if len(p) == 2:
 601             p[0] = [p[1]]
 602         else:
 603             p[0] = p[1] + [p[2]]
 604
 605     def p_block_statement(self, p):
 606         '''block_statement : declaration
 607                            | option '''
 608         p[0] = p[1]
 609
 610     def p_enum_statements(self, p):
 611         '''enum_statements : enum_statement
 612                            | enum_statements enum_statement'''
 613         if len(p) == 2:
 614             p[0] = [p[1]]
 615         else:
 616             p[0] = p[1] + [p[2]]
 617
 618     def p_enum_statement(self, p):
 619         '''enum_statement : ID '=' NUM ','
 620                           | ID ',' '''
 621         if len(p) == 5:
 622             p[0] = [p[1], p[3]]
 623         else:
 624             p[0] = p[1]
 625
 626     def p_field_options(self, p):
 627         '''field_options : field_option
 628                            | field_options field_option'''
 629         if len(p) == 2:
 630             p[0] = p[1]
 631         else:
 632             p[0] = {**p[1], **p[2]}
 633
 634     def p_field_option(self, p):
 635         '''field_option : ID
 636                         | ID '=' assignee ','
 637                         | ID '=' assignee
 638
 639         '''
 640         if len(p) == 2:
 641             p[0] = {p[1]: None}
 642         else:
 643             p[0] = {p[1]: p[3]}
 644
 645     def p_declaration(self, p):
 646         '''declaration : type_specifier ID ';'
 647                        | type_specifier ID '[' field_options ']' ';' '''
 648         if len(p) == 7:
 649             p[0] = Field(p[1], p[2], p[4])
 650         elif len(p) == 4:
 651             p[0] = Field(p[1], p[2])
 652         else:
 653             self._parse_error('ERROR', self._token_coord(p, 1))
 654         self.fields.append(p[2])
 655
 656     def p_declaration_array_vla(self, p):
 657         '''declaration : type_specifier ID '[' ']' ';' '''
 658         p[0] = Array(p[1], p[2], 0, modern_vla=True)
 659
 660     def p_declaration_array(self, p):
 661         '''declaration : type_specifier ID '[' NUM ']' ';'
 662                        | type_specifier ID '[' ID ']' ';' '''
 663
 664         if len(p) != 7:
 665             return self._parse_error(
 666                 'array: %s' % p.value,
 667                 self._coord(lineno=p.lineno))
 668
 669         # Make this error later
 670         if type(p[4]) is int and p[4] == 0:
 671             # XXX: Line number is wrong
 672             self._parse_warning('Old Style VLA: {} {}[{}];'
 673                                 .format(p[1], p[2], p[4]),
 674                                 self._token_coord(p, 1))
 675
 676         if type(p[4]) is str and p[4] not in self.fields:
 677             # Verify that length field exists
 678             self._parse_error('Missing length field: {} {}[{}];'
 679                               .format(p[1], p[2], p[4]),
 680                               self._token_coord(p, 1))
 681         p[0] = Array(p[1], p[2], p[4])
 682
 683     def p_option(self, p):
 684         '''option : OPTION ID '=' assignee ';' '''
 685         p[0] = Option(p[2], p[4])
 686
 687     def p_assignee(self, p):
 688         '''assignee : NUM
 689                     | TRUE
 690                     | FALSE
 691                     | STRING_LITERAL '''
 692         p[0] = p[1]
 693
 694     def p_type_specifier(self, p):
 695         '''type_specifier : U8
 696                           | U16
 697                           | U32
 698                           | U64
 699                           | I8
 700                           | I16
 701                           | I32
 702                           | I64
 703                           | F64
 704                           | BOOL
 705                           | STRING'''
 706         p[0] = p[1]
 707
 708     # Do a second pass later to verify that user defined types are defined
 709     def p_typedef_specifier(self, p):
 710         '''type_specifier : ID '''
 711         if p[1] not in global_types:
 712             self._parse_error('Undefined type: {}'.format(p[1]),
 713                               self._token_coord(p, 1))
 714         p[0] = p[1]
 715
 716     def p_union(self, p):
 717         '''union : UNION ID '{' block_statements_opt '}' ';' '''
 718         p[0] = Union(p[2], [], p[4])
 719
 720     def p_union_flist(self, p):
 721         '''union : flist UNION ID '{' block_statements_opt '}' ';' '''
 722         p[0] = Union(p[3], p[1], p[5])
 723
 724     # Error rule for syntax errors
 725     def p_error(self, p):
 726         if p:
 727             self._parse_error(
 728                 'before: %s' % p.value,
 729                 self._coord(lineno=p.lineno))
 730         else:
 731             self._parse_error('At end of input', self.filename)
 732
 733
 734 class VPPAPI(object):
 735
 736     def __init__(self, debug=False, filename='', logger=None, revision=None):
 737         self.lexer = lex.lex(module=VPPAPILexer(filename), debug=debug)
 738         self.parser = yacc.yacc(module=VPPAPIParser(filename, logger,
 739                                                     revision=revision),
 740                                 write_tables=False, debug=debug)
 741         self.logger = logger
 742         self.revision = revision
 743         self.filename = filename
 744
 745     def parse_string(self, code, debug=0, lineno=1):
 746         self.lexer.lineno = lineno
 747         return self.parser.parse(code, lexer=self.lexer, debug=debug)
 748
 749     def parse_fd(self, fd, debug=0):
 750         data = fd.read()
 751         return self.parse_string(data, debug=debug)
 752
 753     def parse_filename(self, filename, debug=0):
 754         if self.revision:
 755             git_show = f'git show  {self.revision}:{filename}'
 756             proc = Popen(git_show.split(), stdout=PIPE, encoding='utf-8')
 757             try:
 758                 data, errs = proc.communicate()
 759                 if proc.returncode != 0:
 760                     print(f'File not found: {self.revision}:{filename}', file=sys.stderr)
 761                     sys.exit(2)
 762                 return self.parse_string(data, debug=debug)
 763             except Exception as e:
 764                 sys.exit(3)
 765         else:
 766             try:
 767                 with open(filename, encoding='utf-8') as fd:
 768                     return self.parse_fd(fd, None)
 769             except FileNotFoundError:
 770                 print(f'File not found: {filename}', file=sys.stderr)
 771                 sys.exit(2)
 772
 773     def autoreply_block(self, name, parent):
 774         block = [Field('u32', 'context'),
 775                  Field('i32', 'retval')]
 776         # inherhit the parent's options
 777         for k, v in parent.options.items():
 778             block.append(Option(k, v))
 779         return Define(name + '_reply', [], block)
 780
 781     def process(self, objs):
 782         s = {}
 783         s['Option'] = {}
 784         s['Define'] = []
 785         s['Service'] = []
 786         s['types'] = []
 787         s['Import'] = []
 788         crc = 0
 789         for o in objs:
 790             tname = o.__class__.__name__
 791             try:
 792                 crc = binascii.crc32(o.crc, crc) & 0xffffffff
 793             except AttributeError:
 794                 pass
 795             if isinstance(o, Define):
 796                 s[tname].append(o)
 797                 if o.autoreply:
 798                     s[tname].append(self.autoreply_block(o.name, o))
 799             elif isinstance(o, Option):
 800                 s[tname][o.option] = o.value
 801             elif type(o) is list:
 802                 for o2 in o:
 803                     if isinstance(o2, Service):
 804                         s['Service'].append(o2)
 805             elif (isinstance(o, Enum) or
 806                   isinstance(o, Typedef) or
 807                   isinstance(o, Using) or
 808                   isinstance(o, Union)):
 809                 s['types'].append(o)
 810             else:
 811                 if tname not in s:
 812                     raise ValueError('Unknown class type: {} {}'
 813                                      .format(tname, o))
 814                 s[tname].append(o)
 815
 816         msgs = {d.name: d for d in s['Define']}
 817         svcs = {s.caller: s for s in s['Service']}
 818         replies = {s.reply: s for s in s['Service']}
 819         seen_services = {}
 820
 821         s['file_crc'] = crc
 822
 823         for service in svcs:
 824             if service not in msgs:
 825                 raise ValueError(
 826                     'Service definition refers to unknown message'
 827                     ' definition: {}'.format(service))
 828             if svcs[service].reply != 'null' and \
 829                svcs[service].reply not in msgs:
 830                 raise ValueError('Service definition refers to unknown message'
 831                                  ' definition in reply: {}'
 832                                  .format(svcs[service].reply))
 833             if service in replies:
 834                 raise ValueError('Service definition refers to message'
 835                                  ' marked as reply: {}'.format(service))
 836             for event in svcs[service].events:
 837                 if event not in msgs:
 838                     raise ValueError('Service definition refers to unknown '
 839                                      'event: {} in message: {}'
 840                                      .format(event, service))
 841                 seen_services[event] = True
 842
 843         # Create services implicitly
 844         for d in msgs:
 845             if d in seen_services:
 846                 continue
 847             if msgs[d].singular is True:
 848                 continue
 849             if d.endswith('_reply'):
 850                 if d[:-6] in svcs:
 851                     continue
 852                 if d[:-6] not in msgs:
 853                     raise ValueError('{} missing calling message'
 854                                      .format(d))
 855                 continue
 856             if d.endswith('_dump'):
 857                 if d in svcs:
 858                     continue
 859                 if d[:-5]+'_details' in msgs:
 860                     s['Service'].append(Service(d, d[:-5]+'_details',
 861                                                 stream=True))
 862                 else:
 863                     raise ValueError('{} missing details message'
 864                                      .format(d))
 865                 continue
 866
 867             if d.endswith('_details'):
 868                 if d[:-8]+'_dump' not in msgs:
 869                     raise ValueError('{} missing dump message'
 870                                      .format(d))
 871                 continue
 872
 873             if d in svcs:
 874                 continue
 875             if d+'_reply' in msgs:
 876                 s['Service'].append(Service(d, d+'_reply'))
 877             else:
 878                 raise ValueError(
 879                     '{} missing reply message ({}) or service definition'
 880                     .format(d, d+'_reply'))
 881
 882         return s
 883
 884     def process_imports(self, objs, in_import, result):
 885         imported_objs = []
 886         for o in objs:
 887             # Only allow the following object types from imported file
 888             if in_import and not (isinstance(o, Enum) or
 889                                   isinstance(o, Union) or
 890                                   isinstance(o, Typedef) or
 891                                   isinstance(o, Import) or
 892                                   isinstance(o, Using)):
 893                 continue
 894             if isinstance(o, Import):
 895                 result.append(o)
 896                 result = self.process_imports(o.result, True, result)
 897             else:
 898                 result.append(o)
 899         return result
 900
 901
 902 # Add message ids to each message.
 903 def add_msg_id(s):
 904     for o in s:
 905         o.block.insert(0, Field('u16', '_vl_msg_id'))
 906     return s
 907
 908
 909 dirlist = []
 910
 911
 912 def dirlist_add(dirs):
 913     global dirlist
 914     if dirs:
 915         dirlist = dirlist + dirs
 916
 917
 918 def dirlist_get():
 919     return dirlist
 920
 921
 922 def foldup_blocks(block, crc):
 923     for b in block:
 924         # Look up CRC in user defined types
 925         if b.fieldtype.startswith('vl_api_'):
 926             # Recursively
 927             t = global_types[b.fieldtype]
 928             try:
 929                 crc = crc_block_combine(t.block, crc)
 930                 return foldup_blocks(t.block, crc)
 931             except AttributeError:
 932                 pass
 933     return crc
 934
 935
 936 def foldup_crcs(s):
 937     for f in s:
 938         f.crc = foldup_blocks(f.block,
 939                               binascii.crc32(f.crc) & 0xffffffff)
 940
 941
 942 #
 943 # Main
 944 #
 945 def main():
 946     if sys.version_info < (3, 5,):
 947         log.exception('vppapigen requires a supported version of python. '
 948                       'Please use version 3.5 or greater. '
 949                       'Using {}'.format(sys.version))
 950         return 1
 951
 952     cliparser = argparse.ArgumentParser(description='VPP API generator')
 953     cliparser.add_argument('--pluginpath', default=""),
 954     cliparser.add_argument('--includedir', action='append'),
 955     cliparser.add_argument('--outputdir', action='store'),
 956     cliparser.add_argument('--input')
 957     cliparser.add_argument('--output', nargs='?',
 958                            type=argparse.FileType('w', encoding='UTF-8'),
 959                            default=sys.stdout)
 960
 961     cliparser.add_argument('output_module', nargs='?', default='C')
 962     cliparser.add_argument('--debug', action='store_true')
 963     cliparser.add_argument('--show-name', nargs=1)
 964     cliparser.add_argument('--git-revision',
 965                            help="Git revision to use for opening files")
 966     args = cliparser.parse_args()
 967
 968     dirlist_add(args.includedir)
 969     if not args.debug:
 970         sys.excepthook = exception_handler
 971
 972     # Filename
 973     if args.show_name:
 974         filename = args.show_name[0]
 975     elif args.input:
 976         filename = args.input
 977     else:
 978         filename = ''
 979
 980     if args.debug:
 981         logging.basicConfig(stream=sys.stdout, level=logging.WARNING)
 982     else:
 983         logging.basicConfig()
 984
 985     parser = VPPAPI(debug=args.debug, filename=filename, logger=log,
 986                     revision=args.git_revision)
 987
 988     try:
 989         if not args.input:
 990             parsed_objects = parser.parse_fd(sys.stdin, log)
 991         else:
 992             parsed_objects = parser.parse_filename(args.input, log)
 993     except ParseError as e:
 994         print('Parse error: ', e, file=sys.stderr)
 995         sys.exit(1)
 996
 997     # Build a list of objects. Hash of lists.
 998     result = []
 999
1000     if args.output_module == 'C':
1001         s = parser.process(parsed_objects)
1002     else:
1003         result = parser.process_imports(parsed_objects, False, result)
1004         s = parser.process(result)
1005
1006     # Add msg_id field
1007     s['Define'] = add_msg_id(s['Define'])
1008
1009     # Fold up CRCs
1010     foldup_crcs(s['Define'])
1011
1012     #
1013     # Debug
1014     if args.debug:
1015         import pprint
1016         pp = pprint.PrettyPrinter(indent=4, stream=sys.stderr)
1017         for t in s['Define']:
1018             pp.pprint([t.name, t.flags, t.block])
1019         for t in s['types']:
1020             pp.pprint([t.name, t.block])
1021
1022     #
1023     # Generate representation
1024     #
1025     from importlib.machinery import SourceFileLoader
1026
1027     # Default path
1028     pluginpath = ''
1029     if not args.pluginpath:
1030         cand = []
1031         cand.append(os.path.dirname(os.path.realpath(__file__)))
1032         cand.append(os.path.dirname(os.path.realpath(__file__)) +
1033                     '/../share/vpp/')
1034         for c in cand:
1035             c += '/'
1036             if os.path.isfile('{}vppapigen_{}.py'
1037                               .format(c, args.output_module.lower())):
1038                 pluginpath = c
1039                 break
1040     else:
1041         pluginpath = args.pluginpath + '/'
1042     if pluginpath == '':
1043         log.exception('Output plugin not found')
1044         return 1
1045     module_path = '{}vppapigen_{}.py'.format(pluginpath,
1046                                              args.output_module.lower())
1047
1048     try:
1049         plugin = SourceFileLoader(args.output_module,
1050                                   module_path).load_module()
1051     except Exception as err:
1052         log.exception('Error importing output plugin: {}, {}'
1053                       .format(module_path, err))
1054         return 1
1055
1056     result = plugin.run(args, filename, s)
1057     if result:
1058         print(result, file=args.output)
1059     else:
1060         log.exception('Running plugin failed: {} {}'
1061                       .format(filename, result))
1062         return 1
1063     return 0
1064
1065
1066 if __name__ == '__main__':
1067     sys.exit(main())