3 # Copyright (c) 2005 Niels Provos <provos@citi.umich.edu>
6 # Generates marshaling code based on libevent.
9 # 1) use optparse to allow the strategy shell to parse options, and
10 # to allow the instantiated factory (for the specific output language)
11 # to parse remaining options
12 # 2) move the globals into a class that manages execution (including the
13 # progress outputs that space stderr at the moment)
14 # 3) emit other languages
19 _NAME = "event_rpcgen.py"
25 white = re.compile(r'\s+')
26 cppcomment = re.compile(r'\/\/.*$')
27 nonident = re.compile(r'[^a-zA-Z0-9_]')
28 structref = re.compile(r'^struct\[([a-zA-Z_][a-zA-Z0-9_]*)\]$')
29 structdef = re.compile(r'^struct +[a-zA-Z_][a-zA-Z0-9_]* *{$')
34 def TranslateList(mylist, mydict):
35 return map(lambda x: x % mydict, mylist)
37 # Exception class for parse errors
38 class RpcGenError(Exception):
39 def __init__(self, why):
44 # Holds everything that makes a struct
46 def __init__(self, name):
50 print >>sys.stderr, ' Created struct: %s' % name
52 def AddEntry(self, entry):
53 if self._tags.has_key(entry.Tag()):
55 'Entry "%s" duplicates tag number %d from "%s" '
56 'around line %d' % (entry.Name(), entry.Tag(),
57 self._tags[entry.Tag()], line_count))
58 self._entries.append(entry)
59 self._tags[entry.Tag()] = entry.Name()
60 print >>sys.stderr, ' Added entry: %s' % entry.Name()
65 def EntryTagName(self, entry):
66 """Creates the name inside an enumeration for distinguishing data
68 name = "%s_%s" % (self._name, entry.Name())
71 def PrintIndented(self, file, ident, code):
72 """Takes an array, add indentation to each entry and prints it."""
74 print >>file, '%s%s' % (ident, entry)
76 class StructCCode(Struct):
77 """ Knows how to generate C code for a struct """
79 def __init__(self, name):
80 Struct.__init__(self, name)
82 def PrintTags(self, file):
83 """Prints the tag definitions for a structure."""
84 print >>file, '/* Tag definition for %s */' % self._name
85 print >>file, 'enum %s_ {' % self._name.lower()
86 for entry in self._entries:
87 print >>file, ' %s=%d,' % (self.EntryTagName(entry),
89 print >>file, ' %s_MAX_TAGS' % (self._name.upper())
92 def PrintForwardDeclaration(self, file):
93 print >>file, 'struct %s;' % self._name
95 def PrintDeclaration(self, file):
96 print >>file, '/* Structure declaration for %s */' % self._name
97 print >>file, 'struct %s_access_ {' % self._name
98 for entry in self._entries:
99 dcl = entry.AssignDeclaration('(*%s_assign)' % entry.Name())
101 entry.GetDeclaration('(*%s_get)' % entry.Name()))
104 entry.AddDeclaration('(*%s_add)' % entry.Name()))
105 self.PrintIndented(file, ' ', dcl)
108 print >>file, 'struct %s {' % self._name
109 print >>file, ' struct %s_access_ *base;\n' % self._name
110 for entry in self._entries:
111 dcl = entry.Declaration()
112 self.PrintIndented(file, ' ', dcl)
114 for entry in self._entries:
115 print >>file, ' ev_uint8_t %s_set;' % entry.Name()
119 """struct %(name)s *%(name)s_new(void);
120 struct %(name)s *%(name)s_new_with_arg(void *);
121 void %(name)s_free(struct %(name)s *);
122 void %(name)s_clear(struct %(name)s *);
123 void %(name)s_marshal(struct evbuffer *, const struct %(name)s *);
124 int %(name)s_unmarshal(struct %(name)s *, struct evbuffer *);
125 int %(name)s_complete(struct %(name)s *);
126 void evtag_marshal_%(name)s(struct evbuffer *, ev_uint32_t,
127 const struct %(name)s *);
128 int evtag_unmarshal_%(name)s(struct evbuffer *, ev_uint32_t,
129 struct %(name)s *);""" % { 'name' : self._name }
132 # Write a setting function of every variable
133 for entry in self._entries:
134 self.PrintIndented(file, '', entry.AssignDeclaration(
135 entry.AssignFuncName()))
136 self.PrintIndented(file, '', entry.GetDeclaration(
137 entry.GetFuncName()))
139 self.PrintIndented(file, '', entry.AddDeclaration(
140 entry.AddFuncName()))
142 print >>file, '/* --- %s done --- */\n' % self._name
144 def PrintCode(self, file):
145 print >>file, ('/*\n'
146 ' * Implementation of %s\n'
147 ' */\n') % self._name
150 'static struct %(name)s_access_ __%(name)s_base = {' % \
151 { 'name' : self._name }
152 for entry in self._entries:
153 self.PrintIndented(file, ' ', entry.CodeBase())
158 'struct %(name)s *\n'
159 '%(name)s_new(void)\n'
161 ' return %(name)s_new_with_arg(NULL);\n'
164 'struct %(name)s *\n'
165 '%(name)s_new_with_arg(void *unused)\n'
167 ' struct %(name)s *tmp;\n'
168 ' if ((tmp = malloc(sizeof(struct %(name)s))) == NULL) {\n'
169 ' event_warn("%%s: malloc", __func__);\n'
172 ' tmp->base = &__%(name)s_base;\n') % { 'name' : self._name }
174 for entry in self._entries:
175 self.PrintIndented(file, ' ', entry.CodeInitialize('tmp'))
176 print >>file, ' tmp->%s_set = 0;\n' % entry.Name()
183 for entry in self._entries:
185 self.PrintIndented(file, '', entry.CodeAdd())
189 for entry in self._entries:
190 self.PrintIndented(file, '', entry.CodeAssign())
194 for entry in self._entries:
195 self.PrintIndented(file, '', entry.CodeGet())
199 print >>file, ( 'void\n'
200 '%(name)s_clear(struct %(name)s *tmp)\n'
202 ) % { 'name' : self._name }
203 for entry in self._entries:
204 self.PrintIndented(file, ' ', entry.CodeClear('tmp'))
209 print >>file, ( 'void\n'
210 '%(name)s_free(struct %(name)s *tmp)\n'
212 ) % { 'name' : self._name }
214 for entry in self._entries:
215 self.PrintIndented(file, ' ', entry.CodeFree('tmp'))
217 print >>file, (' free(tmp);\n'
221 print >>file, ('void\n'
222 '%(name)s_marshal(struct evbuffer *evbuf, '
223 'const struct %(name)s *tmp)'
224 '{') % { 'name' : self._name }
225 for entry in self._entries:
227 # Optional entries do not have to be set
230 print >>file, ' if (tmp->%s_set) {' % entry.Name()
233 entry.CodeMarshal('evbuf', self.EntryTagName(entry),
234 entry.GetVarName('tmp'),
235 entry.GetVarLen('tmp')))
242 print >>file, ('int\n'
243 '%(name)s_unmarshal(struct %(name)s *tmp, '
244 ' struct evbuffer *evbuf)\n'
246 ' ev_uint32_t tag;\n'
247 ' while (evbuffer_get_length(evbuf) > 0) {\n'
248 ' if (evtag_peek(evbuf, &tag) == -1)\n'
251 ) % { 'name' : self._name }
252 for entry in self._entries:
253 print >>file, ' case %s:\n' % self.EntryTagName(entry)
254 if not entry.Array():
256 ' if (tmp->%s_set)\n'
262 entry.CodeUnmarshal('evbuf',
263 self.EntryTagName(entry),
264 entry.GetVarName('tmp'),
265 entry.GetVarLen('tmp')))
267 print >>file, ( ' tmp->%s_set = 1;\n' % entry.Name() +
269 print >>file, ( ' default:\n'
273 # Check if it was decoded completely
274 print >>file, ( ' if (%(name)s_complete(tmp) == -1)\n'
276 ) % { 'name' : self._name }
278 # Successfully decoded
279 print >>file, ( ' return (0);\n'
282 # Checking if a structure has all the required data
285 '%(name)s_complete(struct %(name)s *msg)\n'
286 '{' ) % { 'name' : self._name }
287 for entry in self._entries:
288 if not entry.Optional():
290 'if (!msg->%(name)s_set)',
292 code = TranslateList(code, entry.GetTranslation())
298 entry.CodeComplete('msg', entry.GetVarName('msg')))
303 # Complete message unmarshaling
306 'evtag_unmarshal_%(name)s(struct evbuffer *evbuf, '
307 'ev_uint32_t need_tag, struct %(name)s *msg)\n'
309 ' ev_uint32_t tag;\n'
312 ' struct evbuffer *tmp = evbuffer_new();\n'
314 ' if (evtag_unmarshal(evbuf, &tag, tmp) == -1'
315 ' || tag != need_tag)\n'
318 ' if (%(name)s_unmarshal(msg, tmp) == -1)\n'
324 ' evbuffer_free(tmp);\n'
326 '}\n' ) % { 'name' : self._name }
328 # Complete message marshaling
331 'evtag_marshal_%(name)s(struct evbuffer *evbuf, ev_uint32_t tag, '
332 'const struct %(name)s *msg)\n'
334 ' struct evbuffer *_buf = evbuffer_new();\n'
335 ' assert(_buf != NULL);\n'
336 ' %(name)s_marshal(_buf, msg);\n'
337 ' evtag_marshal_buffer(evbuf, tag, _buf);\n '
338 ' evbuffer_free(_buf);\n'
339 '}\n' ) % { 'name' : self._name }
342 def __init__(self, type, name, tag):
348 self._can_be_array = 0
350 self._line_count = -1
354 self._optpointer = True
355 self._optaddarg = True
357 def GetInitializer(self):
358 assert 0, "Entry does not provide initializer"
360 def SetStruct(self, struct):
361 self._struct = struct
364 assert self._line_count != -1
365 return self._line_count
367 def SetLineCount(self, number):
368 self._line_count = number
374 return self._optional
385 def MakeArray(self, yes=1):
388 def MakeOptional(self):
392 if self.Array() and not self._can_be_array:
394 'Entry "%s" cannot be created as an array '
395 'around line %d' % (self._name, self.LineCount()))
398 'Entry "%s" does not know which struct it belongs to '
399 'around line %d' % (self._name, self.LineCount()))
400 if self._optional and self._array:
402 'Entry "%s" has illegal combination of optional and array '
403 'around line %d' % (self._name, self.LineCount()))
405 def GetTranslation(self, extradict = {}):
407 "parent_name" : self._struct.Name(),
409 "ctype" : self._ctype,
410 "refname" : self._refname,
411 "optpointer" : self._optpointer and "*" or "",
412 "optreference" : self._optpointer and "&" or "",
414 self._optaddarg and ", const %s value" % self._ctype or ""
416 for (k, v) in extradict.items():
421 def GetVarName(self, var):
422 return '%(var)s->%(name)s_data' % self.GetTranslation({ 'var' : var })
424 def GetVarLen(self, var):
425 return 'sizeof(%s)' % self._ctype
427 def GetFuncName(self):
428 return '%s_%s_get' % (self._struct.Name(), self._name)
430 def GetDeclaration(self, funcname):
431 code = [ 'int %s(struct %s *, %s *);' % (
432 funcname, self._struct.Name(), self._ctype ) ]
438 '%(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, '
441 ' if (msg->%(name)s_set != 1)',
443 ' *value = msg->%(name)s_data;',
446 code = '\n'.join(code)
447 code = code % self.GetTranslation()
448 return code.split('\n')
450 def AssignFuncName(self):
451 return '%s_%s_assign' % (self._struct.Name(), self._name)
453 def AddFuncName(self):
454 return '%s_%s_add' % (self._struct.Name(), self._name)
456 def AssignDeclaration(self, funcname):
457 code = [ 'int %s(struct %s *, const %s);' % (
458 funcname, self._struct.Name(), self._ctype ) ]
461 def CodeAssign(self):
463 '%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,'
464 ' const %(ctype)s value)',
466 ' msg->%(name)s_set = 1;',
467 ' msg->%(name)s_data = value;',
470 code = '\n'.join(code)
471 code = code % self.GetTranslation()
472 return code.split('\n')
474 def CodeClear(self, structname):
475 code = [ '%s->%s_set = 0;' % (structname, self.Name()) ]
479 def CodeComplete(self, structname, var_name):
482 def CodeFree(self, name):
487 '%(parent_name)s_%(name)s_assign,',
488 '%(parent_name)s_%(name)s_get,'
491 code.append('%(parent_name)s_%(name)s_add,')
493 code = '\n'.join(code)
494 code = code % self.GetTranslation()
495 return code.split('\n')
497 class EntryBytes(Entry):
498 def __init__(self, type, name, tag, length):
500 Entry.__init__(self, type, name, tag)
502 self._length = length
503 self._ctype = 'ev_uint8_t'
505 def GetInitializer(self):
508 def GetVarLen(self, var):
509 return '(%s)' % self._length
511 def CodeArrayAdd(self, varname, value):
513 return [ '%(varname)s = NULL;' % { 'varname' : varname } ]
515 def GetDeclaration(self, funcname):
516 code = [ 'int %s(struct %s *, %s **);' % (
517 funcname, self._struct.Name(), self._ctype ) ]
520 def AssignDeclaration(self, funcname):
521 code = [ 'int %s(struct %s *, const %s *);' % (
522 funcname, self._struct.Name(), self._ctype ) ]
525 def Declaration(self):
526 dcl = ['ev_uint8_t %s_data[%s];' % (self._name, self._length)]
533 '%s_%s_get(struct %s *msg, %s **value)' % (
534 self._struct.Name(), name,
535 self._struct.Name(), self._ctype),
537 ' if (msg->%s_set != 1)' % name,
539 ' *value = msg->%s_data;' % name,
544 def CodeAssign(self):
547 '%s_%s_assign(struct %s *msg, const %s *value)' % (
548 self._struct.Name(), name,
549 self._struct.Name(), self._ctype),
551 ' msg->%s_set = 1;' % name,
552 ' memcpy(msg->%s_data, value, %s);' % (
558 def CodeUnmarshal(self, buf, tag_name, var_name, var_len):
559 code = [ 'if (evtag_unmarshal_fixed(%(buf)s, %(tag)s, '
560 '%(var)s, %(varlen)s) == -1) {',
561 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);',
565 return TranslateList(code,
566 self.GetTranslation({
572 def CodeMarshal(self, buf, tag_name, var_name, var_len):
573 code = ['evtag_marshal(%s, %s, %s, %s);' % (
574 buf, tag_name, var_name, var_len)]
577 def CodeClear(self, structname):
578 code = [ '%s->%s_set = 0;' % (structname, self.Name()),
579 'memset(%s->%s_data, 0, sizeof(%s->%s_data));' % (
580 structname, self._name, structname, self._name)]
584 def CodeInitialize(self, name):
585 code = ['memset(%s->%s_data, 0, sizeof(%s->%s_data));' % (
586 name, self._name, name, self._name)]
592 'Entry "%s" needs a length '
593 'around line %d' % (self._name, self.LineCount()))
597 class EntryInt(Entry):
598 def __init__(self, type, name, tag, bits=32):
600 Entry.__init__(self, type, name, tag)
602 self._can_be_array = 1
604 self._ctype = 'ev_uint32_t'
605 self._marshal_type = 'int'
607 self._ctype = 'ev_uint64_t'
608 self._marshal_type = 'int64'
610 def GetInitializer(self):
613 def CodeArrayFree(self, var):
616 def CodeArrayAssign(self, varname, srcvar):
617 return [ '%(varname)s = %(srcvar)s;' % { 'varname' : varname,
618 'srcvar' : srcvar } ]
620 def CodeArrayAdd(self, varname, value):
621 """Returns a new entry of this type."""
622 return [ '%(varname)s = %(value)s;' % { 'varname' : varname,
625 def CodeUnmarshal(self, buf, tag_name, var_name, var_len):
627 'if (evtag_unmarshal_%(ma)s(%(buf)s, %(tag)s, &%(var)s) == -1) {',
628 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);',
631 code = '\n'.join(code) % self.GetTranslation({
632 'ma' : self._marshal_type,
636 return code.split('\n')
638 def CodeMarshal(self, buf, tag_name, var_name, var_len):
640 'evtag_marshal_%s(%s, %s, %s);' % (
641 self._marshal_type, buf, tag_name, var_name)]
644 def Declaration(self):
645 dcl = ['%s %s_data;' % (self._ctype, self._name)]
649 def CodeInitialize(self, name):
650 code = ['%s->%s_data = 0;' % (name, self._name)]
653 class EntryString(Entry):
654 def __init__(self, type, name, tag):
656 Entry.__init__(self, type, name, tag)
658 self._can_be_array = 1
659 self._ctype = 'char *'
661 def GetInitializer(self):
664 def CodeArrayFree(self, varname):
666 'if (%(var)s != NULL) free(%(var)s);' ]
668 return TranslateList(code, { 'var' : varname })
670 def CodeArrayAssign(self, varname, srcvar):
672 'if (%(var)s != NULL)',
674 '%(var)s = strdup(%(srcvar)s);',
675 'if (%(var)s == NULL) {',
676 ' event_warnx("%%s: strdup", __func__);',
680 return TranslateList(code, { 'var' : varname,
683 def CodeArrayAdd(self, varname, value):
685 'if (%(value)s != NULL) {',
686 ' %(var)s = strdup(%(value)s);',
687 ' if (%(var)s == NULL) {',
694 return TranslateList(code, { 'var' : varname,
697 def GetVarLen(self, var):
698 return 'strlen(%s)' % self.GetVarName(var)
700 def CodeMakeInitalize(self, varname):
701 return '%(varname)s = NULL;' % { 'varname' : varname }
703 def CodeAssign(self):
706 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,
707 const %(ctype)s value)
709 if (msg->%(name)s_data != NULL)
710 free(msg->%(name)s_data);
711 if ((msg->%(name)s_data = strdup(value)) == NULL)
713 msg->%(name)s_set = 1;
715 }""" % self.GetTranslation()
717 return code.split('\n')
719 def CodeUnmarshal(self, buf, tag_name, var_name, var_len):
720 code = ['if (evtag_unmarshal_string(%(buf)s, %(tag)s, &%(var)s) == -1) {',
721 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);',
725 code = '\n'.join(code) % self.GetTranslation({
729 return code.split('\n')
731 def CodeMarshal(self, buf, tag_name, var_name, var_len):
732 code = ['evtag_marshal_string(%s, %s, %s);' % (
733 buf, tag_name, var_name)]
736 def CodeClear(self, structname):
737 code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),
738 ' free(%s->%s_data);' % (structname, self.Name()),
739 ' %s->%s_data = NULL;' % (structname, self.Name()),
740 ' %s->%s_set = 0;' % (structname, self.Name()),
746 def CodeInitialize(self, name):
747 code = ['%s->%s_data = NULL;' % (name, self._name)]
750 def CodeFree(self, name):
751 code = ['if (%s->%s_data != NULL)' % (name, self._name),
752 ' free (%s->%s_data);' % (name, self._name)]
756 def Declaration(self):
757 dcl = ['char *%s_data;' % self._name]
761 class EntryStruct(Entry):
762 def __init__(self, type, name, tag, refname):
764 Entry.__init__(self, type, name, tag)
766 self._optpointer = False
767 self._can_be_array = 1
768 self._refname = refname
769 self._ctype = 'struct %s*' % refname
770 self._optaddarg = False
772 def GetInitializer(self):
775 def GetVarLen(self, var):
778 def CodeArrayAdd(self, varname, value):
780 '%(varname)s = %(refname)s_new();',
781 'if (%(varname)s == NULL)',
784 return TranslateList(code, self.GetTranslation({ 'varname' : varname }))
786 def CodeArrayFree(self, var):
787 code = [ '%(refname)s_free(%(var)s);' % self.GetTranslation(
791 def CodeArrayAssign(self, var, srcvar):
793 'int had_error = 0;',
794 'struct evbuffer *tmp = NULL;',
795 '%(refname)s_clear(%(var)s);',
796 'if ((tmp = evbuffer_new()) == NULL) {',
797 ' event_warn("%%s: evbuffer_new()", __func__);',
801 '%(refname)s_marshal(tmp, %(srcvar)s);',
802 'if (%(refname)s_unmarshal(%(var)s, tmp) == -1) {',
803 ' event_warnx("%%s: %(refname)s_unmarshal", __func__);',
809 ' evbuffer_free(tmp);',
811 ' %(refname)s_clear(%(var)s);',
815 return TranslateList(code, self.GetTranslation({
822 '%s_%s_get(struct %s *msg, %s *value)' % (
823 self._struct.Name(), name,
824 self._struct.Name(), self._ctype),
826 ' if (msg->%s_set != 1) {' % name,
827 ' msg->%s_data = %s_new();' % (name, self._refname),
828 ' if (msg->%s_data == NULL)' % name,
830 ' msg->%s_set = 1;' % name,
832 ' *value = msg->%s_data;' % name,
837 def CodeAssign(self):
840 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,
841 const %(ctype)s value)
843 struct evbuffer *tmp = NULL;
844 if (msg->%(name)s_set) {
845 %(refname)s_clear(msg->%(name)s_data);
846 msg->%(name)s_set = 0;
848 msg->%(name)s_data = %(refname)s_new();
849 if (msg->%(name)s_data == NULL) {
850 event_warn("%%s: %(refname)s_new()", __func__);
854 if ((tmp = evbuffer_new()) == NULL) {
855 event_warn("%%s: evbuffer_new()", __func__);
858 %(refname)s_marshal(tmp, value);
859 if (%(refname)s_unmarshal(msg->%(name)s_data, tmp) == -1) {
860 event_warnx("%%s: %(refname)s_unmarshal", __func__);
863 msg->%(name)s_set = 1;
869 if (msg->%(name)s_data != NULL) {
870 %(refname)s_free(msg->%(name)s_data);
871 msg->%(name)s_data = NULL;
874 }""" % self.GetTranslation()
875 return code.split('\n')
877 def CodeComplete(self, structname, var_name):
878 code = [ 'if (%(structname)s->%(name)s_set && '
879 '%(refname)s_complete(%(var)s) == -1)',
882 return TranslateList(code, self.GetTranslation({
883 'structname' : structname,
886 def CodeUnmarshal(self, buf, tag_name, var_name, var_len):
887 code = ['%(var)s = %(refname)s_new();',
888 'if (%(var)s == NULL)',
890 'if (evtag_unmarshal_%(refname)s(%(buf)s, %(tag)s, '
892 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);',
896 code = '\n'.join(code) % self.GetTranslation({
900 return code.split('\n')
902 def CodeMarshal(self, buf, tag_name, var_name, var_len):
903 code = ['evtag_marshal_%s(%s, %s, %s);' % (
904 self._refname, buf, tag_name, var_name)]
907 def CodeClear(self, structname):
908 code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),
909 ' %s_free(%s->%s_data);' % (
910 self._refname, structname, self.Name()),
911 ' %s->%s_data = NULL;' % (structname, self.Name()),
912 ' %s->%s_set = 0;' % (structname, self.Name()),
918 def CodeInitialize(self, name):
919 code = ['%s->%s_data = NULL;' % (name, self._name)]
922 def CodeFree(self, name):
923 code = ['if (%s->%s_data != NULL)' % (name, self._name),
924 ' %s_free(%s->%s_data);' % (
925 self._refname, name, self._name)]
929 def Declaration(self):
930 dcl = ['%s %s_data;' % (self._ctype, self._name)]
934 class EntryVarBytes(Entry):
935 def __init__(self, type, name, tag):
937 Entry.__init__(self, type, name, tag)
939 self._ctype = 'ev_uint8_t *'
941 def GetInitializer(self):
944 def GetVarLen(self, var):
945 return '%(var)s->%(name)s_length' % self.GetTranslation({ 'var' : var })
947 def CodeArrayAdd(self, varname, value):
949 return [ '%(varname)s = NULL;' % { 'varname' : varname } ]
951 def GetDeclaration(self, funcname):
952 code = [ 'int %s(struct %s *, %s *, ev_uint32_t *);' % (
953 funcname, self._struct.Name(), self._ctype ) ]
956 def AssignDeclaration(self, funcname):
957 code = [ 'int %s(struct %s *, const %s, ev_uint32_t);' % (
958 funcname, self._struct.Name(), self._ctype ) ]
961 def CodeAssign(self):
964 '%s_%s_assign(struct %s *msg, '
965 'const %s value, ev_uint32_t len)' % (
966 self._struct.Name(), name,
967 self._struct.Name(), self._ctype),
969 ' if (msg->%s_data != NULL)' % name,
970 ' free (msg->%s_data);' % name,
971 ' msg->%s_data = malloc(len);' % name,
972 ' if (msg->%s_data == NULL)' % name,
974 ' msg->%s_set = 1;' % name,
975 ' msg->%s_length = len;' % name,
976 ' memcpy(msg->%s_data, value, len);' % name,
984 '%s_%s_get(struct %s *msg, %s *value, ev_uint32_t *plen)' % (
985 self._struct.Name(), name,
986 self._struct.Name(), self._ctype),
988 ' if (msg->%s_set != 1)' % name,
990 ' *value = msg->%s_data;' % name,
991 ' *plen = msg->%s_length;' % name,
996 def CodeUnmarshal(self, buf, tag_name, var_name, var_len):
997 code = ['if (evtag_payload_length(%(buf)s, &%(varlen)s) == -1)',
999 # We do not want DoS opportunities
1000 'if (%(varlen)s > evbuffer_get_length(%(buf)s))',
1002 'if ((%(var)s = malloc(%(varlen)s)) == NULL)',
1004 'if (evtag_unmarshal_fixed(%(buf)s, %(tag)s, %(var)s, '
1005 '%(varlen)s) == -1) {',
1006 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);',
1010 code = '\n'.join(code) % self.GetTranslation({
1014 'varlen' : var_len })
1015 return code.split('\n')
1017 def CodeMarshal(self, buf, tag_name, var_name, var_len):
1018 code = ['evtag_marshal(%s, %s, %s, %s);' % (
1019 buf, tag_name, var_name, var_len)]
1022 def CodeClear(self, structname):
1023 code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),
1024 ' free (%s->%s_data);' % (structname, self.Name()),
1025 ' %s->%s_data = NULL;' % (structname, self.Name()),
1026 ' %s->%s_length = 0;' % (structname, self.Name()),
1027 ' %s->%s_set = 0;' % (structname, self.Name()),
1033 def CodeInitialize(self, name):
1034 code = ['%s->%s_data = NULL;' % (name, self._name),
1035 '%s->%s_length = 0;' % (name, self._name) ]
1038 def CodeFree(self, name):
1039 code = ['if (%s->%s_data != NULL)' % (name, self._name),
1040 ' free(%s->%s_data);' % (name, self._name)]
1044 def Declaration(self):
1045 dcl = ['ev_uint8_t *%s_data;' % self._name,
1046 'ev_uint32_t %s_length;' % self._name]
1050 class EntryArray(Entry):
1051 def __init__(self, entry):
1053 Entry.__init__(self, entry._type, entry._name, entry._tag)
1056 self._refname = entry._refname
1057 self._ctype = self._entry._ctype
1058 self._optional = True
1059 self._optpointer = self._entry._optpointer
1060 self._optaddarg = self._entry._optaddarg
1062 # provide a new function for accessing the variable name
1063 def GetVarName(var_name):
1064 return '%(var)s->%(name)s_data[%(index)s]' % \
1065 self._entry.GetTranslation({'var' : var_name,
1066 'index' : self._index})
1067 self._entry.GetVarName = GetVarName
1069 def GetInitializer(self):
1072 def GetVarName(self, var_name):
1075 def GetVarLen(self, var_name):
1078 def GetDeclaration(self, funcname):
1079 """Allows direct access to elements of the array."""
1081 'int %(funcname)s(struct %(parent_name)s *, int, %(ctype)s *);' %
1082 self.GetTranslation({ 'funcname' : funcname }) ]
1085 def AssignDeclaration(self, funcname):
1086 code = [ 'int %s(struct %s *, int, const %s);' % (
1087 funcname, self._struct.Name(), self._ctype ) ]
1090 def AddDeclaration(self, funcname):
1092 '%(ctype)s %(optpointer)s '
1093 '%(funcname)s(struct %(parent_name)s *msg%(optaddarg)s);' % \
1094 self.GetTranslation({ 'funcname' : funcname }) ]
1099 %(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, int offset,
1102 if (!msg->%(name)s_set || offset < 0 || offset >= msg->%(name)s_length)
1104 *value = msg->%(name)s_data[offset];
1106 }""" % self.GetTranslation()
1108 return code.split('\n')
1110 def CodeAssign(self):
1113 '%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, int off,',
1114 ' const %(ctype)s value)',
1116 ' if (!msg->%(name)s_set || off < 0 || off >= msg->%(name)s_length)',
1119 code = TranslateList(code, self.GetTranslation())
1121 codearrayassign = self._entry.CodeArrayAssign(
1122 'msg->%(name)s_data[off]' % self.GetTranslation(), 'value')
1123 code += map(lambda x: ' ' + x, codearrayassign)
1125 code += TranslateList([
1128 '}' ], self.GetTranslation())
1133 codearrayadd = self._entry.CodeArrayAdd(
1134 'msg->%(name)s_data[msg->%(name)s_length - 1]' % self.GetTranslation(),
1138 '%(parent_name)s_%(name)s_expand_to_hold_more('
1139 'struct %(parent_name)s *msg)',
1141 ' int tobe_allocated = msg->%(name)s_num_allocated;',
1142 ' %(ctype)s* new_data = NULL;',
1143 ' tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1;',
1144 ' new_data = (%(ctype)s*) realloc(msg->%(name)s_data,',
1145 ' tobe_allocated * sizeof(%(ctype)s));',
1146 ' if (new_data == NULL)',
1148 ' msg->%(name)s_data = new_data;',
1149 ' msg->%(name)s_num_allocated = tobe_allocated;',
1153 '%(ctype)s %(optpointer)s',
1154 '%(parent_name)s_%(name)s_add('
1155 'struct %(parent_name)s *msg%(optaddarg)s)',
1157 ' if (++msg->%(name)s_length >= msg->%(name)s_num_allocated) {',
1158 ' if (%(parent_name)s_%(name)s_expand_to_hold_more(msg)<0)',
1162 code = TranslateList(code, self.GetTranslation())
1164 code += map(lambda x: ' ' + x, codearrayadd)
1166 code += TranslateList([
1167 ' msg->%(name)s_set = 1;',
1168 ' return %(optreference)s(msg->%(name)s_data['
1169 'msg->%(name)s_length - 1]);',
1171 ' --msg->%(name)s_length;',
1173 '}' ], self.GetTranslation())
1177 def CodeComplete(self, structname, var_name):
1179 tmp = self._entry.CodeComplete(structname, self._entry.GetVarName(var_name))
1180 # skip the whole loop if there is nothing to check
1184 translate = self.GetTranslation({ 'structname' : structname })
1188 ' for (i = 0; i < %(structname)s->%(name)s_length; ++i) {' ]
1190 code = TranslateList(code, translate)
1192 code += map(lambda x: ' ' + x, tmp)
1200 def CodeUnmarshal(self, buf, tag_name, var_name, var_len):
1201 translate = self.GetTranslation({ 'var' : var_name,
1204 'init' : self._entry.GetInitializer()})
1206 'if (%(var)s->%(name)s_length >= %(var)s->%(name)s_num_allocated &&',
1207 ' %(parent_name)s_%(name)s_expand_to_hold_more(%(var)s) < 0) {',
1208 ' puts("HEY NOW");',
1212 # the unmarshal code directly returns
1213 code = TranslateList(code, translate)
1215 self._index = '%(var)s->%(name)s_length' % translate
1216 code += self._entry.CodeUnmarshal(buf, tag_name,
1217 self._entry.GetVarName(var_name),
1218 self._entry.GetVarLen(var_name))
1220 code += [ '++%(var)s->%(name)s_length;' % translate ]
1224 def CodeMarshal(self, buf, tag_name, var_name, var_len):
1227 ' for (i = 0; i < %(var)s->%(name)s_length; ++i) {' ]
1230 code += self._entry.CodeMarshal(buf, tag_name,
1231 self._entry.GetVarName(var_name),
1232 self._entry.GetVarLen(var_name))
1237 code = "\n".join(code) % self.GetTranslation({ 'var' : var_name })
1239 return code.split('\n')
1241 def CodeClear(self, structname):
1242 translate = self.GetTranslation({ 'structname' : structname })
1243 codearrayfree = self._entry.CodeArrayFree(
1244 '%(structname)s->%(name)s_data[i]' % self.GetTranslation(
1245 { 'structname' : structname } ))
1247 code = [ 'if (%(structname)s->%(name)s_set == 1) {' ]
1252 ' for (i = 0; i < %(structname)s->%(name)s_length; ++i) {' ]
1254 code = TranslateList(code, translate)
1257 code += map(lambda x: ' ' + x, codearrayfree)
1261 code += TranslateList([
1262 ' free(%(structname)s->%(name)s_data);',
1263 ' %(structname)s->%(name)s_data = NULL;',
1264 ' %(structname)s->%(name)s_set = 0;',
1265 ' %(structname)s->%(name)s_length = 0;',
1266 ' %(structname)s->%(name)s_num_allocated = 0;',
1272 def CodeInitialize(self, name):
1273 code = ['%s->%s_data = NULL;' % (name, self._name),
1274 '%s->%s_length = 0;' % (name, self._name),
1275 '%s->%s_num_allocated = 0;' % (name, self._name)]
1278 def CodeFree(self, structname):
1279 code = self.CodeClear(structname);
1281 code += TranslateList([
1282 'free(%(structname)s->%(name)s_data);' ],
1283 self.GetTranslation({'structname' : structname }))
1287 def Declaration(self):
1288 dcl = ['%s *%s_data;' % (self._ctype, self._name),
1289 'int %s_length;' % self._name,
1290 'int %s_num_allocated;' % self._name ]
1294 def NormalizeLine(line):
1298 line = cppcomment.sub('', line)
1300 line = white.sub(' ', line)
1304 def ProcessOneEntry(factory, newstruct, entry):
1314 tokens = entry.split(' ')
1320 if not optional and token == 'optional':
1324 if not array and token == 'array':
1333 res = re.match(r'^([^\[\]]+)(\[.*\])?$', token)
1336 'Cannot parse name: \"%s\" '
1337 'around line %d' % (entry, line_count))
1339 fixed_length = res.group(2)
1341 fixed_length = fixed_length[1:-1]
1346 if separator != '=':
1347 raise RpcGenError('Expected "=" after name \"%s\" got %s'
1353 if not re.match(r'^(0x)?[0-9]+$', token):
1354 raise RpcGenError('Expected tag number: \"%s\"' % entry)
1358 raise RpcGenError('Cannot parse \"%s\"' % entry)
1361 raise RpcGenError('Need tag number: \"%s\"' % entry)
1363 # Create the right entry
1364 if entry_type == 'bytes':
1366 newentry = factory.EntryBytes(entry_type, name, tag, fixed_length)
1368 newentry = factory.EntryVarBytes(entry_type, name, tag)
1369 elif entry_type == 'int' and not fixed_length:
1370 newentry = factory.EntryInt(entry_type, name, tag)
1371 elif entry_type == 'int64' and not fixed_length:
1372 newentry = factory.EntryInt(entry_type, name, tag, bits=64)
1373 elif entry_type == 'string' and not fixed_length:
1374 newentry = factory.EntryString(entry_type, name, tag)
1376 res = structref.match(entry_type)
1378 # References another struct defined in our file
1379 newentry = factory.EntryStruct(entry_type, name, tag, res.group(1))
1381 raise RpcGenError('Bad type: "%s" in "%s"' % (entry_type, entry))
1386 newentry.MakeOptional()
1388 newentry.MakeArray()
1390 newentry.SetStruct(newstruct)
1391 newentry.SetLineCount(line_count)
1395 # We need to encapsulate this entry into a struct
1396 newname = newentry.Name()+ '_array'
1398 # Now borgify the new entry.
1399 newentry = factory.EntryArray(newentry)
1400 newentry.SetStruct(newstruct)
1401 newentry.SetLineCount(line_count)
1402 newentry.MakeArray()
1404 newstruct.AddEntry(newentry)
1408 def ProcessStruct(factory, data):
1409 tokens = data.split(' ')
1411 # First three tokens are: 'struct' 'name' '{'
1412 newstruct = factory.Struct(tokens[1])
1414 inside = ' '.join(tokens[3:-1])
1416 tokens = inside.split(';')
1420 for entry in tokens:
1421 entry = NormalizeLine(entry)
1425 # It's possible that new structs get defined in here
1426 structs.extend(ProcessOneEntry(factory, newstruct, entry))
1428 structs.append(newstruct)
1431 def GetNextStruct(file):
1437 processed_lines = []
1442 line = file.readline()
1449 if not have_c_comment and re.search(r'/\*', line):
1450 if re.search(r'/\*.*?\*/', line):
1451 line = re.sub(r'/\*.*?\*/', '', line)
1453 line = re.sub(r'/\*.*$', '', line)
1457 if not re.search(r'\*/', line):
1460 line = re.sub(r'^.*\*/', '', line)
1462 line = NormalizeLine(line)
1468 if re.match(r'#include ["<].*[>"]', line):
1469 cppdirect.append(line)
1472 if re.match(r'^#(if( |def)|endif)', line):
1473 cppdirect.append(line)
1476 if re.match(r'^#define', line):
1477 headerdirect.append(line)
1480 if not structdef.match(line):
1481 raise RpcGenError('Missing struct on line %d: %s'
1482 % (line_count, line))
1488 # We are inside the struct
1489 tokens = line.split('}')
1490 if len(tokens) == 1:
1495 raise RpcGenError('Trailing garbage after struct on line %d'
1498 # We found the end of the struct
1499 data += ' %s}' % tokens[0]
1502 # Remove any comments, that might be in there
1503 data = re.sub(r'/\*.*\*/', '', data)
1508 def Parse(factory, file):
1510 Parses the input file and returns C code and corresponding header file.
1516 # Just gets the whole struct nicely formatted
1517 data = GetNextStruct(file)
1522 entities.extend(ProcessStruct(factory, data))
1526 class CCodeGenerator:
1530 def GuardName(self, name):
1531 # Use the complete provided path to the input file, with all
1532 # non-identifier characters replaced with underscores, to
1533 # reduce the chance of a collision between guard macros.
1534 return '_' + nonident.sub('_', name).upper() + '_'
1536 def HeaderPreamble(self, name):
1537 guard = self.GuardName(name)
1540 ' * Automatically generated from %s\n'
1543 '#define %s\n\n' ) % (
1546 for statement in headerdirect:
1547 pre += '%s\n' % statement
1552 '#include <event2/util.h> /* for ev_uint*_t */\n'
1553 '#include <event2/rpc.h>\n'
1558 def HeaderPostamble(self, name):
1559 guard = self.GuardName(name)
1560 return '#endif /* %s */' % guard
1562 def BodyPreamble(self, name, header_file):
1566 slash = header_file.rfind('/')
1568 header_file = header_file[slash+1:]
1571 ' * Automatically generated from %s\n'
1572 ' * by %s/%s. DO NOT EDIT THIS FILE.\n'
1573 ' */\n\n' ) % (name, _NAME, _VERSION)
1574 pre += ( '#include <stdlib.h>\n'
1575 '#include <string.h>\n'
1576 '#include <assert.h>\n'
1577 '#include <event2/event-config.h>\n'
1578 '#include <event2/event.h>\n'
1579 '#include <event2/buffer.h>\n'
1580 '#include <event2/tag.h>\n\n'
1581 '#ifdef _EVENT___func__\n'
1582 '#define __func__ _EVENT___func__\n'
1586 for statement in cppdirect:
1587 pre += '%s\n' % statement
1589 pre += '\n#include "%s"\n\n' % header_file
1591 pre += 'void event_warn(const char *fmt, ...);\n'
1592 pre += 'void event_warnx(const char *fmt, ...);\n\n'
1596 def HeaderFilename(self, filename):
1597 return '.'.join(filename.split('.')[:-1]) + '.h'
1599 def CodeFilename(self, filename):
1600 return '.'.join(filename.split('.')[:-1]) + '.gen.c'
1602 def Struct(self, name):
1603 return StructCCode(name)
1605 def EntryBytes(self, entry_type, name, tag, fixed_length):
1606 return EntryBytes(entry_type, name, tag, fixed_length)
1608 def EntryVarBytes(self, entry_type, name, tag):
1609 return EntryVarBytes(entry_type, name, tag)
1611 def EntryInt(self, entry_type, name, tag, bits=32):
1612 return EntryInt(entry_type, name, tag, bits)
1614 def EntryString(self, entry_type, name, tag):
1615 return EntryString(entry_type, name, tag)
1617 def EntryStruct(self, entry_type, name, tag, struct_name):
1618 return EntryStruct(entry_type, name, tag, struct_name)
1620 def EntryArray(self, entry):
1621 return EntryArray(entry)
1623 class Usage(RpcGenError):
1624 def __init__(self, argv0):
1625 RpcGenError.__init__("usage: %s input.rpc [[output.h] output.c]"
1629 def __init__(self, argv):
1630 """Initialize a command-line to launch event_rpcgen, as if
1631 from a command-line with CommandLine(sys.argv). If you're
1632 calling this directly, remember to provide a dummy value
1635 self.filename = None
1636 self.header_file = None
1637 self.impl_file = None
1638 self.factory = CCodeGenerator()
1640 if len(argv) < 2 or len(argv) > 4:
1641 raise Usage(argv[0])
1643 self.filename = argv[1].replace('\\', '/')
1645 self.impl_file = argv[2].replace('\\', '/')
1647 self.header_file = argv[2].replace('\\', '/')
1648 self.impl_file = argv[3].replace('\\', '/')
1650 if not self.filename:
1651 raise Usage(argv[0])
1653 if not self.impl_file:
1654 self.impl_file = self.factory.CodeFilename(self.filename)
1656 if not self.header_file:
1657 self.header_file = self.factory.HeaderFilename(self.impl_file)
1659 if not self.impl_file.endswith('.c'):
1660 raise RpcGenError("can only generate C implementation files")
1661 if not self.header_file.endswith('.h'):
1662 raise RpcGenError("can only generate C header files")
1665 filename = self.filename
1666 header_file = self.header_file
1667 impl_file = self.impl_file
1668 factory = self.factory
1670 print >>sys.stderr, 'Reading \"%s\"' % filename
1672 fp = open(filename, 'r')
1673 entities = Parse(factory, fp)
1676 print >>sys.stderr, '... creating "%s"' % header_file
1677 header_fp = open(header_file, 'w')
1678 print >>header_fp, factory.HeaderPreamble(filename)
1680 # Create forward declarations: allows other structs to reference
1682 for entry in entities:
1683 entry.PrintForwardDeclaration(header_fp)
1684 print >>header_fp, ''
1686 for entry in entities:
1687 entry.PrintTags(header_fp)
1688 entry.PrintDeclaration(header_fp)
1689 print >>header_fp, factory.HeaderPostamble(filename)
1692 print >>sys.stderr, '... creating "%s"' % impl_file
1693 impl_fp = open(impl_file, 'w')
1694 print >>impl_fp, factory.BodyPreamble(filename, header_file)
1695 for entry in entities:
1696 entry.PrintCode(impl_fp)
1699 if __name__ == '__main__':
1701 CommandLine(sys.argv).run()
1704 except RpcGenError, e:
1705 print >>sys.stderr, e
1708 except EnvironmentError, e:
1709 if e.filename and e.strerror:
1710 print >>sys.stderr, "%s: %s" % (e.filename, e.strerror)
1713 print >> sys.stderr, e.strerror