|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [PATCH for-4.14] golang/xenlight: fix code generation for python 2.6
Before python 2.7, str.format() calls required that the format fields
were explicitly enumerated, e.g.:
'{0} {1}'.format(foo, bar)
vs.
'{} {}'.format(foo, bar)
Currently, gengotypes.py uses the latter pattern everywhere, which means
the Go bindings do not build on python 2.6. Use the 2.6 syntax for
format() in order to support python 2.6 for now.
Signed-off-by: Nick Rosbrook <rosbrookn@xxxxxxxxxxxx>
---
tools/golang/xenlight/gengotypes.py | 204 ++++++++++++++--------------
1 file changed, 102 insertions(+), 102 deletions(-)
diff --git a/tools/golang/xenlight/gengotypes.py
b/tools/golang/xenlight/gengotypes.py
index 557fecd07b..ebec938224 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -3,7 +3,7 @@
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.
@@ -73,14 +73,14 @@ def xenlight_golang_define_enum(ty = None):
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'
@@ -99,9 +99,9 @@ def xenlight_golang_define_struct(ty = None, typename = None,
nested = False):
# 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:
@@ -111,13 +111,13 @@ def xenlight_golang_define_struct(ty = None, typename =
None, nested = False):
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)
@@ -132,7 +132,7 @@ def xenlight_golang_define_struct(ty = None, typename =
None, nested = False):
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'
@@ -151,11 +151,11 @@ def xenlight_golang_define_union(ty = None, struct_name =
'', union_name = ''):
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)
@@ -165,7 +165,7 @@ def xenlight_golang_define_union(ty = None, struct_name =
'', union_name = ''):
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])
@@ -173,21 +173,21 @@ def xenlight_golang_define_union(ty = None, struct_name =
'', union_name = ''):
# 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)
@@ -243,7 +243,7 @@ def xenlight_golang_define_from_C(ty = None):
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
@@ -271,7 +271,7 @@ def xenlight_golang_define_from_C(ty = None):
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)
@@ -300,8 +300,8 @@ def xenlight_golang_convert_from_C(ty = None, outer_name =
None, cvarname = None
# 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.
@@ -312,15 +312,15 @@ def xenlight_golang_convert_from_C(ty = None, outer_name
= None, cvarname = None
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
@@ -331,9 +331,9 @@ def xenlight_golang_union_from_C(ty = None, union_name =
'', struct_name = ''):
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
@@ -343,7 +343,7 @@ def xenlight_golang_union_from_C(ty = None, union_name =
'', struct_name = ''):
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
@@ -354,17 +354,17 @@ def xenlight_golang_union_from_C(ty = None, union_name =
'', struct_name = ''):
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')
@@ -374,35 +374,35 @@ def xenlight_golang_union_from_C(ty = None, union_name =
'', struct_name = ''):
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)
@@ -420,22 +420,22 @@ def xenlight_golang_array_from_C(ty = None):
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'
@@ -446,11 +446,11 @@ def xenlight_golang_define_to_C(ty = None, typename =
None, nested = False):
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
@@ -471,7 +471,7 @@ def xenlight_golang_define_to_C(ty = None, typename = None,
nested = False):
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)
@@ -506,26 +506,26 @@ def xenlight_golang_convert_to_C(ty = None, outer_name =
None,
# 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
@@ -537,7 +537,7 @@ def xenlight_golang_union_to_C(ty = None, union_name = '',
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
@@ -545,44 +545,44 @@ def xenlight_golang_union_to_C(ty = None, union_name = '',
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
@@ -599,29 +599,29 @@ def xenlight_golang_array_to_C(ty = None):
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
@@ -633,7 +633,7 @@ def xenlight_golang_define_constructor(ty = None):
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
@@ -643,7 +643,7 @@ def xenlight_golang_define_constructor(ty = None):
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):
@@ -658,24 +658,24 @@ def xenlight_golang_define_constructor(ty = None):
# 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)
@@ -684,7 +684,7 @@ def xenlight_golang_define_constructor(ty = None):
# 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'
@@ -727,7 +727,7 @@ if __name__ == '__main__':
header_comment="""// DO NOT EDIT.
//
// This file is generated by:
-// {}
+// {0}
//
""".format(' '.join(sys.argv))
--
2.17.1
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |