import os
import sys
-sys.path.append('{}/tools/libxl'.format(os.environ['XEN_ROOT']))
+sys.path.append('{0}/tools/libxl'.format(os.environ['XEN_ROOT']))
import idl
# Go versions of some builtin types.
if ty.typename is not None:
typename = xenlight_golang_fmt_name(ty.typename)
- s += 'type {} int\n'.format(typename)
+ s += 'type {0} int\n'.format(typename)
# Start const block
s += 'const(\n'
for v in ty.values:
name = xenlight_golang_fmt_name(v.name)
- s += '{} {} = {}\n'.format(name, typename, v.value)
+ s += '{0} {1} = {2}\n'.format(name, typename, v.value)
# End const block
s += ')\n'
# Begin struct definition
if nested:
- s += '{} struct {{\n'.format(name)
+ s += '{0} struct {{\n'.format(name)
else:
- s += 'type {} struct {{\n'.format(name)
+ s += 'type {0} struct {{\n'.format(name)
# Write struct fields
for f in ty.fields:
typename = xenlight_golang_fmt_name(typename)
name = xenlight_golang_fmt_name(f.name)
- s += '{} []{}\n'.format(name, typename)
+ s += '{0} []{1}\n'.format(name, typename)
else:
typename = f.type.typename
typename = xenlight_golang_fmt_name(typename)
name = xenlight_golang_fmt_name(f.name)
- s += '{} {}\n'.format(name, typename)
+ s += '{0} {1}\n'.format(name, typename)
elif isinstance(f.type, idl.Struct):
r = xenlight_golang_define_struct(f.type, typename=f.name, nested=True)
extras.extend(r[1])
else:
- raise Exception('type {} not supported'.format(f.type))
+ raise Exception('type {0} not supported'.format(f.type))
# End struct definition
s += '}\n'
s = ''
extras = []
- interface_name = '{}_{}_union'.format(struct_name, ty.keyvar.name)
+ interface_name = '{0}_{1}_union'.format(struct_name, ty.keyvar.name)
interface_name = xenlight_golang_fmt_name(interface_name, exported=False)
- s += 'type {} interface {{\n'.format(interface_name)
- s += 'is{}()\n'.format(interface_name)
+ s += 'type {0} interface {{\n'.format(interface_name)
+ s += 'is{0}()\n'.format(interface_name)
s += '}\n'
extras.append(s)
continue
# Define struct
- name = '{}_{}_union_{}'.format(struct_name, ty.keyvar.name, f.name)
+ name = '{0}_{1}_union_{2}'.format(struct_name, ty.keyvar.name, f.name)
r = xenlight_golang_define_struct(f.type, typename=name)
extras.append(r[0])
extras.extend(r[1])
# This typeof trick ensures that the fields used in the cgo struct
# used for marshaling are the same as the fields of the union in the
# actual C type, and avoids re-defining all of those fields.
- s = 'typedef typeof(((struct {} *)NULL)->{}.{}){};'
+ s = 'typedef typeof(((struct {0} *)NULL)->{1}.{2}){3};'
s = s.format(struct_name, union_name, f.name, name)
cgo_helpers_preamble.append(s)
# Define function to implement 'union' interface
name = xenlight_golang_fmt_name(name)
- s = 'func (x {}) is{}(){{}}\n'.format(name, interface_name)
+ s = 'func (x {0}) is{1}(){{}}\n'.format(name, interface_name)
extras.append(s)
fname = xenlight_golang_fmt_name(ty.keyvar.name)
ftype = xenlight_golang_fmt_name(ty.keyvar.type.typename)
- s = '{} {}\n'.format(fname, ftype)
+ s = '{0} {1}\n'.format(fname, ftype)
- fname = xenlight_golang_fmt_name('{}_union'.format(ty.keyvar.name))
- s += '{} {}\n'.format(fname, interface_name)
+ fname = xenlight_golang_fmt_name('{0}_union'.format(ty.keyvar.name))
+ s += '{0} {1}\n'.format(fname, interface_name)
return (s,extras)
Define the fromC marshaling function for the type
represented by ty.
"""
- func = 'func (x *{}) fromC(xc *C.{}) error {{\n {}\n return nil}}\n'
+ func = 'func (x *{0}) fromC(xc *C.{1}) error {{\n {2}\n return nil}}\n'
goname = xenlight_golang_fmt_name(ty.typename)
cname = ty.typename
extras.extend(r[1])
else:
- raise Exception('type {} not supported'.format(f.type))
+ raise Exception('type {0} not supported'.format(f.type))
return (func.format(goname, cname, body), extras)
# If outer_name is set, treat this as nested.
if outer_name is not None:
- goname = '{}.{}'.format(xenlight_golang_fmt_name(outer_name), goname)
- cname = '{}.{}'.format(outer_name, cname)
+ goname = '{0}.{1}'.format(xenlight_golang_fmt_name(outer_name), goname)
+ cname = '{0}.{1}'.format(outer_name, cname)
# Types that satisfy this condition can be easily casted or
# converted to a Go builtin type.
if not is_castable:
# If the type is not castable, we need to call its fromC
# function.
- s += 'if err := x.{}.fromC(&{}.{});'.format(goname,cvarname,cname)
- s += 'err != nil {{\nreturn fmt.Errorf("converting field {}: %v", err)\n}}\n'.format(goname)
+ s += 'if err := x.{0}.fromC(&{1}.{2});'.format(goname,cvarname,cname)
+ s += 'err != nil {{\nreturn fmt.Errorf("converting field {0}: %v", err)\n}}\n'.format(goname)
elif gotypename == 'string':
# Use the cgo helper for converting C strings.
- s += 'x.{} = C.GoString({}.{})\n'.format(goname,cvarname,cname)
+ s += 'x.{0} = C.GoString({1}.{2})\n'.format(goname,cvarname,cname)
else:
- s += 'x.{} = {}({}.{})\n'.format(goname,gotypename,cvarname,cname)
+ s += 'x.{0} = {1}({2}.{3})\n'.format(goname,gotypename,cvarname,cname)
return s
gokeyname = xenlight_golang_fmt_name(keyname)
keytype = ty.keyvar.type.typename
gokeytype = xenlight_golang_fmt_name(keytype)
- field_name = xenlight_golang_fmt_name('{}_union'.format(keyname))
+ field_name = xenlight_golang_fmt_name('{0}_union'.format(keyname))
- interface_name = '{}_{}_union'.format(struct_name, keyname)
+ interface_name = '{0}_{1}_union'.format(struct_name, keyname)
interface_name = xenlight_golang_fmt_name(interface_name, exported=False)
cgo_keyname = keyname
cases = {}
for f in ty.fields:
- val = '{}_{}'.format(keytype, f.name)
+ val = '{0}_{1}'.format(keytype, f.name)
val = xenlight_golang_fmt_name(val)
# Add to list of cases to make for the switch
continue
# Define fromC func for 'union' struct.
- typename = '{}_{}_union_{}'.format(struct_name,keyname,f.name)
+ typename = '{0}_{1}_union_{2}'.format(struct_name,keyname,f.name)
gotypename = xenlight_golang_fmt_name(typename)
# Define the function here. The cases for keyed unions are a little
# different.
- s = 'func (x *{}) fromC(xc *C.{}) error {{\n'.format(gotypename,struct_name)
- s += 'if {}(xc.{}) != {} {{\n'.format(gokeytype,cgo_keyname,val)
- err_string = '"expected union key {}"'.format(val)
- s += 'return errors.New({})\n'.format(err_string)
+ s = 'func (x *{0}) fromC(xc *C.{1}) error {{\n'.format(gotypename,struct_name)
+ s += 'if {0}(xc.{1}) != {2} {{\n'.format(gokeytype,cgo_keyname,val)
+ err_string = '"expected union key {0}"'.format(val)
+ s += 'return errors.New({0})\n'.format(err_string)
s += '}\n\n'
- s += 'tmp := (*C.{})(unsafe.Pointer(&xc.{}[0]))\n'.format(typename,union_name)
+ s += 'tmp := (*C.{0})(unsafe.Pointer(&xc.{1}[0]))\n'.format(typename,union_name)
for nf in f.type.fields:
s += xenlight_golang_convert_from_C(nf,cvarname='tmp')
extras.append(s)
- s = 'x.{} = {}(xc.{})\n'.format(gokeyname,gokeytype,cgo_keyname)
- s += 'switch x.{}{{\n'.format(gokeyname)
+ s = 'x.{0} = {1}(xc.{2})\n'.format(gokeyname,gokeytype,cgo_keyname)
+ s += 'switch x.{0}{{\n'.format(gokeyname)
# Create switch statement to determine which 'union element'
# to populate in the Go struct.
for case_name, case_tuple in sorted(cases.items()):
(case_val, case_type) = case_tuple
- s += 'case {}:\n'.format(case_val)
+ s += 'case {0}:\n'.format(case_val)
if case_type is None:
- s += "x.{} = nil\n".format(field_name)
+ s += "x.{0} = nil\n".format(field_name)
continue
- gotype = '{}_{}_union_{}'.format(struct_name,keyname,case_name)
+ gotype = '{0}_{1}_union_{2}'.format(struct_name,keyname,case_name)
gotype = xenlight_golang_fmt_name(gotype)
- goname = '{}_{}'.format(keyname,case_name)
+ goname = '{0}_{1}'.format(keyname,case_name)
goname = xenlight_golang_fmt_name(goname,exported=False)
- s += 'var {} {}\n'.format(goname, gotype)
- s += 'if err := {}.fromC(xc);'.format(goname)
- s += 'err != nil {{\n return fmt.Errorf("converting field {}: %v", err)\n}}\n'.format(goname)
+ s += 'var {0} {1}\n'.format(goname, gotype)
+ s += 'if err := {0}.fromC(xc);'.format(goname)
+ s += 'err != nil {{\n return fmt.Errorf("converting field {0}: %v", err)\n}}\n'.format(goname)
- s += 'x.{} = {}\n'.format(field_name, goname)
+ s += 'x.{0} = {1}\n'.format(field_name, goname)
# End switch statement
s += 'default:\n'
- err_string = '"invalid union key \'%v\'", x.{}'.format(gokeyname)
- s += 'return fmt.Errorf({})'.format(err_string)
+ err_string = '"invalid union key \'%v\'", x.{0}'.format(gokeyname)
+ s += 'return fmt.Errorf({0})'.format(err_string)
s += '}\n'
return (s,extras)
goname = xenlight_golang_fmt_name(ty.name)
ctypename = ty.type.elem_type.typename
cname = ty.name
- cslice = 'c{}'.format(goname)
+ cslice = 'c{0}'.format(goname)
clenvar = ty.type.lenvar.name
- s += 'x.{} = nil\n'.format(goname)
- s += 'if n := int(xc.{}); n > 0 {{\n'.format(clenvar)
- s += '{} := '.format(cslice)
- s +='(*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:n:n]\n'.format(ctypename, cname)
- s += 'x.{} = make([]{}, n)\n'.format(goname, gotypename)
- s += 'for i, v := range {} {{\n'.format(cslice)
+ s += 'x.{0} = nil\n'.format(goname)
+ s += 'if n := int(xc.{0}); n > 0 {{\n'.format(clenvar)
+ s += '{0} := '.format(cslice)
+ s +='(*[1<<28]C.{0})(unsafe.Pointer(xc.{1}))[:n:n]\n'.format(ctypename, cname)
+ s += 'x.{0} = make([]{1}, n)\n'.format(goname, gotypename)
+ s += 'for i, v := range {0} {{\n'.format(cslice)
is_enum = isinstance(ty.type.elem_type,idl.Enumeration)
if gotypename in go_builtin_types or is_enum:
- s += 'x.{}[i] = {}(v)\n'.format(goname, gotypename)
+ s += 'x.{0}[i] = {1}(v)\n'.format(goname, gotypename)
else:
- s += 'if err := x.{}[i].fromC(&v); err != nil {{\n'.format(goname)
- s += 'return fmt.Errorf("converting field {}: %v", err) }}\n'.format(goname)
+ s += 'if err := x.{0}[i].fromC(&v); err != nil {{\n'.format(goname)
+ s += 'return fmt.Errorf("converting field {0}: %v", err) }}\n'.format(goname)
s += '}\n}\n'
Define the toC marshaling function for the type
represented by ty.
"""
- func = 'func (x *{}) toC(xc *C.{}) (err error){{{}\n return nil\n }}\n'
+ func = 'func (x *{0}) toC(xc *C.{1}) (err error){{{2}\n return nil\n }}\n'
body = ''
if ty.dispose_fn is not None:
- body += 'defer func(){{\nif err != nil{{\nC.{}(xc)}}\n}}()\n\n'.format(ty.dispose_fn)
+ body += 'defer func(){{\nif err != nil{{\nC.{0}(xc)}}\n}}()\n\n'.format(ty.dispose_fn)
goname = xenlight_golang_fmt_name(ty.typename)
cname = ty.typename
body += xenlight_golang_union_to_C(f.type, f.name, ty.typename)
else:
- raise Exception('type {} not supported'.format(f.type))
+ raise Exception('type {0} not supported'.format(f.type))
return func.format(goname, cname, body)
# If outer_name is set, treat this as nested.
if outer_name is not None:
- goname = '{}.{}'.format(xenlight_golang_fmt_name(outer_name), goname)
- cname = '{}.{}'.format(outer_name, cname)
+ goname = '{0}.{1}'.format(xenlight_golang_fmt_name(outer_name), goname)
+ cname = '{0}.{1}'.format(outer_name, cname)
is_castable = (ty.type.json_parse_type == 'JSON_INTEGER' or
isinstance(ty.type, idl.Enumeration) or
gotypename in go_builtin_types)
if not is_castable:
- s += 'if err := {}.{}.toC(&{}.{}); err != nil {{\n'.format(govarname,goname,
+ s += 'if err := {0}.{1}.toC(&{2}.{3}); err != nil {{\n'.format(govarname,goname,
cvarname,cname)
- s += 'return fmt.Errorf("converting field {}: %v", err)\n}}\n'.format(goname)
+ s += 'return fmt.Errorf("converting field {0}: %v", err)\n}}\n'.format(goname)
elif gotypename == 'string':
# Use the cgo helper for converting C strings.
- s += 'if {}.{} != "" {{\n'.format(govarname,goname)
- s += '{}.{} = C.CString({}.{})}}\n'.format(cvarname,cname,
+ s += 'if {0}.{1} != "" {{\n'.format(govarname,goname)
+ s += '{0}.{1} = C.CString({2}.{3})}}\n'.format(cvarname,cname,
govarname,goname)
else:
- s += '{}.{} = C.{}({}.{})\n'.format(cvarname,cname,ctypename,
+ s += '{0}.{1} = C.{2}({3}.{4})\n'.format(cvarname,cname,ctypename,
govarname,goname)
return s
keytype = ty.keyvar.type.typename
gokeytype = xenlight_golang_fmt_name(keytype)
- interface_name = '{}_{}_union'.format(struct_name, keyname)
+ interface_name = '{0}_{1}_union'.format(struct_name, keyname)
interface_name = xenlight_golang_fmt_name(interface_name, exported=False)
cgo_keyname = keyname
cgo_keyname = '_' + cgo_keyname
- s = 'xc.{} = C.{}(x.{})\n'.format(cgo_keyname,keytype,gokeyname)
- s += 'switch x.{}{{\n'.format(gokeyname)
+ s = 'xc.{0} = C.{1}(x.{2})\n'.format(cgo_keyname,keytype,gokeyname)
+ s += 'switch x.{0}{{\n'.format(gokeyname)
# Create switch statement to determine how to populate the C union.
for f in ty.fields:
- key_val = '{}_{}'.format(keytype, f.name)
+ key_val = '{0}_{1}'.format(keytype, f.name)
key_val = xenlight_golang_fmt_name(key_val)
- s += 'case {}:\n'.format(key_val)
+ s += 'case {0}:\n'.format(key_val)
if f.type is None:
s += "break\n"
continue
- cgotype = '{}_{}_union_{}'.format(struct_name,keyname,f.name)
+ cgotype = '{0}_{1}_union_{2}'.format(struct_name,keyname,f.name)
gotype = xenlight_golang_fmt_name(cgotype)
- field_name = xenlight_golang_fmt_name('{}_union'.format(keyname))
- s += 'tmp, ok := x.{}.({})\n'.format(field_name,gotype)
+ field_name = xenlight_golang_fmt_name('{0}_union'.format(keyname))
+ s += 'tmp, ok := x.{0}.({1})\n'.format(field_name,gotype)
s += 'if !ok {\n'
- s += 'return errors.New("wrong type for union key {}")\n'.format(keyname)
+ s += 'return errors.New("wrong type for union key {0}")\n'.format(keyname)
s += '}\n'
- s += 'var {} C.{}\n'.format(f.name,cgotype)
+ s += 'var {0} C.{1}\n'.format(f.name,cgotype)
for uf in f.type.fields:
s += xenlight_golang_convert_to_C(uf,cvarname=f.name,
govarname='tmp')
# The union is still represented as Go []byte.
- s += '{}Bytes := C.GoBytes(unsafe.Pointer(&{}),C.sizeof_{})\n'.format(f.name,
+ s += '{0}Bytes := C.GoBytes(unsafe.Pointer(&{1}),C.sizeof_{2})\n'.format(f.name,
f.name,
cgotype)
- s += 'copy(xc.{}[:],{}Bytes)\n'.format(union_name,f.name)
+ s += 'copy(xc.{0}[:],{1}Bytes)\n'.format(union_name,f.name)
# End switch statement
s += 'default:\n'
- err_string = '"invalid union key \'%v\'", x.{}'.format(gokeyname)
- s += 'return fmt.Errorf({})'.format(err_string)
+ err_string = '"invalid union key \'%v\'", x.{0}'.format(gokeyname)
+ s += 'return fmt.Errorf({0})'.format(err_string)
s += '}\n'
return s
is_enum = isinstance(ty.type.elem_type,idl.Enumeration)
if gotypename in go_builtin_types or is_enum:
- s += 'if {} := len(x.{}); {} > 0 {{\n'.format(golenvar,goname,golenvar)
- s += 'xc.{} = (*C.{})(C.malloc(C.size_t({}*{})))\n'.format(cname,ctypename,
+ s += 'if {0} := len(x.{1}); {2} > 0 {{\n'.format(golenvar,goname,golenvar)
+ s += 'xc.{0} = (*C.{1})(C.malloc(C.size_t({2}*{3})))\n'.format(cname,ctypename,
golenvar,golenvar)
- s += 'xc.{} = C.int({})\n'.format(clenvar,golenvar)
- s += 'c{} := (*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(goname,
+ s += 'xc.{0} = C.int({1})\n'.format(clenvar,golenvar)
+ s += 'c{0} := (*[1<<28]C.{1})(unsafe.Pointer(xc.{2}))[:{3}:{4}]\n'.format(goname,
ctypename,cname,
golenvar,golenvar)
- s += 'for i,v := range x.{} {{\n'.format(goname)
- s += 'c{}[i] = C.{}(v)\n'.format(goname,ctypename)
+ s += 'for i,v := range x.{0} {{\n'.format(goname)
+ s += 'c{0}[i] = C.{1}(v)\n'.format(goname,ctypename)
s += '}\n}\n'
return s
- s += 'if {} := len(x.{}); {} > 0 {{\n'.format(golenvar,goname,golenvar)
- s += 'xc.{} = (*C.{})(C.malloc(C.ulong({})*C.sizeof_{}))\n'.format(cname,ctypename,
+ s += 'if {0} := len(x.{1}); {2} > 0 {{\n'.format(golenvar,goname,golenvar)
+ s += 'xc.{0} = (*C.{1})(C.malloc(C.ulong({2})*C.sizeof_{3}))\n'.format(cname,ctypename,
golenvar,ctypename)
- s += 'xc.{} = C.int({})\n'.format(clenvar,golenvar)
- s += 'c{} := (*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(goname,
+ s += 'xc.{0} = C.int({1})\n'.format(clenvar,golenvar)
+ s += 'c{0} := (*[1<<28]C.{1})(unsafe.Pointer(xc.{2}))[:{3}:{4}]\n'.format(goname,
ctypename,cname,
golenvar,golenvar)
- s += 'for i,v := range x.{} {{\n'.format(goname)
- s += 'if err := v.toC(&c{}[i]); err != nil {{\n'.format(goname)
- s += 'return fmt.Errorf("converting field {}: %v", err)\n'.format(goname)
+ s += 'for i,v := range x.{0} {{\n'.format(goname)
+ s += 'if err := v.toC(&c{0}[i]); err != nil {{\n'.format(goname)
+ s += 'return fmt.Errorf("converting field {0}: %v", err)\n'.format(goname)
s += '}\n}\n}\n'
return s
gotypename = xenlight_golang_fmt_name(ctypename)
# Since this func is exported, add a comment as per Go conventions.
- s += '// New{} returns an instance of {}'.format(gotypename,gotypename)
+ s += '// New{0} returns an instance of {1}'.format(gotypename,gotypename)
s += ' initialized with defaults.\n'
# If a struct has a keyed union, an extra argument is
init_fns = []
# Add call to parent init_fn first.
- init_fns.append('C.{}(&xc)'.format(ty.init_fn))
+ init_fns.append('C.{0}(&xc)'.format(ty.init_fn))
for f in ty.fields:
if not isinstance(f.type, idl.KeyedUnion):
# Serveral keyed unions use 'type' as the key variable name. In
# that case, prepend the first letter of the Go type name.
if param_goname == 'type':
- param_goname = '{}type'.format(param_gotype.lower()[0])
+ param_goname = '{0}type'.format(param_gotype.lower()[0])
# Add call to keyed union's init_fn.
- init_fns.append('C.{}_{}(&xc, C.{}({}))'.format(ty.init_fn,
+ init_fns.append('C.{0}_{1}(&xc, C.{2}({3}))'.format(ty.init_fn,
param.name,
param_ctype,
param_goname))
# Add to params list.
- params.append('{} {}'.format(param_goname, param_gotype))
+ params.append('{0} {1}'.format(param_goname, param_gotype))
# Define function
- s += 'func New{}({}) (*{}, error) {{\n'.format(gotypename,
+ s += 'func New{0}({1}) (*{2}, error) {{\n'.format(gotypename,
','.join(params),
gotypename)
# Declare variables.
- s += 'var (\nx {}\nxc C.{})\n\n'.format(gotypename, ctypename)
+ s += 'var (\nx {0}\nxc C.{1})\n\n'.format(gotypename, ctypename)
# Write init_fn calls.
s += '\n'.join(init_fns)
# Make sure dispose_fn get's called when constructor
# returns.
if ty.dispose_fn is not None:
- s += 'defer C.{}(&xc)\n'.format(ty.dispose_fn)
+ s += 'defer C.{0}(&xc)\n'.format(ty.dispose_fn)
s += '\n'
header_comment="""// DO NOT EDIT.
//
// This file is generated by:
-// {}
+// {0}
//
""".format(' '.join(sys.argv))
projects / people / jgross / xen.git / commitdiff