Annotation of embedaddon/libevent/event_rpcgen.py, revision 1.1
1.1 ! misho 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)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to event_rpcgen.py CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent