#!/usr/bin/env python2

#

# Copyright (c) 2005-2007 Niels Provos <provos@citi.umich.edu>

# Copyright (c) 2007-2012 Niels Provos and Nick Mathewson

# All rights reserved.

#

# Generates marshaling code based on libevent.

# TODO:

# 1) use optparse to allow the strategy shell to parse options, and

#    to allow the instantiated factory (for the specific output language)

#    to parse remaining options

# 2) move the globals into a class that manages execution (including the

#    progress outputs that space stderr at the moment)

# 3) emit other languages

import sys

import re

_NAME = "event_rpcgen.py"

_VERSION = "0.1"

# Globals

line_count = 0

white = re.compile(r'\s+')

cppcomment = re.compile(r'\/\/.*$')

nonident = re.compile(r'[^a-zA-Z0-9_]')

structref = re.compile(r'^struct\[([a-zA-Z_][a-zA-Z0-9_]*)\]$')

structdef = re.compile(r'^struct +[a-zA-Z_][a-zA-Z0-9_]* *{$')

headerdirect = []

cppdirect = []

def TranslateList(mylist, mydict):

    return map(lambda x: x % mydict, mylist)

# Exception class for parse errors

class RpcGenError(Exception):

        def __init__(self, why):

                self.why = why

        def __str__(self):

                return str(self.why)

# Holds everything that makes a struct

class Struct:

    def __init__(self, name):

        self._name = name

        self._entries = []

        self._tags = {}

        print >>sys.stderr, '  Created struct: %s' % name

    def AddEntry(self, entry):

        if self._tags.has_key(entry.Tag()):

            raise RpcGenError(

                'Entry "%s" duplicates tag number %d from "%s" '

                'around line %d' % (entry.Name(), entry.Tag(),

                                    self._tags[entry.Tag()], line_count))

        self._entries.append(entry)

        self._tags[entry.Tag()] = entry.Name()

        print >>sys.stderr, '    Added entry: %s' % entry.Name()

    def Name(self):

        return self._name

    def EntryTagName(self, entry):

        """Creates the name inside an enumeration for distinguishing data

        types."""

        name = "%s_%s" % (self._name, entry.Name())

        return name.upper()

    def PrintIndented(self, file, ident, code):

        """Takes an array, add indentation to each entry and prints it."""

        for entry in code:

            print >>file, '%s%s' % (ident, entry)

class StructCCode(Struct):

    """ Knows how to generate C code for a struct """

    def __init__(self, name):

        Struct.__init__(self, name)

    def PrintTags(self, file):

        """Prints the tag definitions for a structure."""

        print >>file, '/* Tag definition for %s */' % self._name

        print >>file, 'enum %s_ {' % self._name.lower()

        for entry in self._entries:

            print >>file, '  %s=%d,' % (self.EntryTagName(entry),

                                        entry.Tag())

        print >>file, '  %s_MAX_TAGS' % (self._name.upper())

        print >>file, '};\n'

    def PrintForwardDeclaration(self, file):

        print >>file, 'struct %s;' % self._name

    def PrintDeclaration(self, file):

        print >>file, '/* Structure declaration for %s */' % self._name

        print >>file, 'struct %s_access_ {' % self._name

        for entry in self._entries:

            dcl = entry.AssignDeclaration('(*%s_assign)' % entry.Name())

            dcl.extend(

                entry.GetDeclaration('(*%s_get)' % entry.Name()))

            if entry.Array():

                dcl.extend(

                    entry.AddDeclaration('(*%s_add)' % entry.Name()))

            self.PrintIndented(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.PrintIndented(file, '  ', dcl)

        print >>file, ''

        for entry in self._entries:

            print >>file, '  ev_uint8_t %s_set;' % entry.Name()

        print >>file, '};\n'

        print >>file, \

"""struct %(name)s *%(name)s_new(void);

struct %(name)s *%(name)s_new_with_arg(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 *, ev_uint32_t,

    const struct %(name)s *);

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.PrintIndented(file, '', entry.AssignDeclaration(

                entry.AssignFuncName()))

            self.PrintIndented(file, '', entry.GetDeclaration(

                entry.GetFuncName()))

            if entry.Array():

                self.PrintIndented(file, '', entry.AddDeclaration(

                    entry.AddFuncName()))

        print >>file, '/* --- %s done --- */\n' % self._name

    def PrintCode(self, file):

        print >>file, ('/*\n'

                       ' * Implementation of %s\n'

                       ' */\n') % self._name

        print >>file, \

              'static struct %(name)s_access_ __%(name)s_base = {' % \

              { 'name' : self._name }

        for entry in self._entries:

            self.PrintIndented(file, '  ', entry.CodeBase())

        print >>file, '};\n'

        # Creation

        print >>file, (

            'struct %(name)s *\n'

            '%(name)s_new(void)\n'

            '{\n'

            '  return %(name)s_new_with_arg(NULL);\n'

            '}\n'

            '\n'

            'struct %(name)s *\n'

            '%(name)s_new_with_arg(void *unused)\n'

            '{\n'

            '  struct %(name)s *tmp;\n'

            '  if ((tmp = malloc(sizeof(struct %(name)s))) == NULL) {\n'

            '    event_warn("%%s: malloc", __func__);\n'

            '    return (NULL);\n'

            '  }\n'

            '  tmp->base = &__%(name)s_base;\n') % { 'name' : self._name }

        for entry in self._entries:

            self.PrintIndented(file, '  ', entry.CodeInitialize('tmp'))

            print >>file, '  tmp->%s_set = 0;\n' % entry.Name()

        print >>file, (

            '  return (tmp);\n'

            '}\n')

        # Adding

        for entry in self._entries:

            if entry.Array():

                self.PrintIndented(file, '', entry.CodeAdd())

            print >>file, ''

        # Assigning

        for entry in self._entries:

            self.PrintIndented(file, '', entry.CodeAssign())

            print >>file, ''

        # Getting

        for entry in self._entries:

            self.PrintIndented(file, '', entry.CodeGet())

            print >>file, ''

        # Clearing

        print >>file, ( 'void\n'

                        '%(name)s_clear(struct %(name)s *tmp)\n'

                        '{'

                        ) % { 'name' : self._name }

        for entry in self._entries:

            self.PrintIndented(file, '  ', entry.CodeClear('tmp'))

        print >>file, '}\n'

        # Freeing

        print >>file, ( 'void\n'

                        '%(name)s_free(struct %(name)s *tmp)\n'

                        '{'

                        ) % { 'name' : self._name }

        for entry in self._entries:

            self.PrintIndented(file, '  ', entry.CodeFree('tmp'))

        print >>file, ('  free(tmp);\n'

                       '}\n')

        # Marshaling

        print >>file, ('void\n'

                       '%(name)s_marshal(struct evbuffer *evbuf, '

                       'const struct %(name)s *tmp)'

                       '{') % { 'name' : self._name }

        for entry in self._entries:

            indent = '  '

            # Optional entries do not have to be set

            if entry.Optional():

                indent += '  '

                print >>file, '  if (tmp->%s_set) {' % entry.Name()

            self.PrintIndented(

                file, indent,

                entry.CodeMarshal('evbuf', self.EntryTagName(entry),

                                  entry.GetVarName('tmp'),

                                  entry.GetVarLen('tmp')))

            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'

                       '  ev_uint32_t tag;\n'

                       '  while (evbuffer_get_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'

                    '          return (-1);'

                    ) % (entry.Name())

            self.PrintIndented(

                file, '        ',

                entry.CodeUnmarshal('evbuf',

                                    self.EntryTagName(entry),

                                    entry.GetVarName('tmp'),

                                    entry.GetVarLen('tmp')))

            print >>file, ( '        tmp->%s_set = 1;\n' % entry.Name() +

                            '        break;\n' )

        print >>file, ( '      default:\n'

                        '        return -1;\n'

                        '    }\n'

                        '  }\n' )

        # Check if it was decoded completely

        print >>file, ( '  if (%(name)s_complete(tmp) == -1)\n'

                        '    return (-1);'

                        ) % { 'name' : self._name }

        # Successfully decoded

        print >>file, ( '  return (0);\n'

                        '}\n')

        # Checking if a structure has all the required data

        print >>file, (

            'int\n'

            '%(name)s_complete(struct %(name)s *msg)\n'

            '{' ) % { 'name' : self._name }

        for entry in self._entries:

            if not entry.Optional():

                code = [

                    'if (!msg->%(name)s_set)',

                    '  return (-1);' ]

                code = TranslateList(code, entry.GetTranslation())

                self.PrintIndented(

                    file, '  ', code)

            self.PrintIndented(

                file, '  ',

                entry.CodeComplete('msg', entry.GetVarName('msg')))

        print >>file, (

            '  return (0);\n'

            '}\n' )

        # Complete message unmarshaling

        print >>file, (

            'int\n'

            'evtag_unmarshal_%(name)s(struct evbuffer *evbuf, '

            'ev_uint32_t need_tag, struct %(name)s *msg)\n'

            '{\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, ev_uint32_t tag, '

            'const struct %(name)s *msg)\n'

            '{\n'

            '  struct evbuffer *_buf = evbuffer_new();\n'

            '  assert(_buf != NULL);\n'

            '  %(name)s_marshal(_buf, msg);\n'

            '  evtag_marshal_buffer(evbuf, tag, _buf);\n '

            '  evbuffer_free(_buf);\n'

            '}\n' ) % { 'name' : self._name }

class Entry:

    def __init__(self, type, name, tag):

        self._type = type

        self._name = name

        self._tag = int(tag)

        self._ctype = type

        self._optional = 0

        self._can_be_array = 0

        self._array = 0

        self._line_count = -1

        self._struct = None

        self._refname = None

        self._optpointer = True

        self._optaddarg = True

    def GetInitializer(self):

        assert 0, "Entry does not provide initializer"

    def SetStruct(self, struct):

        self._struct = struct

    def LineCount(self):

        assert self._line_count != -1

        return self._line_count

    def SetLineCount(self, number):

        self._line_count = number

    def Array(self):

        return self._array

    def Optional(self):

        return self._optional

    def Tag(self):

        return self._tag

    def Name(self):

        return self._name

    def Type(self):

        return self._type

    def MakeArray(self, yes=1):

        self._array = yes

    def MakeOptional(self):

        self._optional = 1

    def Verify(self):

        if self.Array() and not self._can_be_array:

            raise RpcGenError(

                'Entry "%s" cannot be created as an array '

                'around line %d' % (self._name, self.LineCount()))

        if not self._struct:

            raise RpcGenError(

                'Entry "%s" does not know which struct it belongs to '

                'around line %d' % (self._name, self.LineCount()))

        if self._optional and self._array:

            raise RpcGenError(

                'Entry "%s" has illegal combination of optional and array '

                'around line %d' % (self._name, self.LineCount()))

    def GetTranslation(self, extradict = {}):

        mapping = {

            "parent_name" : self._struct.Name(),

            "name" : self._name,

            "ctype" : self._ctype,

            "refname" : self._refname,

            "optpointer" : self._optpointer and "*" or "",

            "optreference" : self._optpointer and "&" or "",

            "optaddarg" :

            self._optaddarg and ", const %s value" % self._ctype or ""

            }

        for (k, v) in extradict.items():

            mapping[k] = v

        return mapping

    def GetVarName(self, var):

        return '%(var)s->%(name)s_data' % self.GetTranslation({ 'var' : var })

    def GetVarLen(self, var):

        return 'sizeof(%s)' % self._ctype

    def GetFuncName(self):

        return '%s_%s_get' % (self._struct.Name(), self._name)

    def GetDeclaration(self, funcname):

        code = [ 'int %s(struct %s *, %s *);' % (

            funcname, self._struct.Name(), self._ctype ) ]

        return code

    def CodeGet(self):

        code = (

            'int',

            '%(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, '

            '%(ctype)s *value)',

            '{',

            '  if (msg->%(name)s_set != 1)',

            '    return (-1);',

            '  *value = msg->%(name)s_data;',

            '  return (0);',

            '}' )

        code = '\n'.join(code)

        code = code % self.GetTranslation()

        return code.split('\n')

    def AssignFuncName(self):

        return '%s_%s_assign' % (self._struct.Name(), self._name)

    def AddFuncName(self):

        return '%s_%s_add' % (self._struct.Name(), self._name)

    def AssignDeclaration(self, funcname):

        code = [ 'int %s(struct %s *, const %s);' % (

            funcname, self._struct.Name(), self._ctype ) ]

        return code

    def CodeAssign(self):

        code = [ 'int',

                 '%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,'

                 ' const %(ctype)s value)',

                 '{',

                 '  msg->%(name)s_set = 1;',

                 '  msg->%(name)s_data = value;',

                 '  return (0);',

                 '}' ]

        code = '\n'.join(code)

        code = code % self.GetTranslation()

        return code.split('\n')

    def CodeClear(self, structname):

        code = [ '%s->%s_set = 0;' % (structname, self.Name()) ]

        return code

    def CodeComplete(self, structname, var_name):

        return []

    def CodeFree(self, name):

        return []

    def CodeBase(self):

        code = [

            '%(parent_name)s_%(name)s_assign,',

            '%(parent_name)s_%(name)s_get,'

            ]

        if self.Array():

            code.append('%(parent_name)s_%(name)s_add,')

        code = '\n'.join(code)

        code = code % self.GetTranslation()

        return code.split('\n')

class EntryBytes(Entry):

    def __init__(self, type, name, tag, length):

        # Init base class

        Entry.__init__(self, type, name, tag)

        self._length = length

        self._ctype = 'ev_uint8_t'

    def GetInitializer(self):

        return "NULL"

    def GetVarLen(self, var):

        return '(%s)' % self._length

    def CodeArrayAdd(self, varname, value):

        # XXX: copy here

        return [ '%(varname)s = NULL;' % { 'varname' : varname } ]

    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  = ['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),

                 '{',

                 '  if (msg->%s_set != 1)' % name,

                 '    return (-1);',

                 '  *value = msg->%s_data;' % name,

                 '  return (0);',

                 '}' ]

        return code

    def CodeAssign(self):

        name = self._name

        code = [ 'int',

                 '%s_%s_assign(struct %s *msg, const %s *value)' % (

            self._struct.Name(), name,

            self._struct.Name(), self._ctype),

                 '{',

                 '  msg->%s_set = 1;' % name,

                 '  memcpy(msg->%s_data, value, %s);' % (

            name, self._length),

                 '  return (0);',

                 '}' ]

        return code

    def CodeUnmarshal(self, buf, tag_name, var_name, var_len):

        code = [  'if (evtag_unmarshal_fixed(%(buf)s, %(tag)s, '

                  '%(var)s, %(varlen)s) == -1) {',

                  '  event_warnx("%%s: failed to unmarshal %(name)s", __func__);',

                  '  return (-1);',

                  '}'

                  ]

        return TranslateList(code,

                             self.GetTranslation({

            'var' : var_name,

            'varlen' : var_len,

            'buf' : buf,

            'tag' : tag_name }))

    def CodeMarshal(self, buf, tag_name, var_name, var_len):

        code = ['evtag_marshal(%s, %s, %s, %s);' % (

            buf, tag_name, var_name, var_len)]

        return code

    def CodeClear(self, structname):

        code = [ '%s->%s_set = 0;' % (structname, self.Name()),

                 'memset(%s->%s_data, 0, sizeof(%s->%s_data));' % (

            structname, self._name, structname, self._name)]

        return code

    def CodeInitialize(self, name):

        code  = ['memset(%s->%s_data, 0, sizeof(%s->%s_data));' % (

            name, self._name, name, self._name)]

        return code

    def Verify(self):

        if not self._length:

            raise RpcGenError(

                'Entry "%s" needs a length '

                'around line %d' % (self._name, self.LineCount()))

        Entry.Verify(self)

class EntryInt(Entry):

    def __init__(self, type, name, tag, bits=32):

        # Init base class

        Entry.__init__(self, type, name, tag)

        self._can_be_array = 1

        if bits == 32:

            self._ctype = 'ev_uint32_t'

            self._marshal_type = 'int'

        if bits == 64:

            self._ctype = 'ev_uint64_t'

            self._marshal_type = 'int64'

    def GetInitializer(self):

        return "0"

    def CodeArrayFree(self, var):

        return []

    def CodeArrayAssign(self, varname, srcvar):

        return [ '%(varname)s = %(srcvar)s;' % { 'varname' : varname,

                                                'srcvar' : srcvar } ]

    def CodeArrayAdd(self, varname, value):

        """Returns a new entry of this type."""

        return [ '%(varname)s = %(value)s;' % { 'varname' : varname,

                                              'value' : value } ]

    def CodeUnmarshal(self, buf, tag_name, var_name, var_len):

        code = [

            'if (evtag_unmarshal_%(ma)s(%(buf)s, %(tag)s, &%(var)s) == -1) {',

            '  event_warnx("%%s: failed to unmarshal %(name)s", __func__);',

            '  return (-1);',

            '}' ]

        code = '\n'.join(code) % self.GetTranslation({

            'ma'  : self._marshal_type,

            'buf' : buf,

            'tag' : tag_name,

            'var' : var_name })

        return code.split('\n')

    def CodeMarshal(self, buf, tag_name, var_name, var_len):

        code = [

            'evtag_marshal_%s(%s, %s, %s);' % (

            self._marshal_type, buf, tag_name, var_name)]

        return code

    def Declaration(self):

        dcl  = ['%s %s_data;' % (self._ctype, self._name)]

        return dcl

    def CodeInitialize(self, name):

        code = ['%s->%s_data = 0;' % (name, self._name)]

        return code

class EntryString(Entry):

    def __init__(self, type, name, tag):

        # Init base class

        Entry.__init__(self, type, name, tag)

        self._can_be_array = 1

        self._ctype = 'char *'

    def GetInitializer(self):

        return "NULL"

    def CodeArrayFree(self, varname):

        code = [

            'if (%(var)s != NULL) free(%(var)s);' ]

        return TranslateList(code, { 'var' : varname })

    def CodeArrayAssign(self, varname, srcvar):

        code = [

            'if (%(var)s != NULL)',

            '  free(%(var)s);',

            '%(var)s = strdup(%(srcvar)s);',

            'if (%(var)s == NULL) {',

            '  event_warnx("%%s: strdup", __func__);',

            '  return (-1);',

            '}' ]

        return TranslateList(code, { 'var' : varname,

                                     'srcvar' : srcvar })

    def CodeArrayAdd(self, varname, value):

        code = [

            'if (%(value)s != NULL) {',

            '  %(var)s = strdup(%(value)s);',

            '  if (%(var)s == NULL) {',

            '    goto error;',

            '  }',

            '} else {',

            '  %(var)s = NULL;',

            '}' ]

        return TranslateList(code, { 'var' : varname,

                                     'value' : value })

    def GetVarLen(self, var):

        return 'strlen(%s)' % self.GetVarName(var)

    def CodeMakeInitalize(self, varname):

        return '%(varname)s = NULL;' % { 'varname' : varname }

    def CodeAssign(self):

        name = self._name

        code = """int

%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,

    const %(ctype)s value)

{

  if (msg->%(name)s_data != NULL)

    free(msg->%(name)s_data);

  if ((msg->%(name)s_data = strdup(value)) == NULL)

    return (-1);

  msg->%(name)s_set = 1;

  return (0);

}""" % self.GetTranslation()

        return code.split('\n')

    def CodeUnmarshal(self, buf, tag_name, var_name, var_len):

        code = ['if (evtag_unmarshal_string(%(buf)s, %(tag)s, &%(var)s) == -1) {',

                '  event_warnx("%%s: failed to unmarshal %(name)s", __func__);',

                '  return (-1);',

                '}'

                ]

        code = '\n'.join(code) % self.GetTranslation({

            'buf' : buf,

            'tag' : tag_name,

            'var' : var_name })

        return code.split('\n')

    def CodeMarshal(self, buf, tag_name, var_name, var_len):

        code = ['evtag_marshal_string(%s, %s, %s);' % (

            buf, tag_name, var_name)]

        return code

    def CodeClear(self, structname):

        code = [ 'if (%s->%s_set == 1) {' % (structname, self.Name()),

                 '  free(%s->%s_data);' % (structname, self.Name()),

                 '  %s->%s_data = NULL;' % (structname, self.Name()),

                 '  %s->%s_set = 0;' % (structname, self.Name()),

                 '}'

                 ]

        return code

    def CodeInitialize(self, name):

        code  = ['%s->%s_data = NULL;' % (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  = ['char *%s_data;' % self._name]

        return dcl

class EntryStruct(Entry):

    def __init__(self, type, name, tag, refname):

        # Init base class

        Entry.__init__(self, type, name, tag)

        self._optpointer = False

        self._can_be_array = 1

        self._refname = refname

        self._ctype = 'struct %s*' % refname

        self._optaddarg = False

    def GetInitializer(self):

        return "NULL"

    def GetVarLen(self, var):

        return '-1'

    def CodeArrayAdd(self, varname, value):

        code = [

            '%(varname)s = %(refname)s_new();',

            'if (%(varname)s == NULL)',

            '  goto error;' ]

        return TranslateList(code, self.GetTranslation({ 'varname' : varname }))

    def CodeArrayFree(self, var):

        code = [ '%(refname)s_free(%(var)s);' % self.GetTranslation(

            { 'var' : var }) ]

        return code

    def CodeArrayAssign(self, var, srcvar):

        code = [

            'int had_error = 0;',

            'struct evbuffer *tmp = NULL;',

            '%(refname)s_clear(%(var)s);',

            'if ((tmp = evbuffer_new()) == NULL) {',

            '  event_warn("%%s: evbuffer_new()", __func__);',

            '  had_error = 1;',

            '  goto done;',

            '}',

            '%(refname)s_marshal(tmp, %(srcvar)s);',

            'if (%(refname)s_unmarshal(%(var)s, tmp) == -1) {',

            '  event_warnx("%%s: %(refname)s_unmarshal", __func__);',

            '  had_error = 1;',

            '  goto done;',

            '}',

            'done:'

            'if (tmp != NULL)',

            '  evbuffer_free(tmp);',

            'if (had_error) {',

            '  %(refname)s_clear(%(var)s);',

            '  return (-1);',

            '}' ]

        return TranslateList(code, self.GetTranslation({

            'var' : var,

            'srcvar' : srcvar}))

    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),

                 '{',

                 '  if (msg->%s_set != 1) {' % name,

                 '    msg->%s_data = %s_new();' % (name, self._refname),

                 '    if (msg->%s_data == NULL)' % name,

                 '      return (-1);',

                 '    msg->%s_set = 1;' % name,

                 '  }',

                 '  *value = msg->%s_data;' % name,

                 '  return (0);',

                 '}' ]

        return code

    def CodeAssign(self):

        name = self._name

        code = """int

%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg,

    const %(ctype)s value)

{

   struct evbuffer *tmp = NULL;

   if (msg->%(name)s_set) {

     %(refname)s_clear(msg->%(name)s_data);

     msg->%(name)s_set = 0;

   } else {

     msg->%(name)s_data = %(refname)s_new();

     if (msg->%(name)s_data == NULL) {

       event_warn("%%s: %(refname)s_new()", __func__);

       goto error;

     }

   }

   if ((tmp = evbuffer_new()) == NULL) {

     event_warn("%%s: evbuffer_new()", __func__);

     goto error;

   }

   %(refname)s_marshal(tmp, value);

   if (%(refname)s_unmarshal(msg->%(name)s_data, tmp) == -1) {

     event_warnx("%%s: %(refname)s_unmarshal", __func__);

     goto error;

   }

   msg->%(name)s_set = 1;

   evbuffer_free(tmp);

   return (0);

 error:

   if (tmp != NULL)

     evbuffer_free(tmp);

   if (msg->%(name)s_data != NULL) {

     %(refname)s_free(msg->%(name)s_data);

     msg->%(name)s_data = NULL;

   }

   return (-1);

}""" % self.GetTranslation()

        return code.split('\n')

    def CodeComplete(self, structname, var_name):

        code = [ 'if (%(structname)s->%(name)s_set && '

                 '%(refname)s_complete(%(var)s) == -1)',