1 #!/usr/bin/env python2 2 # 3 # Copyright (c) 2005-2007 Niels Provos <provos (at] citi.umich.edu> 4 # Copyright (c) 2007-2012 Niels Provos and Nick Mathewson 5 # All rights reserved. 6 # 7 # Generates marshaling code based on libevent. 8 9 # TODO: 10 # 1) use optparse to allow the strategy shell to parse options, and 11 # to allow the instantiated factory (for the specific output language) 12 # to parse remaining options 13 # 2) move the globals into a class that manages execution (including the 14 # progress outputs that space stderr at the moment) 15 # 3) emit other languages 16 17 import sys 18 import re 19 20 _NAME = "event_rpcgen.py" 21 _VERSION = "0.1" 22 23 # Globals 24 line_count = 0 25 26 white = re.compile(r'\s+') 27 cppcomment = re.compile(r'\/\/.*$') 28 nonident = re.compile(r'[^a-zA-Z0-9_]') 29 structref = re.compile(r'^struct\[([a-zA-Z_][a-zA-Z0-9_]*)\]$') 30 structdef = re.compile(r'^struct +[a-zA-Z_][a-zA-Z0-9_]* *{$') 31 32 headerdirect = [] 33 cppdirect = [] 34 35 def TranslateList(mylist, mydict): 36 return map(lambda x: x % mydict, mylist) 37 38 # Exception class for parse errors 39 class RpcGenError(Exception): 40 def __init__(self, why): 41 self.why = why 42 def __str__(self): 43 return str(self.why) 44 45 # Holds everything that makes a struct 46 class Struct: 47 def __init__(self, name): 48 self._name = name 49 self._entries = [] 50 self._tags = {} 51 print >>sys.stderr, ' Created struct: %s' % name 52 53 def AddEntry(self, entry): 54 if self._tags.has_key(entry.Tag()): 55 raise RpcGenError( 56 'Entry "%s" duplicates tag number %d from "%s" ' 57 'around line %d' % (entry.Name(), entry.Tag(), 58 self._tags[entry.Tag()], line_count)) 59 self._entries.append(entry) 60 self._tags[entry.Tag()] = entry.Name() 61 print >>sys.stderr, ' Added entry: %s' % entry.Name() 62 63 def Name(self): 64 return self._name 65 66 def EntryTagName(self, entry): 67 """Creates the name inside an enumeration for distinguishing data 68 types.""" 69 name = "%s_%s" % (self._name, entry.Name()) 70 return name.upper() 71 72 def PrintIndented(self, file, ident, code): 73 """Takes an array, add indentation to each entry and prints it.""" 74 for entry in code: 75 print >>file, '%s%s' % (ident, entry) 76 77 class StructCCode(Struct): 78 """ Knows how to generate C code for a struct """ 79 80 def __init__(self, name): 81 Struct.__init__(self, name) 82 83 def PrintTags(self, file): 84 """Prints the tag definitions for a structure.""" 85 print >>file, '/* Tag definition for %s */' % self._name 86 print >>file, 'enum %s_ {' % self._name.lower() 87 for entry in self._entries: 88 print >>file, ' %s=%d,' % (self.EntryTagName(entry), 89 entry.Tag()) 90 print >>file, ' %s_MAX_TAGS' % (self._name.upper()) 91 print >>file, '};\n' 92 93 def PrintForwardDeclaration(self, file): 94 print >>file, 'struct %s;' % self._name 95 96 def PrintDeclaration(self, file): 97 print >>file, '/* Structure declaration for %s */' % self._name 98 print >>file, 'struct %s_access_ {' % self._name 99 for entry in self._entries: 100 dcl = entry.AssignDeclaration('(*%s_assign)' % entry.Name()) 101 dcl.extend( 102 entry.GetDeclaration('(*%s_get)' % entry.Name())) 103 if entry.Array(): 104 dcl.extend( 105 entry.AddDeclaration('(*%s_add)' % entry.Name())) 106 self.PrintIndented(file, ' ', dcl) 107 print >>file, '};\n' 108 109 print >>file, 'struct %s {' % self._name 110 print >>file, ' struct %s_access_ *base;\n' % self._name 111 for entry in self._entries: 112 dcl = entry.Declaration() 113 self.PrintIndented(file, ' ', dcl) 114 print >>file, '' 115 for entry in self._entries: 116 print >>file, ' ev_uint8_t %s_set;' % entry.Name() 117 print >>file, '};\n' 118 119 print >>file, \ 120 """struct %(name)s *%(name)s_new(void); 121 struct %(name)s *%(name)s_new_with_arg(void *); 122 void %(name)s_free(struct %(name)s *); 123 void %(name)s_clear(struct %(name)s *); 124 void %(name)s_marshal(struct evbuffer *, const struct %(name)s *); 125 int %(name)s_unmarshal(struct %(name)s *, struct evbuffer *); 126 int %(name)s_complete(struct %(name)s *); 127 void evtag_marshal_%(name)s(struct evbuffer *, ev_uint32_t, 128 const struct %(name)s *); 129 int evtag_unmarshal_%(name)s(struct evbuffer *, ev_uint32_t, 130 struct %(name)s *);""" % { 'name' : self._name } 131 132 133 # Write a setting function of every variable 134 for entry in self._entries: 135 self.PrintIndented(file, '', entry.AssignDeclaration( 136 entry.AssignFuncName())) 137 self.PrintIndented(file, '', entry.GetDeclaration( 138 entry.GetFuncName())) 139 if entry.Array(): 140 self.PrintIndented(file, '', entry.AddDeclaration( 141 entry.AddFuncName())) 142 143 print >>file, '/* --- %s done --- */\n' % self._name 144 145 def PrintCode(self, file): 146 print >>file, ('/*\n' 147 ' * Implementation of %s\n' 148 ' */\n') % self._name 149 150 print >>file, \ 151 'static struct %(name)s_access_ __%(name)s_base = {' % \ 152 { 'name' : self._name } 153 for entry in self._entries: 154 self.PrintIndented(file, ' ', entry.CodeBase()) 155 print >>file, '};\n' 156 157 # Creation 158 print >>file, ( 159 'struct %(name)s *\n' 160 '%(name)s_new(void)\n' 161 '{\n' 162 ' return %(name)s_new_with_arg(NULL);\n' 163 '}\n' 164 '\n' 165 'struct %(name)s *\n' 166 '%(name)s_new_with_arg(void *unused)\n' 167 '{\n' 168 ' struct %(name)s *tmp;\n' 169 ' if ((tmp = malloc(sizeof(struct %(name)s))) == NULL) {\n' 170 ' event_warn("%%s: malloc", __func__);\n' 171 ' return (NULL);\n' 172 ' }\n' 173 ' tmp->base = &__%(name)s_base;\n') % { 'name' : self._name } 174 175 for entry in self._entries: 176 self.PrintIndented(file, ' ', entry.CodeInitialize('tmp')) 177 print >>file, ' tmp->%s_set = 0;\n' % entry.Name() 178 179 print >>file, ( 180 ' return (tmp);\n' 181 '}\n') 182 183 # Adding 184 for entry in self._entries: 185 if entry.Array(): 186 self.PrintIndented(file, '', entry.CodeAdd()) 187 print >>file, '' 188 189 # Assigning 190 for entry in self._entries: 191 self.PrintIndented(file, '', entry.CodeAssign()) 192 print >>file, '' 193 194 # Getting 195 for entry in self._entries: 196 self.PrintIndented(file, '', entry.CodeGet()) 197 print >>file, '' 198 199 # Clearing 200 print >>file, ( 'void\n' 201 '%(name)s_clear(struct %(name)s *tmp)\n' 202 '{' 203 ) % { 'name' : self._name } 204 for entry in self._entries: 205 self.PrintIndented(file, ' ', entry.CodeClear('tmp')) 206 207 print >>file, '}\n' 208 209 # Freeing 210 print >>file, ( 'void\n' 211 '%(name)s_free(struct %(name)s *tmp)\n' 212 '{' 213 ) % { 'name' : self._name } 214 215 for entry in self._entries: 216 self.PrintIndented(file, ' ', entry.CodeFree('tmp')) 217 218 print >>file, (' free(tmp);\n' 219 '}\n') 220 221 # Marshaling 222 print >>file, ('void\n' 223 '%(name)s_marshal(struct evbuffer *evbuf, ' 224 'const struct %(name)s *tmp)' 225 '{') % { 'name' : self._name } 226 for entry in self._entries: 227 indent = ' ' 228 # Optional entries do not have to be set 229 if entry.Optional(): 230 indent += ' ' 231 print >>file, ' if (tmp->%s_set) {' % entry.Name() 232 self.PrintIndented( 233 file, indent, 234 entry.CodeMarshal('evbuf', self.EntryTagName(entry), 235 entry.GetVarName('tmp'), 236 entry.GetVarLen('tmp'))) 237 if entry.Optional(): 238 print >>file, ' }' 239 240 print >>file, '}\n' 241 242 # Unmarshaling 243 print >>file, ('int\n' 244 '%(name)s_unmarshal(struct %(name)s *tmp, ' 245 ' struct evbuffer *evbuf)\n' 246 '{\n' 247 ' ev_uint32_t tag;\n' 248 ' while (evbuffer_get_length(evbuf) > 0) {\n' 249 ' if (evtag_peek(evbuf, &tag) == -1)\n' 250 ' return (-1);\n' 251 ' switch (tag) {\n' 252 ) % { 'name' : self._name } 253 for entry in self._entries: 254 print >>file, ' case %s:\n' % self.EntryTagName(entry) 255 if not entry.Array(): 256 print >>file, ( 257 ' if (tmp->%s_set)\n' 258 ' return (-1);' 259 ) % (entry.Name()) 260 261 self.PrintIndented( 262 file, ' ', 263 entry.CodeUnmarshal('evbuf', 264 self.EntryTagName(entry), 265 entry.GetVarName('tmp'), 266 entry.GetVarLen('tmp'))) 267 268 print >>file, ( ' tmp->%s_set = 1;\n' % entry.Name() + 269 ' break;\n' ) 270 print >>file, ( ' default:\n' 271 ' return -1;\n' 272 ' }\n' 273 ' }\n' ) 274 # Check if it was decoded completely 275 print >>file, ( ' if (%(name)s_complete(tmp) == -1)\n' 276 ' return (-1);' 277 ) % { 'name' : self._name } 278 279 # Successfully decoded 280 print >>file, ( ' return (0);\n' 281 '}\n') 282 283 # Checking if a structure has all the required data 284 print >>file, ( 285 'int\n' 286 '%(name)s_complete(struct %(name)s *msg)\n' 287 '{' ) % { 'name' : self._name } 288 for entry in self._entries: 289 if not entry.Optional(): 290 code = [ 291 'if (!msg->%(name)s_set)', 292 ' return (-1);' ] 293 code = TranslateList(code, entry.GetTranslation()) 294 self.PrintIndented( 295 file, ' ', code) 296 297 self.PrintIndented( 298 file, ' ', 299 entry.CodeComplete('msg', entry.GetVarName('msg'))) 300 print >>file, ( 301 ' return (0);\n' 302 '}\n' ) 303 304 # Complete message unmarshaling 305 print >>file, ( 306 'int\n' 307 'evtag_unmarshal_%(name)s(struct evbuffer *evbuf, ' 308 'ev_uint32_t need_tag, struct %(name)s *msg)\n' 309 '{\n' 310 ' ev_uint32_t tag;\n' 311 ' int res = -1;\n' 312 '\n' 313 ' struct evbuffer *tmp = evbuffer_new();\n' 314 '\n' 315 ' if (evtag_unmarshal(evbuf, &tag, tmp) == -1' 316 ' || tag != need_tag)\n' 317 ' goto error;\n' 318 '\n' 319 ' if (%(name)s_unmarshal(msg, tmp) == -1)\n' 320 ' goto error;\n' 321 '\n' 322 ' res = 0;\n' 323 '\n' 324 ' error:\n' 325 ' evbuffer_free(tmp);\n' 326 ' return (res);\n' 327 '}\n' ) % { 'name' : self._name } 328 329 # Complete message marshaling 330 print >>file, ( 331 'void\n' 332 'evtag_marshal_%(name)s(struct evbuffer *evbuf, ev_uint32_t tag, ' 333 'const struct %(name)s *msg)\n' 334 '{\n' 335 ' struct evbuffer *_buf = evbuffer_new();\n' 336 ' assert(_buf != NULL);\n' 337 ' %(name)s_marshal(_buf, msg);\n' 338 ' evtag_marshal_buffer(evbuf, tag, _buf);\n ' 339 ' evbuffer_free(_buf);\n' 340 '}\n' ) % { 'name' : self._name } 341 342 class Entry: 343 def __init__(self, type, name, tag): 344 self._type = type 345 self._name = name 346 self._tag = int(tag) 347 self._ctype = type 348 self._optional = 0 349 self._can_be_array = 0 350 self._array = 0 351 self._line_count = -1 352 self._struct = None 353 self._refname = None 354 355 self._optpointer = True 356 self._optaddarg = True 357 358 def GetInitializer(self): 359 assert 0, "Entry does not provide initializer" 360 361 def SetStruct(self, struct): 362 self._struct = struct 363 364 def LineCount(self): 365 assert self._line_count != -1 366 return self._line_count 367 368 def SetLineCount(self, number): 369 self._line_count = number 370 371 def Array(self): 372 return self._array 373 374 def Optional(self): 375 return self._optional 376 377 def Tag(self): 378 return self._tag 379 380 def Name(self): 381 return self._name 382 383 def Type(self): 384 return self._type 385 386 def MakeArray(self, yes=1): 387 self._array = yes 388 389 def MakeOptional(self): 390 self._optional = 1 391 392 def Verify(self): 393 if self.Array() and not self._can_be_array: 394 raise RpcGenError( 395 'Entry "%s" cannot be created as an array ' 396 'around line %d' % (self._name, self.LineCount())) 397 if not self._struct: 398 raise RpcGenError( 399 'Entry "%s" does not know which struct it belongs to ' 400 'around line %d' % (self._name, self.LineCount())) 401 if self._optional and self._array: 402 raise RpcGenError( 403 'Entry "%s" has illegal combination of optional and array ' 404 'around line %d' % (self._name, self.LineCount())) 405 406 def GetTranslation(self, extradict = {}): 407 mapping = { 408 "parent_name" : self._struct.Name(), 409 "name" : self._name, 410 "ctype" : self._ctype, 411 "refname" : self._refname, 412 "optpointer" : self._optpointer and "*" or "", 413 "optreference" : self._optpointer and "&" or "", 414 "optaddarg" : 415 self._optaddarg and ", const %s value" % self._ctype or "" 416 } 417 for (k, v) in extradict.items(): 418 mapping[k] = v 419 420 return mapping 421 422 def GetVarName(self, var): 423 return '%(var)s->%(name)s_data' % self.GetTranslation({ 'var' : var }) 424 425 def GetVarLen(self, var): 426 return 'sizeof(%s)' % self._ctype 427 428 def GetFuncName(self): 429 return '%s_%s_get' % (self._struct.Name(), self._name) 430 431 def GetDeclaration(self, funcname): 432 code = [ 'int %s(struct %s *, %s *);' % ( 433 funcname, self._struct.Name(), self._ctype ) ] 434 return code 435 436 def CodeGet(self): 437 code = ( 438 'int', 439 '%(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, ' 440 '%(ctype)s *value)', 441 '{', 442 ' if (msg->%(name)s_set != 1)', 443 ' return (-1);', 444 ' *value = msg->%(name)s_data;', 445 ' return (0);', 446 '}' ) 447 code = '\n'.join(code) 448 code = code % self.GetTranslation() 449 return code.split('\n') 450 451 def AssignFuncName(self): 452 return '%s_%s_assign' % (self._struct.Name(), self._name) 453 454 def AddFuncName(self): 455 return '%s_%s_add' % (self._struct.Name(), self._name) 456 457 def AssignDeclaration(self, funcname): 458 code = [ 'int %s(struct %s *, const %s);' % ( 459 funcname, self._struct.Name(), self._ctype ) ] 460 return code 461 462 def CodeAssign(self): 463 code = [ 'int', 464 '%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,' 465 ' const %(ctype)s value)', 466 '{', 467 ' msg->%(name)s_set = 1;', 468 ' msg->%(name)s_data = value;', 469 ' return (0);', 470 '}' ] 471 code = '\n'.join(code) 472 code = code % self.GetTranslation() 473 return code.split('\n') 474 475 def CodeClear(self, structname): 476 code = [ '%s->%s_set = 0;' % (structname, self.Name()) ] 477 478 return code 479 480 def CodeComplete(self, structname, var_name): 481 return [] 482 483 def CodeFree(self, name): 484 return [] 485 486 def CodeBase(self): 487 code = [ 488 '%(parent_name)s_%(name)s_assign,', 489 '%(parent_name)s_%(name)s_get,' 490 ] 491 if self.Array(): 492 code.append('%(parent_name)s_%(name)s_add,') 493 494 code = '\n'.join(code) 495 code = code % self.GetTranslation() 496 return code.split('\n') 497 498 class EntryBytes(Entry): 499 def __init__(self, type, name, tag, length): 500 # Init base class 501 Entry.__init__(self, type, name, tag) 502 503 self._length = length 504 self._ctype = 'ev_uint8_t' 505 506 def GetInitializer(self): 507 return "NULL" 508 509 def GetVarLen(self, var): 510 return '(%s)' % self._length 511 512 def CodeArrayAdd(self, varname, value): 513 # XXX: copy here 514 return [ '%(varname)s = NULL;' % { 'varname' : varname } ] 515 516 def GetDeclaration(self, funcname): 517 code = [ 'int %s(struct %s *, %s **);' % ( 518 funcname, self._struct.Name(), self._ctype ) ] 519 return code 520 521 def AssignDeclaration(self, funcname): 522 code = [ 'int %s(struct %s *, const %s *);' % ( 523 funcname, self._struct.Name(), self._ctype ) ] 524 return code 525 526 def Declaration(self): 527 dcl = ['ev_uint8_t %s_data[%s];' % (self._name, self._length)] 528 529 return dcl 530 531 def CodeGet(self): 532 name = self._name 533 code = [ 'int', 534 '%s_%s_get(struct %s *msg, %s **value)' % ( 535 self._struct.Name(), name, 536 self._struct.Name(), self._ctype), 537 '{', 538 ' if (msg->%s_set != 1)' % name, 539 ' return (-1);', 540 ' *value = msg->%s_data;' % name, 541 ' return (0);', 542 '}' ] 543 return code 544 545 def CodeAssign(self): 546 name = self._name 547 code = [ 'int', 548 '%s_%s_assign(struct %s *msg, const %s *value)' % ( 549 self._struct.Name(), name, 550 self._struct.Name(), self._ctype), 551 '{', 552 ' msg->%s_set = 1;' % name, 553 ' memcpy(msg->%s_data, value, %s);' % ( 554 name, self._length), 555 ' return (0);', 556 '}' ] 557 return code 558 559 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 560 code = [ 'if (evtag_unmarshal_fixed(%(buf)s, %(tag)s, ' 561 '%(var)s, %(varlen)s) == -1) {', 562 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 563 ' return (-1);', 564 '}' 565 ] 566 return TranslateList(code, 567 self.GetTranslation({ 568 'var' : var_name, 569 'varlen' : var_len, 570 'buf' : buf, 571 'tag' : tag_name })) 572 573 def CodeMarshal(self, buf, tag_name, var_name, var_len): 574 code = ['evtag_marshal(%s, %s, %s, %s);' % ( 575 buf, tag_name, var_name, var_len)] 576 return code 577 578 def CodeClear(self, structname): 579 code = [ '%s->%s_set = 0;' % (structname, self.Name()), 580 'memset(%s->%s_data, 0, sizeof(%s->%s_data));' % ( 581 structname, self._name, structname, self._name)] 582 583 return code 584 585 def CodeInitialize(self, name): 586 code = ['memset(%s->%s_data, 0, sizeof(%s->%s_data));' % ( 587 name, self._name, name, self._name)] 588 return code 589 590 def Verify(self): 591 if not self._length: 592 raise RpcGenError( 593 'Entry "%s" needs a length ' 594 'around line %d' % (self._name, self.LineCount())) 595 596 Entry.Verify(self) 597 598 class EntryInt(Entry): 599 def __init__(self, type, name, tag, bits=32): 600 # Init base class 601 Entry.__init__(self, type, name, tag) 602 603 self._can_be_array = 1 604 if bits == 32: 605 self._ctype = 'ev_uint32_t' 606 self._marshal_type = 'int' 607 if bits == 64: 608 self._ctype = 'ev_uint64_t' 609 self._marshal_type = 'int64' 610 611 def GetInitializer(self): 612 return "0" 613 614 def CodeArrayFree(self, var): 615 return [] 616 617 def CodeArrayAssign(self, varname, srcvar): 618 return [ '%(varname)s = %(srcvar)s;' % { 'varname' : varname, 619 'srcvar' : srcvar } ] 620 621 def CodeArrayAdd(self, varname, value): 622 """Returns a new entry of this type.""" 623 return [ '%(varname)s = %(value)s;' % { 'varname' : varname, 624 'value' : value } ] 625 626 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 627 code = [ 628 'if (evtag_unmarshal_%(ma)s(%(buf)s, %(tag)s, &%(var)s) == -1) {', 629 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 630 ' return (-1);', 631 '}' ] 632 code = '\n'.join(code) % self.GetTranslation({ 633 'ma' : self._marshal_type, 634 'buf' : buf, 635 'tag' : tag_name, 636 'var' : var_name }) 637 return code.split('\n') 638 639 def CodeMarshal(self, buf, tag_name, var_name, var_len): 640 code = [ 641 'evtag_marshal_%s(%s, %s, %s);' % ( 642 self._marshal_type, buf, tag_name, var_name)] 643 return code 644 645 def Declaration(self): 646 dcl = ['%s %s_data;' % (self._ctype, self._name)] 647 648 return dcl 649 650 def CodeInitialize(self, name): 651 code = ['%s->%s_data = 0;' % (name, self._name)] 652 return code 653 654 class EntryString(Entry): 655 def __init__(self, type, name, tag): 656 # Init base class 657 Entry.__init__(self, type, name, tag) 658 659 self._can_be_array = 1 660 self._ctype = 'char *' 661 662 def GetInitializer(self): 663 return "NULL" 664 665 def CodeArrayFree(self, varname): 666 code = [ 667 'if (%(var)s != NULL) free(%(var)s);' ] 668 669 return TranslateList(code, { 'var' : varname }) 670 671 def CodeArrayAssign(self, varname, srcvar): 672 code = [ 673 'if (%(var)s != NULL)', 674 ' free(%(var)s);', 675 '%(var)s = strdup(%(srcvar)s);', 676 'if (%(var)s == NULL) {', 677 ' event_warnx("%%s: strdup", __func__);', 678 ' return (-1);', 679 '}' ] 680 681 return TranslateList(code, { 'var' : varname, 682 'srcvar' : srcvar }) 683 684 def CodeArrayAdd(self, varname, value): 685 code = [ 686 'if (%(value)s != NULL) {', 687 ' %(var)s = strdup(%(value)s);', 688 ' if (%(var)s == NULL) {', 689 ' goto error;', 690 ' }', 691 '} else {', 692 ' %(var)s = NULL;', 693 '}' ] 694 695 return TranslateList(code, { 'var' : varname, 696 'value' : value }) 697 698 def GetVarLen(self, var): 699 return 'strlen(%s)' % self.GetVarName(var) 700 701 def CodeMakeInitalize(self, varname): 702 return '%(varname)s = NULL;' % { 'varname' : varname } 703 704 def CodeAssign(self): 705 name = self._name 706 code = """int 707 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, 708 const %(ctype)s value) 709 { 710 if (msg->%(name)s_data != NULL) 711 free(msg->%(name)s_data); 712 if ((msg->%(name)s_data = strdup(value)) == NULL) 713 return (-1); 714 msg->%(name)s_set = 1; 715 return (0); 716 }""" % self.GetTranslation() 717 718 return code.split('\n') 719 720 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 721 code = ['if (evtag_unmarshal_string(%(buf)s, %(tag)s, &%(var)s) == -1) {', 722 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 723 ' return (-1);', 724 '}' 725 ] 726 code = '\n'.join(code) % self.GetTranslation({ 727 'buf' : buf, 728 'tag' : tag_name, 729 'var' : var_name }) 730 return code.split('\n') 731 732 def CodeMarshal(self, buf, tag_name, var_name, var_len): 733 code = ['evtag_marshal_string(%s, %s, %s);' % ( 734 buf, tag_name, var_name)] 735 return code 736 737 def CodeClear(self, structname): 738 code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()), 739 ' free(%s->%s_data);' % (structname, self.Name()), 740 ' %s->%s_data = NULL;' % (structname, self.Name()), 741 ' %s->%s_set = 0;' % (structname, self.Name()), 742 '}' 743 ] 744 745 return code 746 747 def CodeInitialize(self, name): 748 code = ['%s->%s_data = NULL;' % (name, self._name)] 749 return code 750 751 def CodeFree(self, name): 752 code = ['if (%s->%s_data != NULL)' % (name, self._name), 753 ' free (%s->%s_data);' % (name, self._name)] 754 755 return code 756 757 def Declaration(self): 758 dcl = ['char *%s_data;' % self._name] 759 760 return dcl 761 762 class EntryStruct(Entry): 763 def __init__(self, type, name, tag, refname): 764 # Init base class 765 Entry.__init__(self, type, name, tag) 766 767 self._optpointer = False 768 self._can_be_array = 1 769 self._refname = refname 770 self._ctype = 'struct %s*' % refname 771 self._optaddarg = False 772 773 def GetInitializer(self): 774 return "NULL" 775 776 def GetVarLen(self, var): 777 return '-1' 778 779 def CodeArrayAdd(self, varname, value): 780 code = [ 781 '%(varname)s = %(refname)s_new();', 782 'if (%(varname)s == NULL)', 783 ' goto error;' ] 784 785 return TranslateList(code, self.GetTranslation({ 'varname' : varname })) 786 787 def CodeArrayFree(self, var): 788 code = [ '%(refname)s_free(%(var)s);' % self.GetTranslation( 789 { 'var' : var }) ] 790 return code 791 792 def CodeArrayAssign(self, var, srcvar): 793 code = [ 794 'int had_error = 0;', 795 'struct evbuffer *tmp = NULL;', 796 '%(refname)s_clear(%(var)s);', 797 'if ((tmp = evbuffer_new()) == NULL) {', 798 ' event_warn("%%s: evbuffer_new()", __func__);', 799 ' had_error = 1;', 800 ' goto done;', 801 '}', 802 '%(refname)s_marshal(tmp, %(srcvar)s);', 803 'if (%(refname)s_unmarshal(%(var)s, tmp) == -1) {', 804 ' event_warnx("%%s: %(refname)s_unmarshal", __func__);', 805 ' had_error = 1;', 806 ' goto done;', 807 '}', 808 'done:' 809 'if (tmp != NULL)', 810 ' evbuffer_free(tmp);', 811 'if (had_error) {', 812 ' %(refname)s_clear(%(var)s);', 813 ' return (-1);', 814 '}' ] 815 816 return TranslateList(code, self.GetTranslation({ 817 'var' : var, 818 'srcvar' : srcvar})) 819 820 def CodeGet(self): 821 name = self._name 822 code = [ 'int', 823 '%s_%s_get(struct %s *msg, %s *value)' % ( 824 self._struct.Name(), name, 825 self._struct.Name(), self._ctype), 826 '{', 827 ' if (msg->%s_set != 1) {' % name, 828 ' msg->%s_data = %s_new();' % (name, self._refname), 829 ' if (msg->%s_data == NULL)' % name, 830 ' return (-1);', 831 ' msg->%s_set = 1;' % name, 832 ' }', 833 ' *value = msg->%s_data;' % name, 834 ' return (0);', 835 '}' ] 836 return code 837 838 def CodeAssign(self): 839 name = self._name 840 code = """int 841 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, 842 const %(ctype)s value) 843 { 844 struct evbuffer *tmp = NULL; 845 if (msg->%(name)s_set) { 846 %(refname)s_clear(msg->%(name)s_data); 847 msg->%(name)s_set = 0; 848 } else { 849 msg->%(name)s_data = %(refname)s_new(); 850 if (msg->%(name)s_data == NULL) { 851 event_warn("%%s: %(refname)s_new()", __func__); 852 goto error; 853 } 854 } 855 if ((tmp = evbuffer_new()) == NULL) { 856 event_warn("%%s: evbuffer_new()", __func__); 857 goto error; 858 } 859 %(refname)s_marshal(tmp, value); 860 if (%(refname)s_unmarshal(msg->%(name)s_data, tmp) == -1) { 861 event_warnx("%%s: %(refname)s_unmarshal", __func__); 862 goto error; 863 } 864 msg->%(name)s_set = 1; 865 evbuffer_free(tmp); 866 return (0); 867 error: 868 if (tmp != NULL) 869 evbuffer_free(tmp); 870 if (msg->%(name)s_data != NULL) { 871 %(refname)s_free(msg->%(name)s_data); 872 msg->%(name)s_data = NULL; 873 } 874 return (-1); 875 }""" % self.GetTranslation() 876 return code.split('\n') 877 878 def CodeComplete(self, structname, var_name): 879 code = [ 'if (%(structname)s->%(name)s_set && ' 880 '%(refname)s_complete(%(var)s) == -1)', 881 ' return (-1);' ] 882 883 return TranslateList(code, self.GetTranslation({ 884 'structname' : structname, 885 'var' : var_name })) 886 887 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 888 code = ['%(var)s = %(refname)s_new();', 889 'if (%(var)s == NULL)', 890 ' return (-1);', 891 'if (evtag_unmarshal_%(refname)s(%(buf)s, %(tag)s, ' 892 '%(var)s) == -1) {', 893 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 894 ' return (-1);', 895 '}' 896 ] 897 code = '\n'.join(code) % self.GetTranslation({ 898 'buf' : buf, 899 'tag' : tag_name, 900 'var' : var_name }) 901 return code.split('\n') 902 903 def CodeMarshal(self, buf, tag_name, var_name, var_len): 904 code = ['evtag_marshal_%s(%s, %s, %s);' % ( 905 self._refname, buf, tag_name, var_name)] 906 return code 907 908 def CodeClear(self, structname): 909 code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()), 910 ' %s_free(%s->%s_data);' % ( 911 self._refname, structname, self.Name()), 912 ' %s->%s_data = NULL;' % (structname, self.Name()), 913 ' %s->%s_set = 0;' % (structname, self.Name()), 914 '}' 915 ] 916 917 return code 918 919 def CodeInitialize(self, name): 920 code = ['%s->%s_data = NULL;' % (name, self._name)] 921 return code 922 923 def CodeFree(self, name): 924 code = ['if (%s->%s_data != NULL)' % (name, self._name), 925 ' %s_free(%s->%s_data);' % ( 926 self._refname, name, self._name)] 927 928 return code 929 930 def Declaration(self): 931 dcl = ['%s %s_data;' % (self._ctype, self._name)] 932 933 return dcl 934 935 class EntryVarBytes(Entry): 936 def __init__(self, type, name, tag): 937 # Init base class 938 Entry.__init__(self, type, name, tag) 939 940 self._ctype = 'ev_uint8_t *' 941 942 def GetInitializer(self): 943 return "NULL" 944 945 def GetVarLen(self, var): 946 return '%(var)s->%(name)s_length' % self.GetTranslation({ 'var' : var }) 947 948 def CodeArrayAdd(self, varname, value): 949 # xxx: copy 950 return [ '%(varname)s = NULL;' % { 'varname' : varname } ] 951 952 def GetDeclaration(self, funcname): 953 code = [ 'int %s(struct %s *, %s *, ev_uint32_t *);' % ( 954 funcname, self._struct.Name(), self._ctype ) ] 955 return code 956 957 def AssignDeclaration(self, funcname): 958 code = [ 'int %s(struct %s *, const %s, ev_uint32_t);' % ( 959 funcname, self._struct.Name(), self._ctype ) ] 960 return code 961 962 def CodeAssign(self): 963 name = self._name 964 code = [ 'int', 965 '%s_%s_assign(struct %s *msg, ' 966 'const %s value, ev_uint32_t len)' % ( 967 self._struct.Name(), name, 968 self._struct.Name(), self._ctype), 969 '{', 970 ' if (msg->%s_data != NULL)' % name, 971 ' free (msg->%s_data);' % name, 972 ' msg->%s_data = malloc(len);' % name, 973 ' if (msg->%s_data == NULL)' % name, 974 ' return (-1);', 975 ' msg->%s_set = 1;' % name, 976 ' msg->%s_length = len;' % name, 977 ' memcpy(msg->%s_data, value, len);' % name, 978 ' return (0);', 979 '}' ] 980 return code 981 982 def CodeGet(self): 983 name = self._name 984 code = [ 'int', 985 '%s_%s_get(struct %s *msg, %s *value, ev_uint32_t *plen)' % ( 986 self._struct.Name(), name, 987 self._struct.Name(), self._ctype), 988 '{', 989 ' if (msg->%s_set != 1)' % name, 990 ' return (-1);', 991 ' *value = msg->%s_data;' % name, 992 ' *plen = msg->%s_length;' % name, 993 ' return (0);', 994 '}' ] 995 return code 996 997 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 998 code = ['if (evtag_payload_length(%(buf)s, &%(varlen)s) == -1)', 999 ' return (-1);', 1000 # We do not want DoS opportunities 1001 'if (%(varlen)s > evbuffer_get_length(%(buf)s))', 1002 ' return (-1);', 1003 'if ((%(var)s = malloc(%(varlen)s)) == NULL)', 1004 ' return (-1);', 1005 'if (evtag_unmarshal_fixed(%(buf)s, %(tag)s, %(var)s, ' 1006 '%(varlen)s) == -1) {', 1007 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 1008 ' return (-1);', 1009 '}' 1010 ] 1011 code = '\n'.join(code) % self.GetTranslation({ 1012 'buf' : buf, 1013 'tag' : tag_name, 1014 'var' : var_name, 1015 'varlen' : var_len }) 1016 return code.split('\n') 1017 1018 def CodeMarshal(self, buf, tag_name, var_name, var_len): 1019 code = ['evtag_marshal(%s, %s, %s, %s);' % ( 1020 buf, tag_name, var_name, var_len)] 1021 return code 1022 1023 def CodeClear(self, structname): 1024 code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()), 1025 ' free (%s->%s_data);' % (structname, self.Name()), 1026 ' %s->%s_data = NULL;' % (structname, self.Name()), 1027 ' %s->%s_length = 0;' % (structname, self.Name()), 1028 ' %s->%s_set = 0;' % (structname, self.Name()), 1029 '}' 1030 ] 1031 1032 return code 1033 1034 def CodeInitialize(self, name): 1035 code = ['%s->%s_data = NULL;' % (name, self._name), 1036 '%s->%s_length = 0;' % (name, self._name) ] 1037 return code 1038 1039 def CodeFree(self, name): 1040 code = ['if (%s->%s_data != NULL)' % (name, self._name), 1041 ' free(%s->%s_data);' % (name, self._name)] 1042 1043 return code 1044 1045 def Declaration(self): 1046 dcl = ['ev_uint8_t *%s_data;' % self._name, 1047 'ev_uint32_t %s_length;' % self._name] 1048 1049 return dcl 1050 1051 class EntryArray(Entry): 1052 def __init__(self, entry): 1053 # Init base class 1054 Entry.__init__(self, entry._type, entry._name, entry._tag) 1055 1056 self._entry = entry 1057 self._refname = entry._refname 1058 self._ctype = self._entry._ctype 1059 self._optional = True 1060 self._optpointer = self._entry._optpointer 1061 self._optaddarg = self._entry._optaddarg 1062 1063 # provide a new function for accessing the variable name 1064 def GetVarName(var_name): 1065 return '%(var)s->%(name)s_data[%(index)s]' % \ 1066 self._entry.GetTranslation({'var' : var_name, 1067 'index' : self._index}) 1068 self._entry.GetVarName = GetVarName 1069 1070 def GetInitializer(self): 1071 return "NULL" 1072 1073 def GetVarName(self, var_name): 1074 return var_name 1075 1076 def GetVarLen(self, var_name): 1077 return '-1' 1078 1079 def GetDeclaration(self, funcname): 1080 """Allows direct access to elements of the array.""" 1081 code = [ 1082 'int %(funcname)s(struct %(parent_name)s *, int, %(ctype)s *);' % 1083 self.GetTranslation({ 'funcname' : funcname }) ] 1084 return code 1085 1086 def AssignDeclaration(self, funcname): 1087 code = [ 'int %s(struct %s *, int, const %s);' % ( 1088 funcname, self._struct.Name(), self._ctype ) ] 1089 return code 1090 1091 def AddDeclaration(self, funcname): 1092 code = [ 1093 '%(ctype)s %(optpointer)s ' 1094 '%(funcname)s(struct %(parent_name)s *msg%(optaddarg)s);' % \ 1095 self.GetTranslation({ 'funcname' : funcname }) ] 1096 return code 1097 1098 def CodeGet(self): 1099 code = """int 1100 %(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, int offset, 1101 %(ctype)s *value) 1102 { 1103 if (!msg->%(name)s_set || offset < 0 || offset >= msg->%(name)s_length) 1104 return (-1); 1105 *value = msg->%(name)s_data[offset]; 1106 return (0); 1107 }""" % self.GetTranslation() 1108 1109 return code.split('\n') 1110 1111 def CodeAssign(self): 1112 code = [ 1113 'int', 1114 '%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, int off,', 1115 ' const %(ctype)s value)', 1116 '{', 1117 ' if (!msg->%(name)s_set || off < 0 || off >= msg->%(name)s_length)', 1118 ' return (-1);\n', 1119 ' {' ] 1120 code = TranslateList(code, self.GetTranslation()) 1121 1122 codearrayassign = self._entry.CodeArrayAssign( 1123 'msg->%(name)s_data[off]' % self.GetTranslation(), 'value') 1124 code += map(lambda x: ' ' + x, codearrayassign) 1125 1126 code += TranslateList([ 1127 ' }', 1128 ' return (0);', 1129 '}' ], self.GetTranslation()) 1130 1131 return code 1132 1133 def CodeAdd(self): 1134 codearrayadd = self._entry.CodeArrayAdd( 1135 'msg->%(name)s_data[msg->%(name)s_length - 1]' % self.GetTranslation(), 1136 'value') 1137 code = [ 1138 'static int', 1139 '%(parent_name)s_%(name)s_expand_to_hold_more(' 1140 'struct %(parent_name)s *msg)', 1141 '{', 1142 ' int tobe_allocated = msg->%(name)s_num_allocated;', 1143 ' %(ctype)s* new_data = NULL;', 1144 ' tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1;', 1145 ' new_data = (%(ctype)s*) realloc(msg->%(name)s_data,', 1146 ' tobe_allocated * sizeof(%(ctype)s));', 1147 ' if (new_data == NULL)', 1148 ' return -1;', 1149 ' msg->%(name)s_data = new_data;', 1150 ' msg->%(name)s_num_allocated = tobe_allocated;', 1151 ' return 0;' 1152 '}', 1153 '', 1154 '%(ctype)s %(optpointer)s', 1155 '%(parent_name)s_%(name)s_add(' 1156 'struct %(parent_name)s *msg%(optaddarg)s)', 1157 '{', 1158 ' if (++msg->%(name)s_length >= msg->%(name)s_num_allocated) {', 1159 ' if (%(parent_name)s_%(name)s_expand_to_hold_more(msg)<0)', 1160 ' goto error;', 1161 ' }' ] 1162 1163 code = TranslateList(code, self.GetTranslation()) 1164 1165 code += map(lambda x: ' ' + x, codearrayadd) 1166 1167 code += TranslateList([ 1168 ' msg->%(name)s_set = 1;', 1169 ' return %(optreference)s(msg->%(name)s_data[' 1170 'msg->%(name)s_length - 1]);', 1171 'error:', 1172 ' --msg->%(name)s_length;', 1173 ' return (NULL);', 1174 '}' ], self.GetTranslation()) 1175 1176 return code 1177 1178 def CodeComplete(self, structname, var_name): 1179 self._index = 'i' 1180 tmp = self._entry.CodeComplete(structname, self._entry.GetVarName(var_name)) 1181 # skip the whole loop if there is nothing to check 1182 if not tmp: 1183 return [] 1184 1185 translate = self.GetTranslation({ 'structname' : structname }) 1186 code = [ 1187 '{', 1188 ' int i;', 1189 ' for (i = 0; i < %(structname)s->%(name)s_length; ++i) {' ] 1190 1191 code = TranslateList(code, translate) 1192 1193 code += map(lambda x: ' ' + x, tmp) 1194 1195 code += [ 1196 ' }', 1197 '}' ] 1198 1199 return code 1200 1201 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 1202 translate = self.GetTranslation({ 'var' : var_name, 1203 'buf' : buf, 1204 'tag' : tag_name, 1205 'init' : self._entry.GetInitializer()}) 1206 code = [ 1207 'if (%(var)s->%(name)s_length >= %(var)s->%(name)s_num_allocated &&', 1208 ' %(parent_name)s_%(name)s_expand_to_hold_more(%(var)s) < 0) {', 1209 ' puts("HEY NOW");', 1210 ' return (-1);', 1211 '}'] 1212 1213 # the unmarshal code directly returns 1214 code = TranslateList(code, translate) 1215 1216 self._index = '%(var)s->%(name)s_length' % translate 1217 code += self._entry.CodeUnmarshal(buf, tag_name, 1218 self._entry.GetVarName(var_name), 1219 self._entry.GetVarLen(var_name)) 1220 1221 code += [ '++%(var)s->%(name)s_length;' % translate ] 1222 1223 return code 1224 1225 def CodeMarshal(self, buf, tag_name, var_name, var_len): 1226 code = ['{', 1227 ' int i;', 1228 ' for (i = 0; i < %(var)s->%(name)s_length; ++i) {' ] 1229 1230 self._index = 'i' 1231 code += self._entry.CodeMarshal(buf, tag_name, 1232 self._entry.GetVarName(var_name), 1233 self._entry.GetVarLen(var_name)) 1234 code += [' }', 1235 '}' 1236 ] 1237 1238 code = "\n".join(code) % self.GetTranslation({ 'var' : var_name }) 1239 1240 return code.split('\n') 1241 1242 def CodeClear(self, structname): 1243 translate = self.GetTranslation({ 'structname' : structname }) 1244 codearrayfree = self._entry.CodeArrayFree( 1245 '%(structname)s->%(name)s_data[i]' % self.GetTranslation( 1246 { 'structname' : structname } )) 1247 1248 code = [ 'if (%(structname)s->%(name)s_set == 1) {' ] 1249 1250 if codearrayfree: 1251 code += [ 1252 ' int i;', 1253 ' for (i = 0; i < %(structname)s->%(name)s_length; ++i) {' ] 1254 1255 code = TranslateList(code, translate) 1256 1257 if codearrayfree: 1258 code += map(lambda x: ' ' + x, codearrayfree) 1259 code += [ 1260 ' }' ] 1261 1262 code += TranslateList([ 1263 ' free(%(structname)s->%(name)s_data);', 1264 ' %(structname)s->%(name)s_data = NULL;', 1265 ' %(structname)s->%(name)s_set = 0;', 1266 ' %(structname)s->%(name)s_length = 0;', 1267 ' %(structname)s->%(name)s_num_allocated = 0;', 1268 '}' 1269 ], translate) 1270 1271 return code 1272 1273 def CodeInitialize(self, name): 1274 code = ['%s->%s_data = NULL;' % (name, self._name), 1275 '%s->%s_length = 0;' % (name, self._name), 1276 '%s->%s_num_allocated = 0;' % (name, self._name)] 1277 return code 1278 1279 def CodeFree(self, structname): 1280 code = self.CodeClear(structname); 1281 1282 code += TranslateList([ 1283 'free(%(structname)s->%(name)s_data);' ], 1284 self.GetTranslation({'structname' : structname })) 1285 1286 return code 1287 1288 def Declaration(self): 1289 dcl = ['%s *%s_data;' % (self._ctype, self._name), 1290 'int %s_length;' % self._name, 1291 'int %s_num_allocated;' % self._name ] 1292 1293 return dcl 1294 1295 def NormalizeLine(line): 1296 global white 1297 global cppcomment 1298 1299 line = cppcomment.sub('', line) 1300 line = line.strip() 1301 line = white.sub(' ', line) 1302 1303 return line 1304 1305 def ProcessOneEntry(factory, newstruct, entry): 1306 optional = 0 1307 array = 0 1308 entry_type = '' 1309 name = '' 1310 tag = '' 1311 tag_set = None 1312 separator = '' 1313 fixed_length = '' 1314 1315 tokens = entry.split(' ') 1316 while tokens: 1317 token = tokens[0] 1318 tokens = tokens[1:] 1319 1320 if not entry_type: 1321 if not optional and token == 'optional': 1322 optional = 1 1323 continue 1324 1325 if not array and token == 'array': 1326 array = 1 1327 continue 1328 1329 if not entry_type: 1330 entry_type = token 1331 continue 1332 1333 if not name: 1334 res = re.match(r'^([^\[\]]+)(\[.*\])?$', token) 1335 if not res: 1336 raise RpcGenError( 1337 'Cannot parse name: \"%s\" ' 1338 'around line %d' % (entry, line_count)) 1339 name = res.group(1) 1340 fixed_length = res.group(2) 1341 if fixed_length: 1342 fixed_length = fixed_length[1:-1] 1343 continue 1344 1345 if not separator: 1346 separator = token 1347 if separator != '=': 1348 raise RpcGenError('Expected "=" after name \"%s\" got %s' 1349 % (name, token)) 1350 continue 1351 1352 if not tag_set: 1353 tag_set = 1 1354 if not re.match(r'^(0x)?[0-9]+$', token): 1355 raise RpcGenError('Expected tag number: \"%s\"' % entry) 1356 tag = int(token, 0) 1357 continue 1358 1359 raise RpcGenError('Cannot parse \"%s\"' % entry) 1360 1361 if not tag_set: 1362 raise RpcGenError('Need tag number: \"%s\"' % entry) 1363 1364 # Create the right entry 1365 if entry_type == 'bytes': 1366 if fixed_length: 1367 newentry = factory.EntryBytes(entry_type, name, tag, fixed_length) 1368 else: 1369 newentry = factory.EntryVarBytes(entry_type, name, tag) 1370 elif entry_type == 'int' and not fixed_length: 1371 newentry = factory.EntryInt(entry_type, name, tag) 1372 elif entry_type == 'int64' and not fixed_length: 1373 newentry = factory.EntryInt(entry_type, name, tag, bits=64) 1374 elif entry_type == 'string' and not fixed_length: 1375 newentry = factory.EntryString(entry_type, name, tag) 1376 else: 1377 res = structref.match(entry_type) 1378 if res: 1379 # References another struct defined in our file 1380 newentry = factory.EntryStruct(entry_type, name, tag, res.group(1)) 1381 else: 1382 raise RpcGenError('Bad type: "%s" in "%s"' % (entry_type, entry)) 1383 1384 structs = [] 1385 1386 if optional: 1387 newentry.MakeOptional() 1388 if array: 1389 newentry.MakeArray() 1390 1391 newentry.SetStruct(newstruct) 1392 newentry.SetLineCount(line_count) 1393 newentry.Verify() 1394 1395 if array: 1396 # We need to encapsulate this entry into a struct 1397 newname = newentry.Name()+ '_array' 1398 1399 # Now borgify the new entry. 1400 newentry = factory.EntryArray(newentry) 1401 newentry.SetStruct(newstruct) 1402 newentry.SetLineCount(line_count) 1403 newentry.MakeArray() 1404 1405 newstruct.AddEntry(newentry) 1406 1407 return structs 1408 1409 def ProcessStruct(factory, data): 1410 tokens = data.split(' ') 1411 1412 # First three tokens are: 'struct' 'name' '{' 1413 newstruct = factory.Struct(tokens[1]) 1414 1415 inside = ' '.join(tokens[3:-1]) 1416 1417 tokens = inside.split(';') 1418 1419 structs = [] 1420 1421 for entry in tokens: 1422 entry = NormalizeLine(entry) 1423 if not entry: 1424 continue 1425 1426 # It's possible that new structs get defined in here 1427 structs.extend(ProcessOneEntry(factory, newstruct, entry)) 1428 1429 structs.append(newstruct) 1430 return structs 1431 1432 def GetNextStruct(file): 1433 global line_count 1434 global cppdirect 1435 1436 got_struct = 0 1437 1438 processed_lines = [] 1439 1440 have_c_comment = 0 1441 data = '' 1442 while 1: 1443 line = file.readline() 1444 if not line: 1445 break 1446 1447 line_count += 1 1448 line = line[:-1] 1449 1450 if not have_c_comment and re.search(r'/\*', line): 1451 if re.search(r'/\*.*?\*/', line): 1452 line = re.sub(r'/\*.*?\*/', '', line) 1453 else: 1454 line = re.sub(r'/\*.*$', '', line) 1455 have_c_comment = 1 1456 1457 if have_c_comment: 1458 if not re.search(r'\*/', line): 1459 continue 1460 have_c_comment = 0 1461 line = re.sub(r'^.*\*/', '', line) 1462 1463 line = NormalizeLine(line) 1464 1465 if not line: 1466 continue 1467 1468 if not got_struct: 1469 if re.match(r'#include ["<].*[>"]', line): 1470 cppdirect.append(line) 1471 continue 1472 1473 if re.match(r'^#(if( |def)|endif)', line): 1474 cppdirect.append(line) 1475 continue 1476 1477 if re.match(r'^#define', line): 1478 headerdirect.append(line) 1479 continue 1480 1481 if not structdef.match(line): 1482 raise RpcGenError('Missing struct on line %d: %s' 1483 % (line_count, line)) 1484 else: 1485 got_struct = 1 1486 data += line 1487 continue 1488 1489 # We are inside the struct 1490 tokens = line.split('}') 1491 if len(tokens) == 1: 1492 data += ' ' + line 1493 continue 1494 1495 if len(tokens[1]): 1496 raise RpcGenError('Trailing garbage after struct on line %d' 1497 % line_count) 1498 1499 # We found the end of the struct 1500 data += ' %s}' % tokens[0] 1501 break 1502 1503 # Remove any comments, that might be in there 1504 data = re.sub(r'/\*.*\*/', '', data) 1505 1506 return data 1507 1508 1509 def Parse(factory, file): 1510 """ 1511 Parses the input file and returns C code and corresponding header file. 1512 """ 1513 1514 entities = [] 1515 1516 while 1: 1517 # Just gets the whole struct nicely formatted 1518 data = GetNextStruct(file) 1519 1520 if not data: 1521 break 1522 1523 entities.extend(ProcessStruct(factory, data)) 1524 1525 return entities 1526 1527 class CCodeGenerator: 1528 def __init__(self): 1529 pass 1530 1531 def GuardName(self, name): 1532 # Use the complete provided path to the input file, with all 1533 # non-identifier characters replaced with underscores, to 1534 # reduce the chance of a collision between guard macros. 1535 return '_' + nonident.sub('_', name).upper() + '_' 1536 1537 def HeaderPreamble(self, name): 1538 guard = self.GuardName(name) 1539 pre = ( 1540 '/*\n' 1541 ' * Automatically generated from %s\n' 1542 ' */\n\n' 1543 '#ifndef %s\n' 1544 '#define %s\n\n' ) % ( 1545 name, guard, guard) 1546 1547 for statement in headerdirect: 1548 pre += '%s\n' % statement 1549 if headerdirect: 1550 pre += '\n' 1551 1552 pre += ( 1553 '#include <event2/util.h> /* for ev_uint*_t */\n' 1554 '#include <event2/rpc.h>\n' 1555 ) 1556 1557 return pre 1558 1559 def HeaderPostamble(self, name): 1560 guard = self.GuardName(name) 1561 return '#endif /* %s */' % guard 1562 1563 def BodyPreamble(self, name, header_file): 1564 global _NAME 1565 global _VERSION 1566 1567 slash = header_file.rfind('/') 1568 if slash != -1: 1569 header_file = header_file[slash+1:] 1570 1571 pre = ( '/*\n' 1572 ' * Automatically generated from %s\n' 1573 ' * by %s/%s. DO NOT EDIT THIS FILE.\n' 1574 ' */\n\n' ) % (name, _NAME, _VERSION) 1575 pre += ( '#include <stdlib.h>\n' 1576 '#include <string.h>\n' 1577 '#include <assert.h>\n' 1578 '#include <event2/event-config.h>\n' 1579 '#include <event2/event.h>\n' 1580 '#include <event2/buffer.h>\n' 1581 '#include <event2/tag.h>\n\n' 1582 '#ifdef _EVENT___func__\n' 1583 '#define __func__ _EVENT___func__\n' 1584 '#endif\n\n' 1585 ) 1586 1587 for statement in cppdirect: 1588 pre += '%s\n' % statement 1589 1590 pre += '\n#include "%s"\n\n' % header_file 1591 1592 pre += 'void event_warn(const char *fmt, ...);\n' 1593 pre += 'void event_warnx(const char *fmt, ...);\n\n' 1594 1595 return pre 1596 1597 def HeaderFilename(self, filename): 1598 return '.'.join(filename.split('.')[:-1]) + '.h' 1599 1600 def CodeFilename(self, filename): 1601 return '.'.join(filename.split('.')[:-1]) + '.gen.c' 1602 1603 def Struct(self, name): 1604 return StructCCode(name) 1605 1606 def EntryBytes(self, entry_type, name, tag, fixed_length): 1607 return EntryBytes(entry_type, name, tag, fixed_length) 1608 1609 def EntryVarBytes(self, entry_type, name, tag): 1610 return EntryVarBytes(entry_type, name, tag) 1611 1612 def EntryInt(self, entry_type, name, tag, bits=32): 1613 return EntryInt(entry_type, name, tag, bits) 1614 1615 def EntryString(self, entry_type, name, tag): 1616 return EntryString(entry_type, name, tag) 1617 1618 def EntryStruct(self, entry_type, name, tag, struct_name): 1619 return EntryStruct(entry_type, name, tag, struct_name) 1620 1621 def EntryArray(self, entry): 1622 return EntryArray(entry) 1623 1624 class Usage(RpcGenError): 1625 def __init__(self, argv0): 1626 RpcGenError.__init__("usage: %s input.rpc [[output.h] output.c]" 1627 % argv0) 1628 1629 class CommandLine: 1630 def __init__(self, argv): 1631 """Initialize a command-line to launch event_rpcgen, as if 1632 from a command-line with CommandLine(sys.argv). If you're 1633 calling this directly, remember to provide a dummy value 1634 for sys.argv[0] 1635 """ 1636 self.filename = None 1637 self.header_file = None 1638 self.impl_file = None 1639 self.factory = CCodeGenerator() 1640 1641 if len(argv) < 2 or len(argv) > 4: 1642 raise Usage(argv[0]) 1643 1644 self.filename = argv[1].replace('\\', '/') 1645 if len(argv) == 3: 1646 self.impl_file = argv[2].replace('\\', '/') 1647 if len(argv) == 4: 1648 self.header_file = argv[2].replace('\\', '/') 1649 self.impl_file = argv[3].replace('\\', '/') 1650 1651 if not self.filename: 1652 raise Usage(argv[0]) 1653 1654 if not self.impl_file: 1655 self.impl_file = self.factory.CodeFilename(self.filename) 1656 1657 if not self.header_file: 1658 self.header_file = self.factory.HeaderFilename(self.impl_file) 1659 1660 if not self.impl_file.endswith('.c'): 1661 raise RpcGenError("can only generate C implementation files") 1662 if not self.header_file.endswith('.h'): 1663 raise RpcGenError("can only generate C header files") 1664 1665 def run(self): 1666 filename = self.filename 1667 header_file = self.header_file 1668 impl_file = self.impl_file 1669 factory = self.factory 1670 1671 print >>sys.stderr, 'Reading \"%s\"' % filename 1672 1673 fp = open(filename, 'r') 1674 entities = Parse(factory, fp) 1675 fp.close() 1676 1677 print >>sys.stderr, '... creating "%s"' % header_file 1678 header_fp = open(header_file, 'w') 1679 print >>header_fp, factory.HeaderPreamble(filename) 1680 1681 # Create forward declarations: allows other structs to reference 1682 # each other 1683 for entry in entities: 1684 entry.PrintForwardDeclaration(header_fp) 1685 print >>header_fp, '' 1686 1687 for entry in entities: 1688 entry.PrintTags(header_fp) 1689 entry.PrintDeclaration(header_fp) 1690 print >>header_fp, factory.HeaderPostamble(filename) 1691 header_fp.close() 1692 1693 print >>sys.stderr, '... creating "%s"' % impl_file 1694 impl_fp = open(impl_file, 'w') 1695 print >>impl_fp, factory.BodyPreamble(filename, header_file) 1696 for entry in entities: 1697 entry.PrintCode(impl_fp) 1698 impl_fp.close() 1699 1700 if __name__ == '__main__': 1701 try: 1702 CommandLine(sys.argv).run() 1703 sys.exit(0) 1704 1705 except RpcGenError, e: 1706 print >>sys.stderr, e 1707 sys.exit(1) 1708 1709 except EnvironmentError, e: 1710 if e.filename and e.strerror: 1711 print >>sys.stderr, "%s: %s" % (e.filename, e.strerror) 1712 sys.exit(1) 1713 elif e.strerror: 1714 print >> sys.stderr, e.strerror 1715 sys.exit(1) 1716 else: 1717 raise 1718
