posix: upgrade libevent from 1.4.7 to 1.4.13

third_party/libevent/event_rpcgen.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2005 Niels Provos <provos@citi.umich.edu>
 # All rights reserved.
 #
 # Generates marshaling code based on libevent.
 
 import sys
 import re
 
@@ skipping 69 matching lines @@
             self.PrintIdented(file, '  ', dcl)
         print >>file, '};\n'
 
         print >>file, 'struct %s {' % self._name
         print >>file, '  struct %s_access_ *base;\n' % self._name
         for entry in self._entries:
             dcl = entry.Declaration()
             self.PrintIdented(file, '  ', dcl)
         print >>file, ''
         for entry in self._entries:
-            print >>file, '  uint8_t %s_set;' % entry.Name()
+            print >>file, '  ev_uint8_t %s_set;' % entry.Name()
         print >>file, '};\n'
 
         print >>file, \
 """struct %(name)s *%(name)s_new(void);
 void %(name)s_free(struct %(name)s *);
 void %(name)s_clear(struct %(name)s *);
 void %(name)s_marshal(struct evbuffer *, const struct %(name)s *);
 int %(name)s_unmarshal(struct %(name)s *, struct evbuffer *);
 int %(name)s_complete(struct %(name)s *);
-void evtag_marshal_%(name)s(struct evbuffer *, uint32_t, 
+void evtag_marshal_%(name)s(struct evbuffer *, ev_uint32_t, 
     const struct %(name)s *);
-int evtag_unmarshal_%(name)s(struct evbuffer *, uint32_t,
+int evtag_unmarshal_%(name)s(struct evbuffer *, ev_uint32_t,
     struct %(name)s *);""" % { 'name' : self._name }
 
 
         # Write a setting function of every variable
         for entry in self._entries:
             self.PrintIdented(file, '', entry.AssignDeclaration(
                 entry.AssignFuncName()))
             self.PrintIdented(file, '', entry.GetDeclaration(
                 entry.GetFuncName()))
             if entry.Array():
@@ skipping 89 matching lines @@
             if entry.Optional():
                 print >>file, '  }'
 
         print >>file, '}\n'
                        
         # Unmarshaling
         print >>file, ('int\n'
                        '%(name)s_unmarshal(struct %(name)s *tmp, '
                        ' struct evbuffer *evbuf)\n'
                        '{\n'
-                       '  uint32_t tag;\n'
+                       '  ev_uint32_t tag;\n'
                        '  while (EVBUFFER_LENGTH(evbuf) > 0) {\n'
                        '    if (evtag_peek(evbuf, &tag) == -1)\n'
                        '      return (-1);\n'
                        '    switch (tag) {\n'
                        ) % { 'name' : self._name }
         for entry in self._entries:
             print >>file, '      case %s:\n' % self.EntryTagName(entry)
             if not entry.Array():
                 print >>file, (
                     '        if (tmp->%s_set)\n'
@@ skipping 30 matching lines @@
                 file, '  ',
                 entry.CodeComplete('msg'))
         print >>file, (
             '  return (0);\n'
             '}\n' )
 
         # Complete message unmarshaling
         print >>file, (
             'int\n'
             'evtag_unmarshal_%(name)s(struct evbuffer *evbuf, '
-            'uint32_t need_tag, struct %(name)s *msg)\n'
+            'ev_uint32_t need_tag, struct %(name)s *msg)\n'
             '{\n'
-            '  uint32_t tag;\n'
+            '  ev_uint32_t tag;\n'
             '  int res = -1;\n'
             '\n'
             '  struct evbuffer *tmp = evbuffer_new();\n'
             '\n'
             '  if (evtag_unmarshal(evbuf, &tag, tmp) == -1'
             ' || tag != need_tag)\n'
             '    goto error;\n'
             '\n'
             '  if (%(name)s_unmarshal(msg, tmp) == -1)\n'
             '    goto error;\n'
             '\n'
             '  res = 0;\n'
             '\n'
             ' error:\n'
             '  evbuffer_free(tmp);\n'
             '  return (res);\n'
             '}\n' ) % { 'name' : self._name }
 
         # Complete message marshaling
         print >>file, (
             'void\n'
-            'evtag_marshal_%(name)s(struct evbuffer *evbuf, uint32_t tag, '
+            'evtag_marshal_%(name)s(struct evbuffer *evbuf, ev_uint32_t tag, '
             'const struct %(name)s *msg)\n'
             '{\n'
             '  struct evbuffer *_buf = evbuffer_new();\n'
             '  assert(_buf != NULL);\n'
             '  evbuffer_drain(_buf, -1);\n'
             '  %(name)s_marshal(_buf, msg);\n'
             '  evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf), '
             'EVBUFFER_LENGTH(_buf));\n'
             '  evbuffer_free(_buf);\n'
             '}\n' ) % { 'name' : self._name }
@@ skipping 141 matching lines @@
                                    'optional and array around line %d' ) % (
                 self._name, self.LineCount() )
             sys.exit(1)
 
 class EntryBytes(Entry):
     def __init__(self, type, name, tag, length):
         # Init base class
         Entry.__init__(self, type, name, tag)
 
         self._length = length
-        self._ctype = 'uint8_t'
+        self._ctype = 'ev_uint8_t'
 
     def GetDeclaration(self, funcname):
         code = [ 'int %s(struct %s *, %s **);' % (
             funcname, self._struct.Name(), self._ctype ) ]
         return code
         
     def AssignDeclaration(self, funcname):
         code = [ 'int %s(struct %s *, const %s *);' % (
             funcname, self._struct.Name(), self._ctype ) ]
         return code
         
     def Declaration(self):
-        dcl  = ['uint8_t %s_data[%s];' % (self._name, self._length)]
+        dcl  = ['ev_uint8_t %s_data[%s];' % (self._name, self._length)]
         
         return dcl
 
     def CodeGet(self):
         name = self._name
         code = [ 'int',
                  '%s_%s_get(struct %s *msg, %s **value)' % (
             self._struct.Name(), name,
             self._struct.Name(), self._ctype),
                  '{',
@@ skipping 53 matching lines @@
                 self._name, self.LineCount() )
             sys.exit(1)
 
         Entry.Verify(self)
 
 class EntryInt(Entry):
     def __init__(self, type, name, tag):
         # Init base class
         Entry.__init__(self, type, name, tag)
 
-        self._ctype = 'uint32_t'
+        self._ctype = 'ev_uint32_t'
 
     def CodeUnmarshal(self, buf, tag_name, var_name):
         code = ['if (evtag_unmarshal_int(%s, %s, &%s->%s_data) == -1) {' % (
             buf, tag_name, var_name, self._name),
                   '  event_warnx("%%s: failed to unmarshal %s", __func__);' % (
             self._name ),
                 '  return (-1);',
                 '}' ] 
         return code
 
     def CodeMarshal(self, buf, tag_name, var_name):
         code = ['evtag_marshal_int(%s, %s, %s->%s_data);' % (
             buf, tag_name, var_name, self._name)]
         return code
 
     def Declaration(self):
-        dcl  = ['uint32_t %s_data;' % self._name]
+        dcl  = ['ev_uint32_t %s_data;' % self._name]
 
         return dcl
 
     def CodeNew(self, name):
         code = ['%s->%s_data = 0;' % (name, self._name)]
         return code
 
 class EntryString(Entry):
     def __init__(self, type, name, tag):
         # Init base class
@@ skipping 181 matching lines @@
     def Declaration(self):
         dcl  = ['%s %s_data;' % (self._ctype, self._name)]
 
         return dcl
 
 class EntryVarBytes(Entry):
     def __init__(self, type, name, tag):
         # Init base class
         Entry.__init__(self, type, name, tag)
 
-        self._ctype = 'uint8_t *'
+        self._ctype = 'ev_uint8_t *'
 
     def GetDeclaration(self, funcname):
-        code = [ 'int %s(struct %s *, %s *, uint32_t *);' % (
+        code = [ 'int %s(struct %s *, %s *, ev_uint32_t *);' % (
             funcname, self._struct.Name(), self._ctype ) ]
         return code
         
     def AssignDeclaration(self, funcname):
-        code = [ 'int %s(struct %s *, const %s, uint32_t);' % (
+        code = [ 'int %s(struct %s *, const %s, ev_uint32_t);' % (
             funcname, self._struct.Name(), self._ctype ) ]
         return code
         
     def CodeAssign(self):
         name = self._name
         code = [ 'int',
                  '%s_%s_assign(struct %s *msg, '
-                 'const %s value, uint32_t len)' % (
+                 'const %s value, ev_uint32_t len)' % (
             self._struct.Name(), name,
             self._struct.Name(), self._ctype),
                  '{',
                  '  if (msg->%s_data != NULL)' % name,
                  '    free (msg->%s_data);' % name,
                  '  msg->%s_data = malloc(len);' % name,
                  '  if (msg->%s_data == NULL)' % name,
                  '    return (-1);',
                  '  msg->%s_set = 1;' % name,
                  '  msg->%s_length = len;' % name,
                  '  memcpy(msg->%s_data, value, len);' % name,
                  '  return (0);',
                  '}' ]
         return code
         
     def CodeGet(self):
         name = self._name
         code = [ 'int',
-                 '%s_%s_get(struct %s *msg, %s *value, uint32_t *plen)' % (
+                 '%s_%s_get(struct %s *msg, %s *value, ev_uint32_t *plen)' % (
             self._struct.Name(), name,
             self._struct.Name(), self._ctype),
                  '{',
                  '  if (msg->%s_set != 1)' % name,
                  '    return (-1);',
                  '  *value = msg->%s_data;' % name,
                  '  *plen = msg->%s_length;' % name,
                  '  return (0);',
                  '}' ]
         return code
@@ skipping 40 matching lines @@
                  '%s->%s_length = 0;' % (name, self._name) ]
         return code
 
     def CodeFree(self, name):
         code  = ['if (%s->%s_data != NULL)' % (name, self._name),
                  '    free (%s->%s_data); ' % (name, self._name)]
 
         return code
 
     def Declaration(self):
-        dcl  = ['uint8_t *%s_data;' % self._name,
-                'uint32_t %s_length;' % self._name]
+        dcl  = ['ev_uint8_t *%s_data;' % self._name,
+                'ev_uint32_t %s_length;' % self._name]
 
         return dcl
 
 class EntryArray(Entry):
     def __init__(self, entry):
         # Init base class
         Entry.__init__(self, entry._type, entry._name, entry._tag)
 
         self._entry = entry
         self._refname = entry._refname
@@ skipping 448 matching lines @@
         '#include <stdint.h>\n'
         '#endif\n' )
 
     for statement in headerdirect:
         pre += '%s\n' % statement
     if headerdirect:
         pre += '\n'
 
     pre += (
         '#define EVTAG_HAS(msg, member) ((msg)->member##_set == 1)\n'
+        '#ifdef __GNUC__\n'
         '#define EVTAG_ASSIGN(msg, member, args...) '
         '(*(msg)->base->member##_assign)(msg, ## args)\n'
         '#define EVTAG_GET(msg, member, args...) '
         '(*(msg)->base->member##_get)(msg, ## args)\n'
+        '#else\n'
+        '#define EVTAG_ASSIGN(msg, member, ...) '
+        '(*(msg)->base->member##_assign)(msg, ## __VA_ARGS__)\n'
+        '#define EVTAG_GET(msg, member, ...) '
+        '(*(msg)->base->member##_get)(msg, ## __VA_ARGS__)\n'
+        '#endif\n'
         '#define EVTAG_ADD(msg, member) (*(msg)->base->member##_add)(msg)\n'
         '#define EVTAG_LEN(msg, member) ((msg)->member##_length)\n'
         )
 
     return pre
      
 
 def HeaderPostamble(name):
     guard = GuardName(name)
     return '#endif  /* %s */' % guard
 
 def BodyPreamble(name):
     global _NAME
     global _VERSION
     
     header_file = '.'.join(name.split('.')[:-1]) + '.gen.h'
 
     pre = ( '/*\n'
             ' * Automatically generated from %s\n'
             ' * by %s/%s.  DO NOT EDIT THIS FILE.\n'
             ' */\n\n' ) % (name, _NAME, _VERSION)
     pre += ( '#include <sys/types.h>\n'
+             '#ifdef _EVENT_HAVE_SYS_TIME_H\n'
              '#include <sys/time.h>\n'
+             '#endif\n'
              '#include <stdlib.h>\n'
              '#include <string.h>\n'
              '#include <assert.h>\n'
-             '#include <event.h>\n\n' )
+             '#define EVENT_NO_STRUCT\n'
+             '#include <event.h>\n\n'
+             '#ifdef _EVENT___func__\n'
+             '#define __func__ _EVENT___func__\n'
+             '#endif\n' )
 
     for statement in cppdirect:
         pre += '%s\n' % statement
     
     pre += '\n#include "%s"\n\n' % header_file
 
     pre += 'void event_err(int eval, const char *fmt, ...);\n'
     pre += 'void event_warn(const char *fmt, ...);\n'
     pre += 'void event_errx(int eval, const char *fmt, ...);\n'
     pre += 'void event_warnx(const char *fmt, ...);\n\n'
@@ skipping 39 matching lines @@
 
     print >>sys.stderr, '... creating "%s"' % impl_file
     impl_fp = open(impl_file, 'w')
     print >>impl_fp, BodyPreamble(filename)
     for entry in entities:
         entry.PrintCode(impl_fp)
     impl_fp.close()
 
 if __name__ == '__main__':
     main(sys.argv)