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