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