third_party/libevent/event_rpcgen.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2005 Niels Provos <provos@citi.umich.edu>
   4 # All rights reserved.
   5 #
   6 # Generates marshaling code based on libevent.
   7
   8 import sys
   9 import re
  10
  11 #
  12 _NAME = "event_rpcgen.py"
  13 _VERSION = "0.1"
  14 _STRUCT_RE = '[a-z][a-z_0-9]*'
  15
  16 # Globals
  17 line_count = 0
  18
  19 white = re.compile(r'^\s+')
  20 cppcomment = re.compile(r'\/\/.*$')
  21 headerdirect = []
  22 cppdirect = []
  23
  24 # Holds everything that makes a struct
  25 class Struct:
  26     def __init__(self, name):
  27         self._name = name
  28         self._entries = []
  29         self._tags = {}
  30         print >>sys.stderr, '  Created struct: %s' % name
  31
  32     def AddEntry(self, entry):
  33         if self._tags.has_key(entry.Tag()):
  34             print >>sys.stderr, ( 'Entry "%s" duplicates tag number '
  35                                   '%d from "%s" around line %d' ) % (
  36                 entry.Name(), entry.Tag(),
  37                 self._tags[entry.Tag()], line_count)
  38             sys.exit(1)
  39         self._entries.append(entry)
  40         self._tags[entry.Tag()] = entry.Name()
  41         print >>sys.stderr, '    Added entry: %s' % entry.Name()
  42
  43     def Name(self):
  44         return self._name
  45
  46     def EntryTagName(self, entry):
  47         """Creates the name inside an enumeration for distinguishing data
  48         types."""
  49         name = "%s_%s" % (self._name, entry.Name())
  50         return name.upper()
  51
  52     def PrintIdented(self, file, ident, code):
  53         """Takes an array, add indentation to each entry and prints it."""
  54         for entry in code:
  55             print >>file, '%s%s' % (ident, entry)
  56
  57     def PrintTags(self, file):
  58         """Prints the tag definitions for a structure."""
  59         print >>file, '/* Tag definition for %s */' % self._name
  60         print >>file, 'enum %s_ {' % self._name.lower()
  61         for entry in self._entries:
  62             print >>file, '  %s=%d,' % (self.EntryTagName(entry),
  63                                         entry.Tag())
  64         print >>file, '  %s_MAX_TAGS' % (self._name.upper())
  65         print >>file, '};\n'
  66
  67     def PrintForwardDeclaration(self, file):
  68         print >>file, 'struct %s;' % self._name
  69
  70     def PrintDeclaration(self, file):
  71         print >>file, '/* Structure declaration for %s */' % self._name
  72         print >>file, 'struct %s_access_ {' % self._name
  73         for entry in self._entries:
  74             dcl = entry.AssignDeclaration('(*%s_assign)' % entry.Name())
  75             dcl.extend(
  76                 entry.GetDeclaration('(*%s_get)' % entry.Name()))
  77             if entry.Array():
  78                 dcl.extend(
  79                     entry.AddDeclaration('(*%s_add)' % entry.Name()))
  80             self.PrintIdented(file, '  ', dcl)
  81         print >>file, '};\n'
  82
  83         print >>file, 'struct %s {' % self._name
  84         print >>file, '  struct %s_access_ *base;\n' % self._name
  85         for entry in self._entries:
  86             dcl = entry.Declaration()
  87             self.PrintIdented(file, '  ', dcl)
  88         print >>file, ''
  89         for entry in self._entries:
  90             print >>file, '  ev_uint8_t %s_set;' % entry.Name()
  91         print >>file, '};\n'
  92
  93         print >>file, \
  94 """struct %(name)s *%(name)s_new(void);
  95 void %(name)s_free(struct %(name)s *);
  96 void %(name)s_clear(struct %(name)s *);
  97 void %(name)s_marshal(struct evbuffer *, const struct %(name)s *);
  98 int %(name)s_unmarshal(struct %(name)s *, struct evbuffer *);
  99 int %(name)s_complete(struct %(name)s *);
 100 void evtag_marshal_%(name)s(struct evbuffer *, ev_uint32_t,
 101     const struct %(name)s *);
 102 int evtag_unmarshal_%(name)s(struct evbuffer *, ev_uint32_t,
 103     struct %(name)s *);""" % { 'name' : self._name }
 104
 105
 106         # Write a setting function of every variable
 107         for entry in self._entries:
 108             self.PrintIdented(file, '', entry.AssignDeclaration(
 109                 entry.AssignFuncName()))
 110             self.PrintIdented(file, '', entry.GetDeclaration(
 111                 entry.GetFuncName()))
 112             if entry.Array():
 113                 self.PrintIdented(file, '', entry.AddDeclaration(
 114                     entry.AddFuncName()))
 115
 116         print >>file, '/* --- %s done --- */\n' % self._name
 117
 118     def PrintCode(self, file):
 119         print >>file, ('/*\n'
 120                        ' * Implementation of %s\n'
 121                        ' */\n') % self._name
 122
 123         print >>file, \
 124               'static struct %(name)s_access_ __%(name)s_base = {' % \
 125               { 'name' : self._name }
 126         for entry in self._entries:
 127             self.PrintIdented(file, '  ', entry.CodeBase())
 128         print >>file, '};\n'
 129
 130         # Creation
 131         print >>file, (
 132             'struct %(name)s *\n'
 133             '%(name)s_new(void)\n'
 134             '{\n'
 135             '  struct %(name)s *tmp;\n'
 136             '  if ((tmp = malloc(sizeof(struct %(name)s))) == NULL) {\n'
 137             '    event_warn("%%s: malloc", __func__);\n'
 138             '    return (NULL);\n'
 139             '  }\n'
 140             '  tmp->base = &__%(name)s_base;\n') % { 'name' : self._name }
 141
 142         for entry in self._entries:
 143             self.PrintIdented(file, '  ', entry.CodeNew('tmp'))
 144             print >>file, '  tmp->%s_set = 0;\n' % entry.Name()
 145
 146         print >>file, (
 147             '  return (tmp);\n'
 148             '}\n')
 149
 150         # Adding
 151         for entry in self._entries:
 152             if entry.Array():
 153                 self.PrintIdented(file, '', entry.CodeAdd())
 154             print >>file, ''
 155
 156         # Assigning
 157         for entry in self._entries:
 158             self.PrintIdented(file, '', entry.CodeAssign())
 159             print >>file, ''
 160
 161         # Getting
 162         for entry in self._entries:
 163             self.PrintIdented(file, '', entry.CodeGet())
 164             print >>file, ''
 165
 166         # Clearing
 167         print >>file, ( 'void\n'
 168                         '%(name)s_clear(struct %(name)s *tmp)\n'
 169                         '{'
 170                         ) % { 'name' : self._name }
 171         for entry in self._entries:
 172             self.PrintIdented(file, '  ', entry.CodeClear('tmp'))
 173
 174         print >>file, '}\n'
 175
 176         # Freeing
 177         print >>file, ( 'void\n'
 178                         '%(name)s_free(struct %(name)s *tmp)\n'
 179                         '{'
 180                         ) % { 'name' : self._name }
 181
 182         for entry in self._entries:
 183             self.PrintIdented(file, '  ', entry.CodeFree('tmp'))
 184
 185         print >>file, ('  free(tmp);\n'
 186                        '}\n')
 187
 188         # Marshaling
 189         print >>file, ('void\n'
 190                        '%(name)s_marshal(struct evbuffer *evbuf, '
 191                        'const struct %(name)s *tmp)'
 192                        '{') % { 'name' : self._name }
 193         for entry in self._entries:
 194             indent = '  '
 195             # Optional entries do not have to be set
 196             if entry.Optional():
 197                 indent += '  '
 198                 print >>file, '  if (tmp->%s_set) {' % entry.Name()
 199             self.PrintIdented(
 200                 file, indent,
 201                 entry.CodeMarshal('evbuf', self.EntryTagName(entry), 'tmp'))
 202             if entry.Optional():
 203                 print >>file, '  }'
 204
 205         print >>file, '}\n'
 206
 207         # Unmarshaling
 208         print >>file, ('int\n'
 209                        '%(name)s_unmarshal(struct %(name)s *tmp, '
 210                        ' struct evbuffer *evbuf)\n'
 211                        '{\n'
 212                        '  ev_uint32_t tag;\n'
 213                        '  while (EVBUFFER_LENGTH(evbuf) > 0) {\n'
 214                        '    if (evtag_peek(evbuf, &tag) == -1)\n'
 215                        '      return (-1);\n'
 216                        '    switch (tag) {\n'
 217                        ) % { 'name' : self._name }
 218         for entry in self._entries:
 219             print >>file, '      case %s:\n' % self.EntryTagName(entry)
 220             if not entry.Array():
 221                 print >>file, (
 222                     '        if (tmp->%s_set)\n'
 223                     '          return (-1);'
 224                     ) % (entry.Name())
 225
 226             self.PrintIdented(
 227                 file, '        ',
 228                 entry.CodeUnmarshal('evbuf',
 229                                     self.EntryTagName(entry), 'tmp'))
 230
 231             print >>file, ( '        tmp->%s_set = 1;\n' % entry.Name() +
 232                             '        break;\n' )
 233         print >>file, ( '      default:\n'
 234                         '        return -1;\n'
 235                         '    }\n'
 236                         '  }\n' )
 237         # Check if it was decoded completely
 238         print >>file, ( '  if (%(name)s_complete(tmp) == -1)\n'
 239                         '    return (-1);'
 240                         ) % { 'name' : self._name }
 241
 242         # Successfully decoded
 243         print >>file, ( '  return (0);\n'
 244                         '}\n')
 245
 246         # Checking if a structure has all the required data
 247         print >>file, (
 248             'int\n'
 249             '%(name)s_complete(struct %(name)s *msg)\n'
 250             '{' ) % { 'name' : self._name }
 251         for entry in self._entries:
 252             self.PrintIdented(
 253                 file, '  ',
 254                 entry.CodeComplete('msg'))
 255         print >>file, (
 256             '  return (0);\n'
 257             '}\n' )
 258
 259         # Complete message unmarshaling
 260         print >>file, (
 261             'int\n'
 262             'evtag_unmarshal_%(name)s(struct evbuffer *evbuf, '
 263             'ev_uint32_t need_tag, struct %(name)s *msg)\n'
 264             '{\n'
 265             '  ev_uint32_t tag;\n'
 266             '  int res = -1;\n'
 267             '\n'
 268             '  struct evbuffer *tmp = evbuffer_new();\n'
 269             '\n'
 270             '  if (evtag_unmarshal(evbuf, &tag, tmp) == -1'
 271             ' || tag != need_tag)\n'
 272             '    goto error;\n'
 273             '\n'
 274             '  if (%(name)s_unmarshal(msg, tmp) == -1)\n'
 275             '    goto error;\n'
 276             '\n'
 277             '  res = 0;\n'
 278             '\n'
 279             ' error:\n'
 280             '  evbuffer_free(tmp);\n'
 281             '  return (res);\n'
 282             '}\n' ) % { 'name' : self._name }
 283
 284         # Complete message marshaling
 285         print >>file, (
 286             'void\n'
 287             'evtag_marshal_%(name)s(struct evbuffer *evbuf, ev_uint32_t tag, '
 288             'const struct %(name)s *msg)\n'
 289             '{\n'
 290             '  struct evbuffer *_buf = evbuffer_new();\n'
 291             '  assert(_buf != NULL);\n'
 292             '  evbuffer_drain(_buf, -1);\n'
 293             '  %(name)s_marshal(_buf, msg);\n'
 294             '  evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf), '
 295             'EVBUFFER_LENGTH(_buf));\n'
 296             '  evbuffer_free(_buf);\n'
 297             '}\n' ) % { 'name' : self._name }
 298
 299 class Entry:
 300     def __init__(self, type, name, tag):
 301         self._type = type
 302         self._name = name
 303         self._tag = int(tag)
 304         self._ctype = type
 305         self._optional = 0
 306         self._can_be_array = 0
 307         self._array = 0
 308         self._line_count = -1
 309         self._struct = None
 310         self._refname = None
 311
 312     def GetTranslation(self):
 313         return { "parent_name" : self._struct.Name(),
 314                  "name" : self._name,
 315                  "ctype" : self._ctype,
 316                  "refname" : self._refname
 317                  }
 318
 319     def SetStruct(self, struct):
 320         self._struct = struct
 321
 322     def LineCount(self):
 323         assert self._line_count != -1
 324         return self._line_count
 325
 326     def SetLineCount(self, number):
 327         self._line_count = number
 328
 329     def Array(self):
 330         return self._array
 331
 332     def Optional(self):
 333         return self._optional
 334
 335     def Tag(self):
 336         return self._tag
 337
 338     def Name(self):
 339         return self._name
 340
 341     def Type(self):
 342         return self._type
 343
 344     def MakeArray(self, yes=1):
 345         self._array = yes
 346
 347     def MakeOptional(self):
 348         self._optional = 1
 349
 350     def GetFuncName(self):
 351         return '%s_%s_get' % (self._struct.Name(), self._name)
 352
 353     def GetDeclaration(self, funcname):
 354         code = [ 'int %s(struct %s *, %s *);' % (
 355             funcname, self._struct.Name(), self._ctype ) ]
 356         return code
 357
 358     def CodeGet(self):
 359         code = (
 360             'int',
 361             '%(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, '
 362             '%(ctype)s *value)',
 363             '{',
 364             '  if (msg->%(name)s_set != 1)',
 365             '    return (-1);',
 366             '  *value = msg->%(name)s_data;',
 367             '  return (0);',
 368             '}' )
 369         code = '\n'.join(code)
 370         code = code % self.GetTranslation()
 371         return code.split('\n')
 372
 373     def AssignFuncName(self):
 374         return '%s_%s_assign' % (self._struct.Name(), self._name)
 375
 376     def AddFuncName(self):
 377         return '%s_%s_add' % (self._struct.Name(), self._name)
 378
 379     def AssignDeclaration(self, funcname):
 380         code = [ 'int %s(struct %s *, const %s);' % (
 381             funcname, self._struct.Name(), self._ctype ) ]
 382         return code
 383
 384     def CodeAssign(self):
 385         code = [ 'int',
 386                  '%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,'
 387                  ' const %(ctype)s value)',
 388                  '{',
 389                  '  msg->%(name)s_set = 1;',
 390                  '  msg->%(name)s_data = value;',
 391                  '  return (0);',
 392                  '}' ]
 393         code = '\n'.join(code)
 394         code = code % self.GetTranslation()
 395         return code.split('\n')
 396
 397     def CodeClear(self, structname):
 398         code = [ '%s->%s_set = 0;' % (structname, self.Name()) ]
 399
 400         return code
 401
 402     def CodeComplete(self, structname):
 403         if self.Optional():
 404             return []
 405
 406         code = [ 'if (!%s->%s_set)' % (structname, self.Name()),
 407                  '  return (-1);' ]
 408
 409         return code
 410
 411     def CodeFree(self, name):
 412         return []
 413
 414     def CodeBase(self):
 415         code = [
 416             '%(parent_name)s_%(name)s_assign,',
 417             '%(parent_name)s_%(name)s_get,'
 418             ]
 419         if self.Array():
 420             code.append('%(parent_name)s_%(name)s_add,')
 421
 422         code = '\n'.join(code)
 423         code = code % self.GetTranslation()
 424         return code.split('\n')
 425
 426     def Verify(self):
 427         if self.Array() and not self._can_be_array:
 428             print >>sys.stderr, (
 429                 'Entry "%s" cannot be created as an array '
 430                 'around line %d' ) % (self._name, self.LineCount())
 431             sys.exit(1)
 432         if not self._struct:
 433             print >>sys.stderr, (
 434                 'Entry "%s" does not know which struct it belongs to '
 435                 'around line %d' ) % (self._name, self.LineCount())
 436             sys.exit(1)
 437         if self._optional and self._array:
 438             print >>sys.stderr,  ( 'Entry "%s" has illegal combination of '
 439                                    'optional and array around line %d' ) % (
 440                 self._name, self.LineCount() )
 441             sys.exit(1)
 442
 443 class EntryBytes(Entry):
 444     def __init__(self, type, name, tag, length):
 445         # Init base class
 446         Entry.__init__(self, type, name, tag)
 447
 448         self._length = length
 449         self._ctype = 'ev_uint8_t'
 450
 451     def GetDeclaration(self, funcname):
 452         code = [ 'int %s(struct %s *, %s **);' % (
 453             funcname, self._struct.Name(), self._ctype ) ]
 454         return code
 455
 456     def AssignDeclaration(self, funcname):
 457         code = [ 'int %s(struct %s *, const %s *);' % (
 458             funcname, self._struct.Name(), self._ctype ) ]
 459         return code
 460
 461     def Declaration(self):
 462         dcl  = ['ev_uint8_t %s_data[%s];' % (self._name, self._length)]
 463
 464         return dcl
 465
 466     def CodeGet(self):
 467         name = self._name
 468         code = [ 'int',
 469                  '%s_%s_get(struct %s *msg, %s **value)' % (
 470             self._struct.Name(), name,
 471             self._struct.Name(), self._ctype),
 472                  '{',
 473                  '  if (msg->%s_set != 1)' % name,
 474                  '    return (-1);',
 475                  '  *value = msg->%s_data;' % name,
 476                  '  return (0);',
 477                  '}' ]
 478         return code
 479
 480     def CodeAssign(self):
 481         name = self._name
 482         code = [ 'int',
 483                  '%s_%s_assign(struct %s *msg, const %s *value)' % (
 484             self._struct.Name(), name,
 485             self._struct.Name(), self._ctype),
 486                  '{',
 487                  '  msg->%s_set = 1;' % name,
 488                  '  memcpy(msg->%s_data, value, %s);' % (
 489             name, self._length),
 490                  '  return (0);',
 491                  '}' ]
 492         return code
 493
 494     def CodeUnmarshal(self, buf, tag_name, var_name):
 495         code = [  'if (evtag_unmarshal_fixed(%s, %s, ' % (buf, tag_name) +
 496                   '%s->%s_data, ' % (var_name, self._name) +
 497                   'sizeof(%s->%s_data)) == -1) {' % (
 498             var_name, self._name),
 499                   '  event_warnx("%%s: failed to unmarshal %s", __func__);' % (
 500             self._name ),
 501                   '  return (-1);',
 502                   '}'
 503                   ]
 504         return code
 505
 506     def CodeMarshal(self, buf, tag_name, var_name):
 507         code = ['evtag_marshal(%s, %s, %s->%s_data, sizeof(%s->%s_data));' % (
 508             buf, tag_name, var_name, self._name, var_name, self._name )]
 509         return code
 510
 511     def CodeClear(self, structname):
 512         code = [ '%s->%s_set = 0;' % (structname, self.Name()),
 513                  'memset(%s->%s_data, 0, sizeof(%s->%s_data));' % (
 514             structname, self._name, structname, self._name)]
 515
 516         return code
 517
 518     def CodeNew(self, name):
 519         code  = ['memset(%s->%s_data, 0, sizeof(%s->%s_data));' % (
 520             name, self._name, name, self._name)]
 521         return code
 522
 523     def Verify(self):
 524         if not self._length:
 525             print >>sys.stderr, 'Entry "%s" needs a length around line %d' % (
 526                 self._name, self.LineCount() )
 527             sys.exit(1)
 528
 529         Entry.Verify(self)
 530
 531 class EntryInt(Entry):
 532     def __init__(self, type, name, tag):
 533         # Init base class
 534         Entry.__init__(self, type, name, tag)
 535
 536         self._ctype = 'ev_uint32_t'
 537
 538     def CodeUnmarshal(self, buf, tag_name, var_name):
 539         code = ['if (evtag_unmarshal_int(%s, %s, &%s->%s_data) == -1) {' % (
 540             buf, tag_name, var_name, self._name),
 541                   '  event_warnx("%%s: failed to unmarshal %s", __func__);' % (
 542             self._name ),
 543                 '  return (-1);',
 544                 '}' ]
 545         return code
 546
 547     def CodeMarshal(self, buf, tag_name, var_name):
 548         code = ['evtag_marshal_int(%s, %s, %s->%s_data);' % (
 549             buf, tag_name, var_name, self._name)]
 550         return code
 551
 552     def Declaration(self):
 553         dcl  = ['ev_uint32_t %s_data;' % self._name]
 554
 555         return dcl
 556
 557     def CodeNew(self, name):
 558         code = ['%s->%s_data = 0;' % (name, self._name)]
 559         return code
 560
 561 class EntryString(Entry):
 562     def __init__(self, type, name, tag):
 563         # Init base class
 564         Entry.__init__(self, type, name, tag)
 565
 566         self._ctype = 'char *'
 567
 568     def CodeAssign(self):
 569         name = self._name
 570         code = """int
 571 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,
 572     const %(ctype)s value)
 573 {
 574   if (msg->%(name)s_data != NULL)
 575     free(msg->%(name)s_data);
 576   if ((msg->%(name)s_data = strdup(value)) == NULL)
 577     return (-1);
 578   msg->%(name)s_set = 1;
 579   return (0);
 580 }""" % self.GetTranslation()
 581
 582         return code.split('\n')
 583
 584     def CodeUnmarshal(self, buf, tag_name, var_name):
 585         code = ['if (evtag_unmarshal_string(%s, %s, &%s->%s_data) == -1) {' % (
 586             buf, tag_name, var_name, self._name),
 587                 '  event_warnx("%%s: failed to unmarshal %s", __func__);' % (
 588             self._name ),
 589                 '  return (-1);',
 590                 '}'
 591                 ]
 592         return code
 593
 594     def CodeMarshal(self, buf, tag_name, var_name):
 595         code = ['evtag_marshal_string(%s, %s, %s->%s_data);' % (
 596             buf, tag_name, var_name, self._name)]
 597         return code
 598
 599     def CodeClear(self, structname):
 600         code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),
 601                  '  free (%s->%s_data);' % (structname, self.Name()),
 602                  '  %s->%s_data = NULL;' % (structname, self.Name()),
 603                  '  %s->%s_set = 0;' % (structname, self.Name()),
 604                  '}'
 605                  ]
 606
 607         return code
 608
 609     def CodeNew(self, name):
 610         code  = ['%s->%s_data = NULL;' % (name, self._name)]
 611         return code
 612
 613     def CodeFree(self, name):
 614         code  = ['if (%s->%s_data != NULL)' % (name, self._name),
 615                  '    free (%s->%s_data); ' % (name, self._name)]
 616
 617         return code
 618
 619     def Declaration(self):
 620         dcl  = ['char *%s_data;' % self._name]
 621
 622         return dcl
 623
 624 class EntryStruct(Entry):
 625     def __init__(self, type, name, tag, refname):
 626         # Init base class
 627         Entry.__init__(self, type, name, tag)
 628
 629         self._can_be_array = 1
 630         self._refname = refname
 631         self._ctype = 'struct %s*' % refname
 632
 633     def CodeGet(self):
 634         name = self._name
 635         code = [ 'int',
 636                  '%s_%s_get(struct %s *msg, %s *value)' % (
 637             self._struct.Name(), name,
 638             self._struct.Name(), self._ctype),
 639                  '{',
 640                  '  if (msg->%s_set != 1) {' % name,
 641                  '    msg->%s_data = %s_new();' % (name, self._refname),
 642                  '    if (msg->%s_data == NULL)' % name,
 643                  '      return (-1);',
 644                  '    msg->%s_set = 1;' % name,
 645                  '  }',
 646                  '  *value = msg->%s_data;' % name,
 647                  '  return (0);',
 648                  '}' ]
 649         return code
 650
 651     def CodeAssign(self):
 652         name = self._name
 653         code = """int
 654 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,
 655     const %(ctype)s value)
 656 {
 657    struct evbuffer *tmp = NULL;
 658    if (msg->%(name)s_set) {
 659      %(refname)s_clear(msg->%(name)s_data);
 660      msg->%(name)s_set = 0;
 661    } else {
 662      msg->%(name)s_data = %(refname)s_new();
 663      if (msg->%(name)s_data == NULL) {
 664        event_warn("%%s: %(refname)s_new()", __func__);
 665        goto error;
 666      }
 667    }
 668    if ((tmp = evbuffer_new()) == NULL) {
 669      event_warn("%%s: evbuffer_new()", __func__);
 670      goto error;
 671    }
 672    %(refname)s_marshal(tmp, value);
 673    if (%(refname)s_unmarshal(msg->%(name)s_data, tmp) == -1) {
 674      event_warnx("%%s: %(refname)s_unmarshal", __func__);
 675      goto error;
 676    }
 677    msg->%(name)s_set = 1;
 678    evbuffer_free(tmp);
 679    return (0);
 680  error:
 681    if (tmp != NULL)
 682      evbuffer_free(tmp);
 683    if (msg->%(name)s_data != NULL) {
 684      %(refname)s_free(msg->%(name)s_data);
 685      msg->%(name)s_data = NULL;
 686    }
 687    return (-1);
 688 }""" % self.GetTranslation()
 689         return code.split('\n')
 690
 691     def CodeComplete(self, structname):
 692         if self.Optional():
 693             code = [ 'if (%s->%s_set && %s_complete(%s->%s_data) == -1)' % (
 694                 structname, self.Name(),
 695                 self._refname, structname, self.Name()),
 696                      '  return (-1);' ]
 697         else:
 698             code = [ 'if (%s_complete(%s->%s_data) == -1)' % (
 699                 self._refname, structname, self.Name()),
 700                      '  return (-1);' ]
 701
 702         return code
 703
 704     def CodeUnmarshal(self, buf, tag_name, var_name):
 705         code = ['%s->%s_data = %s_new();' % (
 706             var_name, self._name, self._refname),
 707                 'if (%s->%s_data == NULL)' % (var_name, self._name),
 708                 '  return (-1);',
 709                 'if (evtag_unmarshal_%s(%s, %s, %s->%s_data) == -1) {' % (
 710             self._refname, buf, tag_name, var_name, self._name),
 711                   '  event_warnx("%%s: failed to unmarshal %s", __func__);' % (
 712             self._name ),
 713                 '  return (-1);',
 714                 '}'
 715                 ]
 716         return code
 717
 718     def CodeMarshal(self, buf, tag_name, var_name):
 719         code = ['evtag_marshal_%s(%s, %s, %s->%s_data);' % (
 720             self._refname, buf, tag_name, var_name, self._name)]
 721         return code
 722
 723     def CodeClear(self, structname):
 724         code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),
 725                  '  %s_free(%s->%s_data);' % (
 726             self._refname, structname, self.Name()),
 727                  '  %s->%s_data = NULL;' % (structname, self.Name()),
 728                  '  %s->%s_set = 0;' % (structname, self.Name()),
 729                  '}'
 730                  ]
 731
 732         return code
 733
 734     def CodeNew(self, name):
 735         code  = ['%s->%s_data = NULL;' % (name, self._name)]
 736         return code
 737
 738     def CodeFree(self, name):
 739         code  = ['if (%s->%s_data != NULL)' % (name, self._name),
 740                  '    %s_free(%s->%s_data); ' % (
 741             self._refname, name, self._name)]
 742
 743         return code
 744
 745     def Declaration(self):
 746         dcl  = ['%s %s_data;' % (self._ctype, self._name)]
 747
 748         return dcl
 749
 750 class EntryVarBytes(Entry):
 751     def __init__(self, type, name, tag):
 752         # Init base class
 753         Entry.__init__(self, type, name, tag)
 754
 755         self._ctype = 'ev_uint8_t *'
 756
 757     def GetDeclaration(self, funcname):
 758         code = [ 'int %s(struct %s *, %s *, ev_uint32_t *);' % (
 759             funcname, self._struct.Name(), self._ctype ) ]
 760         return code
 761
 762     def AssignDeclaration(self, funcname):
 763         code = [ 'int %s(struct %s *, const %s, ev_uint32_t);' % (
 764             funcname, self._struct.Name(), self._ctype ) ]
 765         return code
 766
 767     def CodeAssign(self):
 768         name = self._name
 769         code = [ 'int',
 770                  '%s_%s_assign(struct %s *msg, '
 771                  'const %s value, ev_uint32_t len)' % (
 772             self._struct.Name(), name,
 773             self._struct.Name(), self._ctype),
 774                  '{',
 775                  '  if (msg->%s_data != NULL)' % name,
 776                  '    free (msg->%s_data);' % name,
 777                  '  msg->%s_data = malloc(len);' % name,
 778                  '  if (msg->%s_data == NULL)' % name,
 779                  '    return (-1);',
 780                  '  msg->%s_set = 1;' % name,
 781                  '  msg->%s_length = len;' % name,
 782                  '  memcpy(msg->%s_data, value, len);' % name,
 783                  '  return (0);',
 784                  '}' ]
 785         return code
 786
 787     def CodeGet(self):
 788         name = self._name
 789         code = [ 'int',
 790                  '%s_%s_get(struct %s *msg, %s *value, ev_uint32_t *plen)' % (
 791             self._struct.Name(), name,
 792             self._struct.Name(), self._ctype),
 793                  '{',
 794                  '  if (msg->%s_set != 1)' % name,
 795                  '    return (-1);',
 796                  '  *value = msg->%s_data;' % name,
 797                  '  *plen = msg->%s_length;' % name,
 798                  '  return (0);',
 799                  '}' ]
 800         return code
 801
 802     def CodeUnmarshal(self, buf, tag_name, var_name):
 803         code = ['if (evtag_payload_length(%s, &%s->%s_length) == -1)' % (
 804             buf, var_name, self._name),
 805                 '  return (-1);',
 806                 # We do not want DoS opportunities
 807                 'if (%s->%s_length > EVBUFFER_LENGTH(%s))' % (
 808             var_name, self._name, buf),
 809                 '  return (-1);',
 810                 'if ((%s->%s_data = malloc(%s->%s_length)) == NULL)' % (
 811             var_name, self._name, var_name, self._name),
 812                 '  return (-1);',
 813                 'if (evtag_unmarshal_fixed(%s, %s, %s->%s_data, '
 814                 '%s->%s_length) == -1) {' % (
 815             buf, tag_name, var_name, self._name, var_name, self._name),
 816                 '  event_warnx("%%s: failed to unmarshal %s", __func__);' % (
 817             self._name ),
 818                 '  return (-1);',
 819                 '}'
 820                 ]
 821         return code
 822
 823     def CodeMarshal(self, buf, tag_name, var_name):
 824         code = ['evtag_marshal(%s, %s, %s->%s_data, %s->%s_length);' % (
 825             buf, tag_name, var_name, self._name, var_name, self._name)]
 826         return code
 827
 828     def CodeClear(self, structname):
 829         code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),
 830                  '  free (%s->%s_data);' % (structname, self.Name()),
 831                  '  %s->%s_data = NULL;' % (structname, self.Name()),
 832                  '  %s->%s_length = 0;' % (structname, self.Name()),
 833                  '  %s->%s_set = 0;' % (structname, self.Name()),
 834                  '}'
 835                  ]
 836
 837         return code
 838
 839     def CodeNew(self, name):
 840         code  = ['%s->%s_data = NULL;' % (name, self._name),
 841                  '%s->%s_length = 0;' % (name, self._name) ]
 842         return code
 843
 844     def CodeFree(self, name):
 845         code  = ['if (%s->%s_data != NULL)' % (name, self._name),
 846                  '    free (%s->%s_data); ' % (name, self._name)]
 847
 848         return code
 849
 850     def Declaration(self):
 851         dcl  = ['ev_uint8_t *%s_data;' % self._name,
 852                 'ev_uint32_t %s_length;' % self._name]
 853
 854         return dcl
 855
 856 class EntryArray(Entry):
 857     def __init__(self, entry):
 858         # Init base class
 859         Entry.__init__(self, entry._type, entry._name, entry._tag)
 860
 861         self._entry = entry
 862         self._refname = entry._refname
 863         self._ctype = 'struct %s *' % self._refname
 864
 865     def GetDeclaration(self, funcname):
 866         """Allows direct access to elements of the array."""
 867         translate = self.GetTranslation()
 868         translate["funcname"] = funcname
 869         code = [
 870             'int %(funcname)s(struct %(parent_name)s *, int, %(ctype)s *);' %
 871             translate ]
 872         return code
 873
 874     def AssignDeclaration(self, funcname):
 875         code = [ 'int %s(struct %s *, int, const %s);' % (
 876             funcname, self._struct.Name(), self._ctype ) ]
 877         return code
 878
 879     def AddDeclaration(self, funcname):
 880         code = [ '%s %s(struct %s *);' % (
 881             self._ctype, funcname, self._struct.Name() ) ]
 882         return code
 883
 884     def CodeGet(self):
 885         code = """int
 886 %(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, int offset,
 887     %(ctype)s *value)
 888 {
 889   if (!msg->%(name)s_set || offset < 0 || offset >= msg->%(name)s_length)
 890     return (-1);
 891   *value = msg->%(name)s_data[offset];
 892   return (0);
 893 }""" % self.GetTranslation()
 894
 895         return code.split('\n')
 896
 897     def CodeAssign(self):
 898         code = """int
 899 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, int off,
 900     const %(ctype)s value)
 901 {
 902   struct evbuffer *tmp = NULL;
 903   if (!msg->%(name)s_set || off < 0 || off >= msg->%(name)s_length)
 904     return (-1);
 905   %(refname)s_clear(msg->%(name)s_data[off]);
 906   if ((tmp = evbuffer_new()) == NULL) {
 907     event_warn("%%s: evbuffer_new()", __func__);
 908     goto error;
 909   }
 910   %(refname)s_marshal(tmp, value);
 911   if (%(refname)s_unmarshal(msg->%(name)s_data[off], tmp) == -1) {
 912     event_warnx("%%s: %(refname)s_unmarshal", __func__);
 913     goto error;
 914   }
 915   evbuffer_free(tmp);
 916   return (0);
 917 error:
 918   if (tmp != NULL)
 919     evbuffer_free(tmp);
 920   %(refname)s_clear(msg->%(name)s_data[off]);
 921   return (-1);
 922 }""" % self.GetTranslation()
 923
 924         return code.split('\n')
 925
 926     def CodeAdd(self):
 927         code = \
 928 """%(ctype)s
 929 %(parent_name)s_%(name)s_add(struct %(parent_name)s *msg)
 930 {
 931   if (++msg->%(name)s_length >= msg->%(name)s_num_allocated) {
 932     int tobe_allocated = msg->%(name)s_num_allocated;
 933     %(ctype)s* new_data = NULL;
 934     tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1;
 935     new_data = (%(ctype)s*) realloc(msg->%(name)s_data,
 936         tobe_allocated * sizeof(%(ctype)s));
 937     if (new_data == NULL)
 938       goto error;
 939     msg->%(name)s_data = new_data;
 940     msg->%(name)s_num_allocated = tobe_allocated;
 941   }
 942   msg->%(name)s_data[msg->%(name)s_length - 1] = %(refname)s_new();
 943   if (msg->%(name)s_data[msg->%(name)s_length - 1] == NULL)
 944     goto error;
 945   msg->%(name)s_set = 1;
 946   return (msg->%(name)s_data[msg->%(name)s_length - 1]);
 947 error:
 948   --msg->%(name)s_length;
 949   return (NULL);
 950 }
 951         """ % self.GetTranslation()
 952
 953         return code.split('\n')
 954
 955     def CodeComplete(self, structname):
 956         code = []
 957         translate = self.GetTranslation()
 958
 959         if self.Optional():
 960             code.append( 'if (%(structname)s->%(name)s_set)'  % translate)
 961
 962         translate["structname"] = structname
 963         tmp = """{
 964   int i;
 965   for (i = 0; i < %(structname)s->%(name)s_length; ++i) {
 966     if (%(refname)s_complete(%(structname)s->%(name)s_data[i]) == -1)
 967       return (-1);
 968   }
 969 }""" % translate
 970         code.extend(tmp.split('\n'))
 971
 972         return code
 973
 974     def CodeUnmarshal(self, buf, tag_name, var_name):
 975         translate = self.GetTranslation()
 976         translate["var_name"] = var_name
 977         translate["buf"] = buf
 978         translate["tag_name"] = tag_name
 979         code = """if (%(parent_name)s_%(name)s_add(%(var_name)s) == NULL)
 980   return (-1);
 981 if (evtag_unmarshal_%(refname)s(%(buf)s, %(tag_name)s,
 982   %(var_name)s->%(name)s_data[%(var_name)s->%(name)s_length - 1]) == -1) {
 983   --%(var_name)s->%(name)s_length;
 984   event_warnx("%%s: failed to unmarshal %(name)s", __func__);
 985   return (-1);
 986 }""" % translate
 987
 988         return code.split('\n')
 989
 990     def CodeMarshal(self, buf, tag_name, var_name):
 991         code = ['{',
 992                 '  int i;',
 993                 '  for (i = 0; i < %s->%s_length; ++i) {' % (
 994             var_name, self._name),
 995                 '    evtag_marshal_%s(%s, %s, %s->%s_data[i]);' % (
 996             self._refname, buf, tag_name, var_name, self._name),
 997                 '  }',
 998                 '}'
 999                 ]
1000         return code
1001
1002     def CodeClear(self, structname):
1003         code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),
1004                  '  int i;',
1005                  '  for (i = 0; i < %s->%s_length; ++i) {' % (
1006             structname, self.Name()),
1007                  '    %s_free(%s->%s_data[i]);' % (
1008             self._refname, structname, self.Name()),
1009                  '  }',
1010                  '  free(%s->%s_data);' % (structname, self.Name()),
1011                  '  %s->%s_data = NULL;' % (structname, self.Name()),
1012                  '  %s->%s_set = 0;' % (structname, self.Name()),
1013                  '  %s->%s_length = 0;' % (structname, self.Name()),
1014                  '  %s->%s_num_allocated = 0;' % (structname, self.Name()),
1015                  '}'
1016                  ]
1017
1018         return code
1019
1020     def CodeNew(self, name):
1021         code  = ['%s->%s_data = NULL;' % (name, self._name),
1022                  '%s->%s_length = 0;' % (name, self._name),
1023                  '%s->%s_num_allocated = 0;' % (name, self._name)]
1024         return code
1025
1026     def CodeFree(self, name):
1027         code  = ['if (%s->%s_data != NULL) {' % (name, self._name),
1028                  '  int i;',
1029                  '  for (i = 0; i < %s->%s_length; ++i) {' % (
1030             name, self._name),
1031                  '    %s_free(%s->%s_data[i]); ' % (
1032             self._refname, name, self._name),
1033                  '    %s->%s_data[i] = NULL;' % (name, self._name),
1034                  '  }',
1035                  '  free(%s->%s_data);' % (name, self._name),
1036                  '  %s->%s_data = NULL;' % (name, self._name),
1037                  '  %s->%s_length = 0;' % (name, self._name),
1038                  '  %s->%s_num_allocated = 0;' % (name, self._name),
1039                  '}'
1040                  ]
1041
1042         return code
1043
1044     def Declaration(self):
1045         dcl  = ['struct %s **%s_data;' % (self._refname, self._name),
1046                 'int %s_length;' % self._name,
1047                 'int %s_num_allocated;' % self._name ]
1048
1049         return dcl
1050
1051 def NormalizeLine(line):
1052     global white
1053     global cppcomment
1054
1055     line = cppcomment.sub('', line)
1056     line = line.strip()
1057     line = white.sub(' ', line)
1058
1059     return line
1060
1061 def ProcessOneEntry(newstruct, entry):
1062     optional = 0
1063     array = 0
1064     entry_type = ''
1065     name = ''
1066     tag = ''
1067     tag_set = None
1068     separator = ''
1069     fixed_length = ''
1070
1071     tokens = entry.split(' ')
1072     while tokens:
1073         token = tokens[0]
1074         tokens = tokens[1:]
1075
1076         if not entry_type:
1077             if not optional and token == 'optional':
1078                 optional = 1
1079                 continue
1080
1081             if not array and token == 'array':
1082                 array = 1
1083                 continue
1084
1085         if not entry_type:
1086             entry_type = token
1087             continue
1088
1089         if not name:
1090             res = re.match(r'^([^\[\]]+)(\[.*\])?$', token)
1091             if not res:
1092                 print >>sys.stderr, 'Cannot parse name: \"%s\" around %d' % (
1093                     entry, line_count)
1094                 sys.exit(1)
1095             name = res.group(1)
1096             fixed_length = res.group(2)
1097             if fixed_length:
1098                 fixed_length = fixed_length[1:-1]
1099             continue
1100
1101         if not separator:
1102             separator = token
1103             if separator != '=':
1104                 print >>sys.stderr, 'Expected "=" after name \"%s\" got %s' % (
1105                     name, token)
1106                 sys.exit(1)
1107             continue
1108
1109         if not tag_set:
1110             tag_set = 1
1111             if not re.match(r'^(0x)?[0-9]+$', token):
1112                 print >>sys.stderr, 'Expected tag number: \"%s\"' % entry
1113                 sys.exit(1)
1114             tag = int(token, 0)
1115             continue
1116
1117         print >>sys.stderr, 'Cannot parse \"%s\"' % entry
1118         sys.exit(1)
1119
1120     if not tag_set:
1121         print >>sys.stderr, 'Need tag number: \"%s\"' % entry
1122         sys.exit(1)
1123
1124     # Create the right entry
1125     if entry_type == 'bytes':
1126         if fixed_length:
1127             newentry = EntryBytes(entry_type, name, tag, fixed_length)
1128         else:
1129             newentry = EntryVarBytes(entry_type, name, tag)
1130     elif entry_type == 'int' and not fixed_length:
1131         newentry = EntryInt(entry_type, name, tag)
1132     elif entry_type == 'string' and not fixed_length:
1133         newentry = EntryString(entry_type, name, tag)
1134     else:
1135         res = re.match(r'^struct\[(%s)\]$' % _STRUCT_RE,
1136                        entry_type, re.IGNORECASE)
1137         if res:
1138             # References another struct defined in our file
1139             newentry = EntryStruct(entry_type, name, tag, res.group(1))
1140         else:
1141             print >>sys.stderr, 'Bad type: "%s" in "%s"' % (entry_type, entry)
1142             sys.exit(1)
1143
1144     structs = []
1145
1146     if optional:
1147         newentry.MakeOptional()
1148     if array:
1149         newentry.MakeArray()
1150
1151     newentry.SetStruct(newstruct)
1152     newentry.SetLineCount(line_count)
1153     newentry.Verify()
1154
1155     if array:
1156         # We need to encapsulate this entry into a struct
1157         newname = newentry.Name()+ '_array'
1158
1159         # Now borgify the new entry.
1160         newentry = EntryArray(newentry)
1161         newentry.SetStruct(newstruct)
1162         newentry.SetLineCount(line_count)
1163         newentry.MakeArray()
1164
1165     newstruct.AddEntry(newentry)
1166
1167     return structs
1168
1169 def ProcessStruct(data):
1170     tokens = data.split(' ')
1171
1172     # First three tokens are: 'struct' 'name' '{'
1173     newstruct = Struct(tokens[1])
1174
1175     inside = ' '.join(tokens[3:-1])
1176
1177     tokens = inside.split(';')
1178
1179     structs = []
1180
1181     for entry in tokens:
1182         entry = NormalizeLine(entry)
1183         if not entry:
1184             continue
1185
1186         # It's possible that new structs get defined in here
1187         structs.extend(ProcessOneEntry(newstruct, entry))
1188
1189     structs.append(newstruct)
1190     return structs
1191
1192 def GetNextStruct(file):
1193     global line_count
1194     global cppdirect
1195
1196     got_struct = 0
1197
1198     processed_lines = []
1199
1200     have_c_comment = 0
1201     data = ''
1202     while 1:
1203         line = file.readline()
1204         if not line:
1205             break
1206
1207         line_count += 1
1208         line = line[:-1]
1209
1210         if not have_c_comment and re.search(r'/\*', line):
1211             if re.search(r'/\*.*\*/', line):
1212                 line = re.sub(r'/\*.*\*/', '', line)
1213             else:
1214                 line = re.sub(r'/\*.*$', '', line)
1215                 have_c_comment = 1
1216
1217         if have_c_comment:
1218             if not re.search(r'\*/', line):
1219                 continue
1220             have_c_comment = 0
1221             line = re.sub(r'^.*\*/', '', line)
1222
1223         line = NormalizeLine(line)
1224
1225         if not line:
1226             continue
1227
1228         if not got_struct:
1229             if re.match(r'#include ["<].*[>"]', line):
1230                 cppdirect.append(line)
1231                 continue
1232
1233             if re.match(r'^#(if( |def)|endif)', line):
1234                 cppdirect.append(line)
1235                 continue
1236
1237             if re.match(r'^#define', line):
1238                 headerdirect.append(line)
1239                 continue
1240
1241             if not re.match(r'^struct %s {$' % _STRUCT_RE,
1242                             line, re.IGNORECASE):
1243                 print >>sys.stderr, 'Missing struct on line %d: %s' % (
1244                     line_count, line)
1245                 sys.exit(1)
1246             else:
1247                 got_struct = 1
1248                 data += line
1249             continue
1250
1251         # We are inside the struct
1252         tokens = line.split('}')
1253         if len(tokens) == 1:
1254             data += ' ' + line
1255             continue
1256
1257         if len(tokens[1]):
1258             print >>sys.stderr, 'Trailing garbage after struct on line %d' % (
1259                 line_count )
1260             sys.exit(1)
1261
1262         # We found the end of the struct
1263         data += ' %s}' % tokens[0]
1264         break
1265
1266     # Remove any comments, that might be in there
1267     data = re.sub(r'/\*.*\*/', '', data)
1268
1269     return data
1270
1271
1272 def Parse(file):
1273     """
1274     Parses the input file and returns C code and corresponding header file.
1275     """
1276
1277     entities = []
1278
1279     while 1:
1280         # Just gets the whole struct nicely formatted
1281         data = GetNextStruct(file)
1282
1283         if not data:
1284             break
1285
1286         entities.extend(ProcessStruct(data))
1287
1288     return entities
1289
1290 def GuardName(name):
1291     name = '_'.join(name.split('.'))
1292     name = '_'.join(name.split('/'))
1293     guard = '_'+name.upper()+'_'
1294
1295     return guard
1296
1297 def HeaderPreamble(name):
1298     guard = GuardName(name)
1299     pre = (
1300         '/*\n'
1301         ' * Automatically generated from %s\n'
1302         ' */\n\n'
1303         '#ifndef %s\n'
1304         '#define %s\n\n' ) % (
1305         name, guard, guard)
1306
1307     # insert stdint.h - let's hope everyone has it
1308     pre += (
1309         '#include <event-config.h>\n'
1310         '#ifdef _EVENT_HAVE_STDINT_H\n'
1311         '#include <stdint.h>\n'
1312         '#endif\n' )
1313
1314     for statement in headerdirect:
1315         pre += '%s\n' % statement
1316     if headerdirect:
1317         pre += '\n'
1318
1319     pre += (
1320         '#define EVTAG_HAS(msg, member) ((msg)->member##_set == 1)\n'
1321         '#ifdef __GNUC__\n'
1322         '#define EVTAG_ASSIGN(msg, member, args...) '
1323         '(*(msg)->base->member##_assign)(msg, ## args)\n'
1324         '#define EVTAG_GET(msg, member, args...) '
1325         '(*(msg)->base->member##_get)(msg, ## args)\n'
1326         '#else\n'
1327         '#define EVTAG_ASSIGN(msg, member, ...) '
1328         '(*(msg)->base->member##_assign)(msg, ## __VA_ARGS__)\n'
1329         '#define EVTAG_GET(msg, member, ...) '
1330         '(*(msg)->base->member##_get)(msg, ## __VA_ARGS__)\n'
1331         '#endif\n'
1332         '#define EVTAG_ADD(msg, member) (*(msg)->base->member##_add)(msg)\n'
1333         '#define EVTAG_LEN(msg, member) ((msg)->member##_length)\n'
1334         )
1335
1336     return pre
1337
1338
1339 def HeaderPostamble(name):
1340     guard = GuardName(name)
1341     return '#endif  /* %s */' % guard
1342
1343 def BodyPreamble(name):
1344     global _NAME
1345     global _VERSION
1346
1347     header_file = '.'.join(name.split('.')[:-1]) + '.gen.h'
1348
1349     pre = ( '/*\n'
1350             ' * Automatically generated from %s\n'
1351             ' * by %s/%s.  DO NOT EDIT THIS FILE.\n'
1352             ' */\n\n' ) % (name, _NAME, _VERSION)
1353     pre += ( '#include <sys/types.h>\n'
1354              '#ifdef _EVENT_HAVE_SYS_TIME_H\n'
1355              '#include <sys/time.h>\n'
1356              '#endif\n'
1357              '#include <stdlib.h>\n'
1358              '#include <string.h>\n'
1359              '#include <assert.h>\n'
1360              '#define EVENT_NO_STRUCT\n'
1361              '#include <event.h>\n\n'
1362              '#ifdef _EVENT___func__\n'
1363              '#define __func__ _EVENT___func__\n'
1364              '#endif\n' )
1365
1366     for statement in cppdirect:
1367         pre += '%s\n' % statement
1368
1369     pre += '\n#include "%s"\n\n' % header_file
1370
1371     pre += 'void event_err(int eval, const char *fmt, ...);\n'
1372     pre += 'void event_warn(const char *fmt, ...);\n'
1373     pre += 'void event_errx(int eval, const char *fmt, ...);\n'
1374     pre += 'void event_warnx(const char *fmt, ...);\n\n'
1375
1376     return pre
1377
1378 def main(argv):
1379     if len(argv) < 2 or not argv[1]:
1380         print >>sys.stderr, 'Need RPC description file as first argument.'
1381         sys.exit(1)
1382
1383     filename = argv[1]
1384
1385     ext = filename.split('.')[-1]
1386     if ext != 'rpc':
1387         print >>sys.stderr, 'Unrecognized file extension: %s' % ext
1388         sys.exit(1)
1389
1390     print >>sys.stderr, 'Reading \"%s\"' % filename
1391
1392     fp = open(filename, 'r')
1393     entities = Parse(fp)
1394     fp.close()
1395
1396     header_file = '.'.join(filename.split('.')[:-1]) + '.gen.h'
1397     impl_file = '.'.join(filename.split('.')[:-1]) + '.gen.c'
1398
1399     print >>sys.stderr, '... creating "%s"' % header_file
1400     header_fp = open(header_file, 'w')
1401     print >>header_fp, HeaderPreamble(filename)
1402
1403     # Create forward declarations: allows other structs to reference
1404     # each other
1405     for entry in entities:
1406         entry.PrintForwardDeclaration(header_fp)
1407     print >>header_fp, ''
1408
1409     for entry in entities:
1410         entry.PrintTags(header_fp)
1411         entry.PrintDeclaration(header_fp)
1412     print >>header_fp, HeaderPostamble(filename)
1413     header_fp.close()
1414
1415     print >>sys.stderr, '... creating "%s"' % impl_file
1416     impl_fp = open(impl_file, 'w')
1417     print >>impl_fp, BodyPreamble(filename)
1418     for entry in entities:
1419         entry.PrintCode(impl_fp)
1420     impl_fp.close()
1421
1422 if __name__ == '__main__':
1423     main(sys.argv)