summaryrefslogtreecommitdiff
path: root/src/cmd/cgo
diff options
context:
space:
mode:
Diffstat (limited to 'src/cmd/cgo')
-rw-r--r--src/cmd/cgo/ast.go230
-rw-r--r--src/cmd/cgo/gcc.go412
-rw-r--r--src/cmd/cgo/main.go60
-rw-r--r--src/cmd/cgo/out.go170
-rw-r--r--src/cmd/cgo/util.go74
5 files changed, 473 insertions, 473 deletions
diff --git a/src/cmd/cgo/ast.go b/src/cmd/cgo/ast.go
index ccaef69d1..b309c33d4 100644
--- a/src/cmd/cgo/ast.go
+++ b/src/cmd/cgo/ast.go
@@ -7,57 +7,57 @@
package main
import (
- "fmt";
- "go/ast";
- "go/doc";
- "go/parser";
- "go/scanner";
- "os";
+ "fmt"
+ "go/ast"
+ "go/doc"
+ "go/parser"
+ "go/scanner"
+ "os"
)
// A Cref refers to an expression of the form C.xxx in the AST.
type Cref struct {
- Name string;
- Expr *ast.Expr;
- Context string; // "type", "expr", or "call"
- TypeName bool; // whether xxx is a C type name
- Type *Type; // the type of xxx
- FuncType *FuncType;
+ Name string
+ Expr *ast.Expr
+ Context string // "type", "expr", or "call"
+ TypeName bool // whether xxx is a C type name
+ Type *Type // the type of xxx
+ FuncType *FuncType
}
// A Prog collects information about a cgo program.
type Prog struct {
- AST *ast.File; // parsed AST
- Preamble string; // C preamble (doc comment on import "C")
- PackagePath string;
- Package string;
- Crefs []*Cref;
- Typedef map[string]ast.Expr;
- Vardef map[string]*Type;
- Funcdef map[string]*FuncType;
- PtrSize int64;
- GccOptions []string;
+ AST *ast.File // parsed AST
+ Preamble string // C preamble (doc comment on import "C")
+ PackagePath string
+ Package string
+ Crefs []*Cref
+ Typedef map[string]ast.Expr
+ Vardef map[string]*Type
+ Funcdef map[string]*FuncType
+ PtrSize int64
+ GccOptions []string
}
// A Type collects information about a type in both the C and Go worlds.
type Type struct {
- Size int64;
- Align int64;
- C string;
- Go ast.Expr;
+ Size int64
+ Align int64
+ C string
+ Go ast.Expr
}
// A FuncType collects information about a function type in both the C and Go worlds.
type FuncType struct {
- Params []*Type;
- Result *Type;
- Go *ast.FuncType;
+ Params []*Type
+ Result *Type
+ Go *ast.FuncType
}
func openProg(name string) *Prog {
- p := new(Prog);
- var err os.Error;
- p.AST, err = parser.ParsePkgFile("", name, parser.ParseComments);
+ p := new(Prog)
+ var err os.Error
+ p.AST, err = parser.ParsePkgFile("", name, parser.ParseComments)
if err != nil {
if list, ok := err.(scanner.ErrorList); ok {
// If err is a scanner.ErrorList, its String will print just
@@ -67,32 +67,32 @@ func openProg(name string) *Prog {
for _, e := range list {
fmt.Fprintln(os.Stderr, e)
}
- os.Exit(2);
+ os.Exit(2)
}
- fatal("parsing %s: %s", name, err);
+ fatal("parsing %s: %s", name, err)
}
- p.Package = p.AST.Name.Value;
+ p.Package = p.AST.Name.Value
// Find the import "C" line and get any extra C preamble.
// Delete the import "C" line along the way.
- sawC := false;
- w := 0;
+ sawC := false
+ w := 0
for _, decl := range p.AST.Decls {
- d, ok := decl.(*ast.GenDecl);
+ d, ok := decl.(*ast.GenDecl)
if !ok {
- p.AST.Decls[w] = decl;
- w++;
- continue;
+ p.AST.Decls[w] = decl
+ w++
+ continue
}
- ws := 0;
+ ws := 0
for _, spec := range d.Specs {
- s, ok := spec.(*ast.ImportSpec);
+ s, ok := spec.(*ast.ImportSpec)
if !ok || len(s.Path) != 1 || string(s.Path[0].Value) != `"C"` {
- d.Specs[ws] = spec;
- ws++;
- continue;
+ d.Specs[ws] = spec
+ ws++
+ continue
}
- sawC = true;
+ sawC = true
if s.Name != nil {
error(s.Path[0].Pos(), `cannot rename import "C"`)
}
@@ -105,20 +105,20 @@ func openProg(name string) *Prog {
if ws == 0 {
continue
}
- d.Specs = d.Specs[0:ws];
- p.AST.Decls[w] = d;
- w++;
+ d.Specs = d.Specs[0:ws]
+ p.AST.Decls[w] = d
+ w++
}
- p.AST.Decls = p.AST.Decls[0:w];
+ p.AST.Decls = p.AST.Decls[0:w]
if !sawC {
error(noPos, `cannot find import "C"`)
}
// Accumulate pointers to uses of C.x.
- p.Crefs = make([]*Cref, 0, 8);
- walk(p.AST, p, "prog");
- return p;
+ p.Crefs = make([]*Cref, 0, 8)
+ walk(p.AST, p, "prog")
+ return p
}
func walk(x interface{}, p *Prog, context string) {
@@ -131,29 +131,29 @@ func walk(x interface{}, p *Prog, context string) {
// so that we will be able to distinguish a "top-level C"
// from a local C.
if l, ok := sel.X.(*ast.Ident); ok && l.Value == "C" {
- i := len(p.Crefs);
+ i := len(p.Crefs)
if i >= cap(p.Crefs) {
- new := make([]*Cref, 2*i);
+ new := make([]*Cref, 2*i)
for j, v := range p.Crefs {
new[j] = v
}
- p.Crefs = new;
+ p.Crefs = new
}
- p.Crefs = p.Crefs[0 : i+1];
+ p.Crefs = p.Crefs[0 : i+1]
p.Crefs[i] = &Cref{
Name: sel.Sel.Value,
Expr: n,
Context: context,
- };
- break;
+ }
+ break
}
}
- walk(*n, p, context);
+ walk(*n, p, context)
// everything else just recurs
default:
- error(noPos, "unexpected type %T in walk", x);
- panic();
+ error(noPos, "unexpected type %T in walk", x)
+ panic()
case nil:
@@ -166,54 +166,54 @@ func walk(x interface{}, p *Prog, context string) {
case *ast.BasicLit:
case *ast.StringList:
case *ast.FuncLit:
- walk(n.Type, p, "type");
- walk(n.Body, p, "stmt");
+ walk(n.Type, p, "type")
+ walk(n.Body, p, "stmt")
case *ast.CompositeLit:
- walk(&n.Type, p, "type");
- walk(n.Elts, p, "expr");
+ walk(&n.Type, p, "type")
+ walk(n.Elts, p, "expr")
case *ast.ParenExpr:
walk(&n.X, p, context)
case *ast.SelectorExpr:
walk(&n.X, p, "selector")
case *ast.IndexExpr:
- walk(&n.X, p, "expr");
- walk(&n.Index, p, "expr");
+ walk(&n.X, p, "expr")
+ walk(&n.Index, p, "expr")
case *ast.SliceExpr:
- walk(&n.X, p, "expr");
- walk(&n.Index, p, "expr");
+ walk(&n.X, p, "expr")
+ walk(&n.Index, p, "expr")
if n.End != nil {
walk(&n.End, p, "expr")
}
case *ast.TypeAssertExpr:
- walk(&n.X, p, "expr");
- walk(&n.Type, p, "type");
+ walk(&n.X, p, "expr")
+ walk(&n.Type, p, "type")
case *ast.CallExpr:
- walk(&n.Fun, p, "call");
- walk(n.Args, p, "expr");
+ walk(&n.Fun, p, "call")
+ walk(n.Args, p, "expr")
case *ast.StarExpr:
walk(&n.X, p, context)
case *ast.UnaryExpr:
walk(&n.X, p, "expr")
case *ast.BinaryExpr:
- walk(&n.X, p, "expr");
- walk(&n.Y, p, "expr");
+ walk(&n.X, p, "expr")
+ walk(&n.Y, p, "expr")
case *ast.KeyValueExpr:
- walk(&n.Key, p, "expr");
- walk(&n.Value, p, "expr");
+ walk(&n.Key, p, "expr")
+ walk(&n.Value, p, "expr")
case *ast.ArrayType:
- walk(&n.Len, p, "expr");
- walk(&n.Elt, p, "type");
+ walk(&n.Len, p, "expr")
+ walk(&n.Elt, p, "type")
case *ast.StructType:
walk(n.Fields, p, "field")
case *ast.FuncType:
- walk(n.Params, p, "field");
- walk(n.Results, p, "field");
+ walk(n.Params, p, "field")
+ walk(n.Results, p, "field")
case *ast.InterfaceType:
walk(n.Methods, p, "field")
case *ast.MapType:
- walk(&n.Key, p, "type");
- walk(&n.Value, p, "type");
+ walk(&n.Key, p, "type")
+ walk(&n.Value, p, "type")
case *ast.ChanType:
walk(&n.Value, p, "type")
@@ -228,8 +228,8 @@ func walk(x interface{}, p *Prog, context string) {
case *ast.IncDecStmt:
walk(&n.X, p, "expr")
case *ast.AssignStmt:
- walk(n.Lhs, p, "expr");
- walk(n.Rhs, p, "expr");
+ walk(n.Lhs, p, "expr")
+ walk(n.Rhs, p, "expr")
case *ast.GoStmt:
walk(n.Call, p, "expr")
case *ast.DeferStmt:
@@ -240,45 +240,45 @@ func walk(x interface{}, p *Prog, context string) {
case *ast.BlockStmt:
walk(n.List, p, "stmt")
case *ast.IfStmt:
- walk(n.Init, p, "stmt");
- walk(&n.Cond, p, "expr");
- walk(n.Body, p, "stmt");
- walk(n.Else, p, "stmt");
+ walk(n.Init, p, "stmt")
+ walk(&n.Cond, p, "expr")
+ walk(n.Body, p, "stmt")
+ walk(n.Else, p, "stmt")
case *ast.CaseClause:
- walk(n.Values, p, "expr");
- walk(n.Body, p, "stmt");
+ walk(n.Values, p, "expr")
+ walk(n.Body, p, "stmt")
case *ast.SwitchStmt:
- walk(n.Init, p, "stmt");
- walk(&n.Tag, p, "expr");
- walk(n.Body, p, "stmt");
+ walk(n.Init, p, "stmt")
+ walk(&n.Tag, p, "expr")
+ walk(n.Body, p, "stmt")
case *ast.TypeCaseClause:
- walk(n.Types, p, "type");
- walk(n.Body, p, "stmt");
+ walk(n.Types, p, "type")
+ walk(n.Body, p, "stmt")
case *ast.TypeSwitchStmt:
- walk(n.Init, p, "stmt");
- walk(n.Assign, p, "stmt");
- walk(n.Body, p, "stmt");
+ walk(n.Init, p, "stmt")
+ walk(n.Assign, p, "stmt")
+ walk(n.Body, p, "stmt")
case *ast.CommClause:
- walk(n.Lhs, p, "expr");
- walk(n.Rhs, p, "expr");
- walk(n.Body, p, "stmt");
+ walk(n.Lhs, p, "expr")
+ walk(n.Rhs, p, "expr")
+ walk(n.Body, p, "stmt")
case *ast.SelectStmt:
walk(n.Body, p, "stmt")
case *ast.ForStmt:
- walk(n.Init, p, "stmt");
- walk(&n.Cond, p, "expr");
- walk(n.Post, p, "stmt");
- walk(n.Body, p, "stmt");
+ walk(n.Init, p, "stmt")
+ walk(&n.Cond, p, "expr")
+ walk(n.Post, p, "stmt")
+ walk(n.Body, p, "stmt")
case *ast.RangeStmt:
- walk(&n.Key, p, "expr");
- walk(&n.Value, p, "expr");
- walk(&n.X, p, "expr");
- walk(n.Body, p, "stmt");
+ walk(&n.Key, p, "expr")
+ walk(&n.Value, p, "expr")
+ walk(&n.X, p, "expr")
+ walk(n.Body, p, "stmt")
case *ast.ImportSpec:
case *ast.ValueSpec:
- walk(&n.Type, p, "type");
- walk(n.Values, p, "expr");
+ walk(&n.Type, p, "type")
+ walk(n.Values, p, "expr")
case *ast.TypeSpec:
walk(&n.Type, p, "type")
@@ -289,7 +289,7 @@ func walk(x interface{}, p *Prog, context string) {
if n.Recv != nil {
walk(n.Recv, p, "field")
}
- walk(n.Type, p, "type");
+ walk(n.Type, p, "type")
if n.Body != nil {
walk(n.Body, p, "stmt")
}
diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index 7d377db54..c42cb7300 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -8,30 +8,30 @@
package main
import (
- "bytes";
- "debug/dwarf";
- "debug/elf";
- "debug/macho";
- "fmt";
- "go/ast";
- "go/token";
- "os";
- "strconv";
- "strings";
+ "bytes"
+ "debug/dwarf"
+ "debug/elf"
+ "debug/macho"
+ "fmt"
+ "go/ast"
+ "go/token"
+ "os"
+ "strconv"
+ "strings"
)
func (p *Prog) loadDebugInfo() {
// Construct a slice of unique names from p.Crefs.
- m := make(map[string]int);
+ m := make(map[string]int)
for _, c := range p.Crefs {
m[c.Name] = -1
}
- names := make([]string, 0, len(m));
+ names := make([]string, 0, len(m))
for name, _ := range m {
- i := len(names);
- names = names[0 : i+1];
- names[i] = name;
- m[name] = i;
+ i := len(names)
+ names = names[0 : i+1]
+ names[i] = name
+ m[name] = i
}
// Coerce gcc into telling us whether each name is
@@ -46,18 +46,18 @@ func (p *Prog) loadDebugInfo() {
// x.c:2: error: 'name' undeclared (first use in this function)
// A line number directive causes the line number to
// correspond to the index in the names array.
- var b bytes.Buffer;
- b.WriteString(p.Preamble);
- b.WriteString("void f(void) {\n");
- b.WriteString("#line 0 \"cgo-test\"\n");
+ var b bytes.Buffer
+ b.WriteString(p.Preamble)
+ b.WriteString("void f(void) {\n")
+ b.WriteString("#line 0 \"cgo-test\"\n")
for _, n := range names {
- b.WriteString(n);
- b.WriteString(";\n");
+ b.WriteString(n)
+ b.WriteString(";\n")
}
- b.WriteString("}\n");
+ b.WriteString("}\n")
- kind := make(map[string]string);
- _, stderr := p.gccDebug(b.Bytes());
+ kind := make(map[string]string)
+ _, stderr := p.gccDebug(b.Bytes())
if stderr == "" {
fatal("gcc produced no output")
}
@@ -65,16 +65,16 @@ func (p *Prog) loadDebugInfo() {
if len(line) < 9 || line[0:9] != "cgo-test:" {
continue
}
- line = line[9:];
- colon := strings.Index(line, ":");
+ line = line[9:]
+ colon := strings.Index(line, ":")
if colon < 0 {
continue
}
- i, err := strconv.Atoi(line[0:colon]);
+ i, err := strconv.Atoi(line[0:colon])
if err != nil {
continue
}
- what := "";
+ what := ""
switch {
default:
continue
@@ -88,7 +88,7 @@ func (p *Prog) loadDebugInfo() {
if old, ok := kind[names[i]]; ok && old != what {
error(noPos, "inconsistent gcc output about C.%s", names[i])
}
- kind[names[i]] = what;
+ kind[names[i]] = what
}
for _, n := range names {
if _, ok := kind[n]; !ok {
@@ -108,21 +108,21 @@ func (p *Prog) loadDebugInfo() {
// typeof(names[i]) *__cgo__i;
// for each entry in names and then dereference the type we
// learn for __cgo__i.
- b.Reset();
- b.WriteString(p.Preamble);
+ b.Reset()
+ b.WriteString(p.Preamble)
for i, n := range names {
fmt.Fprintf(&b, "typeof(%s) *__cgo__%d;\n", n, i)
}
- d, stderr := p.gccDebug(b.Bytes());
+ d, stderr := p.gccDebug(b.Bytes())
if d == nil {
fatal("gcc failed:\n%s\non input:\n%s", stderr, b.Bytes())
}
// Scan DWARF info for top-level TagVariable entries with AttrName __cgo__i.
- types := make([]dwarf.Type, len(names));
- r := d.Reader();
+ types := make([]dwarf.Type, len(names))
+ r := d.Reader()
for {
- e, err := r.Next();
+ e, err := r.Next()
if err != nil {
fatal("reading DWARF entry: %s", err)
}
@@ -132,27 +132,27 @@ func (p *Prog) loadDebugInfo() {
if e.Tag != dwarf.TagVariable {
goto Continue
}
- name, _ := e.Val(dwarf.AttrName).(string);
- typOff, _ := e.Val(dwarf.AttrType).(dwarf.Offset);
+ name, _ := e.Val(dwarf.AttrName).(string)
+ typOff, _ := e.Val(dwarf.AttrType).(dwarf.Offset)
if name == "" || typOff == 0 {
fatal("malformed DWARF TagVariable entry")
}
if !strings.HasPrefix(name, "__cgo__") {
goto Continue
}
- typ, err := d.Type(typOff);
+ typ, err := d.Type(typOff)
if err != nil {
fatal("loading DWARF type: %s", err)
}
- t, ok := typ.(*dwarf.PtrType);
+ t, ok := typ.(*dwarf.PtrType)
if !ok || t == nil {
fatal("internal error: %s has non-pointer type", name)
}
- i, err := strconv.Atoi(name[7:]);
+ i, err := strconv.Atoi(name[7:])
if err != nil {
fatal("malformed __cgo__ name: %s", name)
}
- types[i] = t.Type;
+ types[i] = t.Type
Continue:
if e.Tag != dwarf.TagCompileUnit {
@@ -161,132 +161,132 @@ func (p *Prog) loadDebugInfo() {
}
// Record types and typedef information in Crefs.
- var conv typeConv;
- conv.Init(p.PtrSize);
+ var conv typeConv
+ conv.Init(p.PtrSize)
for _, c := range p.Crefs {
- i := m[c.Name];
- c.TypeName = kind[c.Name] == "type";
- f, fok := types[i].(*dwarf.FuncType);
+ i := m[c.Name]
+ c.TypeName = kind[c.Name] == "type"
+ f, fok := types[i].(*dwarf.FuncType)
if c.Context == "call" && !c.TypeName && fok {
c.FuncType = conv.FuncType(f)
} else {
c.Type = conv.Type(types[i])
}
}
- p.Typedef = conv.typedef;
+ p.Typedef = conv.typedef
}
func concat(a, b []string) []string {
- c := make([]string, len(a)+len(b));
+ c := make([]string, len(a)+len(b))
for i, s := range a {
c[i] = s
}
for i, s := range b {
c[i+len(a)] = s
}
- return c;
+ return c
}
// gccDebug runs gcc -gdwarf-2 over the C program stdin and
// returns the corresponding DWARF data and any messages
// printed to standard error.
func (p *Prog) gccDebug(stdin []byte) (*dwarf.Data, string) {
- machine := "-m32";
+ machine := "-m32"
if p.PtrSize == 8 {
machine = "-m64"
}
- tmp := "_cgo_.o";
+ tmp := "_cgo_.o"
base := []string{
"gcc",
machine,
- "-Wall", // many warnings
- "-Werror", // warnings are errors
- "-o" + tmp, // write object to tmp
- "-gdwarf-2", // generate DWARF v2 debugging symbols
- "-c", // do not link
- "-xc", // input language is C
- "-", // read input from standard input
- };
- _, stderr, ok := run(stdin, concat(base, p.GccOptions));
+ "-Wall", // many warnings
+ "-Werror", // warnings are errors
+ "-o" + tmp, // write object to tmp
+ "-gdwarf-2", // generate DWARF v2 debugging symbols
+ "-c", // do not link
+ "-xc", // input language is C
+ "-", // read input from standard input
+ }
+ _, stderr, ok := run(stdin, concat(base, p.GccOptions))
if !ok {
return nil, string(stderr)
}
// Try to parse f as ELF and Mach-O and hope one works.
var f interface {
- DWARF() (*dwarf.Data, os.Error);
+ DWARF() (*dwarf.Data, os.Error)
}
- var err os.Error;
+ var err os.Error
if f, err = elf.Open(tmp); err != nil {
if f, err = macho.Open(tmp); err != nil {
fatal("cannot parse gcc output %s as ELF or Mach-O object", tmp)
}
}
- d, err := f.DWARF();
+ d, err := f.DWARF()
if err != nil {
fatal("cannot load DWARF debug information from %s: %s", tmp, err)
}
- return d, "";
+ return d, ""
}
// A typeConv is a translator from dwarf types to Go types
// with equivalent memory layout.
type typeConv struct {
// Cache of already-translated or in-progress types.
- m map[dwarf.Type]*Type;
- typedef map[string]ast.Expr;
+ m map[dwarf.Type]*Type
+ typedef map[string]ast.Expr
// Predeclared types.
- byte ast.Expr; // denotes padding
- int8, int16, int32, int64 ast.Expr;
- uint8, uint16, uint32, uint64, uintptr ast.Expr;
- float32, float64 ast.Expr;
- void ast.Expr;
- unsafePointer ast.Expr;
- string ast.Expr;
+ byte ast.Expr // denotes padding
+ int8, int16, int32, int64 ast.Expr
+ uint8, uint16, uint32, uint64, uintptr ast.Expr
+ float32, float64 ast.Expr
+ void ast.Expr
+ unsafePointer ast.Expr
+ string ast.Expr
- ptrSize int64;
+ ptrSize int64
- tagGen int;
+ tagGen int
}
func (c *typeConv) Init(ptrSize int64) {
- c.ptrSize = ptrSize;
- c.m = make(map[dwarf.Type]*Type);
- c.typedef = make(map[string]ast.Expr);
- c.byte = c.Ident("byte");
- c.int8 = c.Ident("int8");
- c.int16 = c.Ident("int16");
- c.int32 = c.Ident("int32");
- c.int64 = c.Ident("int64");
- c.uint8 = c.Ident("uint8");
- c.uint16 = c.Ident("uint16");
- c.uint32 = c.Ident("uint32");
- c.uint64 = c.Ident("uint64");
- c.uintptr = c.Ident("uintptr");
- c.float32 = c.Ident("float32");
- c.float64 = c.Ident("float64");
- c.unsafePointer = c.Ident("unsafe.Pointer");
- c.void = c.Ident("void");
- c.string = c.Ident("string");
+ c.ptrSize = ptrSize
+ c.m = make(map[dwarf.Type]*Type)
+ c.typedef = make(map[string]ast.Expr)
+ c.byte = c.Ident("byte")
+ c.int8 = c.Ident("int8")
+ c.int16 = c.Ident("int16")
+ c.int32 = c.Ident("int32")
+ c.int64 = c.Ident("int64")
+ c.uint8 = c.Ident("uint8")
+ c.uint16 = c.Ident("uint16")
+ c.uint32 = c.Ident("uint32")
+ c.uint64 = c.Ident("uint64")
+ c.uintptr = c.Ident("uintptr")
+ c.float32 = c.Ident("float32")
+ c.float64 = c.Ident("float64")
+ c.unsafePointer = c.Ident("unsafe.Pointer")
+ c.void = c.Ident("void")
+ c.string = c.Ident("string")
}
// base strips away qualifiers and typedefs to get the underlying type
func base(dt dwarf.Type) dwarf.Type {
for {
if d, ok := dt.(*dwarf.QualType); ok {
- dt = d.Type;
- continue;
+ dt = d.Type
+ continue
}
if d, ok := dt.(*dwarf.TypedefType); ok {
- dt = d.Type;
- continue;
+ dt = d.Type
+ continue
}
- break;
+ break
}
- return dt;
+ return dt
}
// Map from dwarf text names to aliases we use in package "C".
@@ -308,22 +308,22 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
if t.Go == nil {
fatal("type conversion loop at %s", dtype)
}
- return t;
+ return t
}
- t := new(Type);
- t.Size = dtype.Size();
- t.Align = -1;
- t.C = dtype.Common().Name;
- c.m[dtype] = t;
+ t := new(Type)
+ t.Size = dtype.Size()
+ t.Align = -1
+ t.C = dtype.Common().Name
+ c.m[dtype] = t
if t.Size < 0 {
// Unsized types are [0]byte
- t.Size = 0;
- t.Go = c.Opaque(0);
+ t.Size = 0
+ t.Go = c.Opaque(0)
if t.C == "" {
t.C = "void"
}
- return t;
+ return t
}
switch dt := dtype.(type) {
@@ -334,30 +334,30 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
if t.Size != c.ptrSize {
fatal("unexpected: %d-byte address type - %s", t.Size, dtype)
}
- t.Go = c.uintptr;
- t.Align = t.Size;
+ t.Go = c.uintptr
+ t.Align = t.Size
case *dwarf.ArrayType:
if dt.StrideBitSize > 0 {
// Cannot represent bit-sized elements in Go.
- t.Go = c.Opaque(t.Size);
- break;
+ t.Go = c.Opaque(t.Size)
+ break
}
gt := &ast.ArrayType{
Len: c.intExpr(dt.Count),
- };
- t.Go = gt; // publish before recursive call
- sub := c.Type(dt.Type);
- t.Align = sub.Align;
- gt.Elt = sub.Go;
- t.C = fmt.Sprintf("typeof(%s[%d])", sub.C, dt.Count);
+ }
+ t.Go = gt // publish before recursive call
+ sub := c.Type(dt.Type)
+ t.Align = sub.Align
+ gt.Elt = sub.Go
+ t.C = fmt.Sprintf("typeof(%s[%d])", sub.C, dt.Count)
case *dwarf.CharType:
if t.Size != 1 {
fatal("unexpected: %d-byte char type - %s", t.Size, dtype)
}
- t.Go = c.int8;
- t.Align = 1;
+ t.Go = c.int8
+ t.Align = 1
case *dwarf.EnumType:
switch t.Size {
@@ -375,7 +375,7 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
if t.Align = t.Size; t.Align >= c.ptrSize {
t.Align = c.ptrSize
}
- t.C = "enum " + dt.EnumName;
+ t.C = "enum " + dt.EnumName
case *dwarf.FloatType:
switch t.Size {
@@ -393,8 +393,8 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
case *dwarf.FuncType:
// No attempt at translation: would enable calls
// directly between worlds, but we need to moderate those.
- t.Go = c.uintptr;
- t.Align = c.ptrSize;
+ t.Go = c.uintptr
+ t.Align = c.ptrSize
case *dwarf.IntType:
if dt.BitSize > 0 {
@@ -417,52 +417,52 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
}
case *dwarf.PtrType:
- t.Align = c.ptrSize;
+ t.Align = c.ptrSize
// Translate void* as unsafe.Pointer
if _, ok := base(dt.Type).(*dwarf.VoidType); ok {
- t.Go = c.unsafePointer;
- t.C = "void*";
- break;
+ t.Go = c.unsafePointer
+ t.C = "void*"
+ break
}
- gt := &ast.StarExpr{};
- t.Go = gt; // publish before recursive call
- sub := c.Type(dt.Type);
- gt.X = sub.Go;
- t.C = sub.C + "*";
+ gt := &ast.StarExpr{}
+ t.Go = gt // publish before recursive call
+ sub := c.Type(dt.Type)
+ gt.X = sub.Go
+ t.C = sub.C + "*"
case *dwarf.QualType:
// Ignore qualifier.
- t = c.Type(dt.Type);
- c.m[dtype] = t;
- return t;
+ t = c.Type(dt.Type)
+ c.m[dtype] = t
+ return t
case *dwarf.StructType:
// Convert to Go struct, being careful about alignment.
// Have to give it a name to simulate C "struct foo" references.
- tag := dt.StructName;
+ tag := dt.StructName
if tag == "" {
- tag = "__" + strconv.Itoa(c.tagGen);
- c.tagGen++;
+ tag = "__" + strconv.Itoa(c.tagGen)
+ c.tagGen++
} else if t.C == "" {
t.C = dt.Kind + " " + tag
}
- name := c.Ident("_C" + dt.Kind + "_" + tag);
- t.Go = name; // publish before recursive calls
+ name := c.Ident("_C" + dt.Kind + "_" + tag)
+ t.Go = name // publish before recursive calls
switch dt.Kind {
case "union", "class":
- c.typedef[name.Value] = c.Opaque(t.Size);
+ c.typedef[name.Value] = c.Opaque(t.Size)
if t.C == "" {
t.C = fmt.Sprintf("typeof(unsigned char[%d])", t.Size)
}
case "struct":
- g, csyntax, align := c.Struct(dt);
+ g, csyntax, align := c.Struct(dt)
if t.C == "" {
t.C = csyntax
}
- t.Align = align;
- c.typedef[name.Value] = g;
+ t.Align = align
+ c.typedef[name.Value] = g
}
case *dwarf.TypedefType:
@@ -471,16 +471,16 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
// Special C name for Go string type.
// Knows string layout used by compilers: pointer plus length,
// which rounds up to 2 pointers after alignment.
- t.Go = c.string;
- t.Size = c.ptrSize * 2;
- t.Align = c.ptrSize;
- break;
- }
- name := c.Ident("_C_" + dt.Name);
- t.Go = name; // publish before recursive call
- sub := c.Type(dt.Type);
- t.Size = sub.Size;
- t.Align = sub.Align;
+ t.Go = c.string
+ t.Size = c.ptrSize * 2
+ t.Align = c.ptrSize
+ break
+ }
+ name := c.Ident("_C_" + dt.Name)
+ t.Go = name // publish before recursive call
+ sub := c.Type(dt.Type)
+ t.Size = sub.Size
+ t.Align = sub.Align
if _, ok := c.typedef[name.Value]; !ok {
c.typedef[name.Value] = sub.Go
}
@@ -489,8 +489,8 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
if t.Size != 1 {
fatal("unexpected: %d-byte uchar type - %s", t.Size, dtype)
}
- t.Go = c.uint8;
- t.Align = 1;
+ t.Go = c.uint8
+ t.Align = 1
case *dwarf.UintType:
if dt.BitSize > 0 {
@@ -513,21 +513,21 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
}
case *dwarf.VoidType:
- t.Go = c.void;
- t.C = "void";
+ t.Go = c.void
+ t.C = "void"
}
switch dtype.(type) {
case *dwarf.AddrType, *dwarf.CharType, *dwarf.IntType, *dwarf.FloatType, *dwarf.UcharType, *dwarf.UintType:
- s := dtype.Common().Name;
+ s := dtype.Common().Name
if s != "" {
if ss, ok := cnameMap[s]; ok {
s = ss
}
- s = strings.Join(strings.Split(s, " ", 0), ""); // strip spaces
- name := c.Ident("_C_" + s);
- c.typedef[name.Value] = t.Go;
- t.Go = name;
+ s = strings.Join(strings.Split(s, " ", 0), "") // strip spaces
+ name := c.Ident("_C_" + s)
+ c.typedef[name.Value] = t.Go
+ t.Go = name
}
}
@@ -535,13 +535,13 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type {
fatal("internal error: did not create C name for %s", dtype)
}
- return t;
+ return t
}
// FuncArg returns a Go type with the same memory layout as
// dtype when used as the type of a C function argument.
func (c *typeConv) FuncArg(dtype dwarf.Type) *Type {
- t := c.Type(dtype);
+ t := c.Type(dtype)
switch dt := dtype.(type) {
case *dwarf.ArrayType:
// Arrays are passed implicitly as pointers in C.
@@ -565,14 +565,14 @@ func (c *typeConv) FuncArg(dtype dwarf.Type) *Type {
}
}
}
- return t;
+ return t
}
// FuncType returns the Go type analogous to dtype.
// There is no guarantee about matching memory layout.
func (c *typeConv) FuncType(dtype *dwarf.FuncType) *FuncType {
- p := make([]*Type, len(dtype.ParamType));
- gp := make([]*ast.Field, len(dtype.ParamType));
+ p := make([]*Type, len(dtype.ParamType))
+ gp := make([]*ast.Field, len(dtype.ParamType))
for i, f := range dtype.ParamType {
// gcc's DWARF generator outputs a single DotDotDotType parameter for
// function pointers that specify no parameters (e.g. void
@@ -580,17 +580,17 @@ func (c *typeConv) FuncType(dtype *dwarf.FuncType) *FuncType {
// invalid according to ISO C anyway (i.e. void (*__cgo_1)(...) is not
// legal).
if _, ok := f.(*dwarf.DotDotDotType); ok && i == 0 {
- p, gp = nil, nil;
- break;
+ p, gp = nil, nil
+ break
}
- p[i] = c.FuncArg(f);
- gp[i] = &ast.Field{Type: p[i].Go};
+ p[i] = c.FuncArg(f)
+ gp[i] = &ast.Field{Type: p[i].Go}
}
- var r *Type;
- var gr []*ast.Field;
+ var r *Type
+ var gr []*ast.Field
if _, ok := dtype.ReturnType.(*dwarf.VoidType); !ok && dtype.ReturnType != nil {
- r = c.Type(dtype.ReturnType);
- gr = []*ast.Field{&ast.Field{Type: r.Go}};
+ r = c.Type(dtype.ReturnType)
+ gr = []*ast.Field{&ast.Field{Type: r.Go}}
}
return &FuncType{
Params: p,
@@ -599,11 +599,11 @@ func (c *typeConv) FuncType(dtype *dwarf.FuncType) *FuncType {
Params: gp,
Results: gr,
},
- };
+ }
}
// Identifier
-func (c *typeConv) Ident(s string) *ast.Ident { return &ast.Ident{Value: s} }
+func (c *typeConv) Ident(s string) *ast.Ident { return &ast.Ident{Value: s} }
// Opaque type of n bytes.
func (c *typeConv) Opaque(n int64) ast.Expr {
@@ -623,17 +623,17 @@ func (c *typeConv) intExpr(n int64) ast.Expr {
// Add padding of given size to fld.
func (c *typeConv) pad(fld []*ast.Field, size int64) []*ast.Field {
- n := len(fld);
- fld = fld[0 : n+1];
- fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident("_")}, Type: c.Opaque(size)};
- return fld;
+ n := len(fld)
+ fld = fld[0 : n+1]
+ fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident("_")}, Type: c.Opaque(size)}
+ return fld
}
// Struct conversion
func (c *typeConv) Struct(dt *dwarf.StructType) (expr *ast.StructType, csyntax string, align int64) {
- csyntax = "struct { ";
- fld := make([]*ast.Field, 0, 2*len(dt.Field)+1); // enough for padding around every field
- off := int64(0);
+ csyntax = "struct { "
+ fld := make([]*ast.Field, 0, 2*len(dt.Field)+1) // enough for padding around every field
+ off := int64(0)
// Mangle struct fields that happen to be named Go keywords into
// _{keyword}. Create a map from C ident -> Go ident. The Go ident will
@@ -641,51 +641,51 @@ func (c *typeConv) Struct(dt *dwarf.StructType) (expr *ast.StructType, csyntax s
// the C-side will cause the Go-mangled version to be prefixed with _.
// (e.g. in a struct with fields '_type' and 'type', the latter would be
// rendered as '__type' in Go).
- ident := make(map[string]string);
- used := make(map[string]bool);
+ ident := make(map[string]string)
+ used := make(map[string]bool)
for _, f := range dt.Field {
- ident[f.Name] = f.Name;
- used[f.Name] = true;
+ ident[f.Name] = f.Name
+ used[f.Name] = true
}
for cid, goid := range ident {
if token.Lookup(strings.Bytes(goid)).IsKeyword() {
// Avoid keyword
- goid = "_" + goid;
+ goid = "_" + goid
// Also avoid existing fields
for _, exist := used[goid]; exist; _, exist = used[goid] {
goid = "_" + goid
}
- used[goid] = true;
- ident[cid] = goid;
+ used[goid] = true
+ ident[cid] = goid
}
}
for _, f := range dt.Field {
if f.ByteOffset > off {
- fld = c.pad(fld, f.ByteOffset-off);
- off = f.ByteOffset;
+ fld = c.pad(fld, f.ByteOffset-off)
+ off = f.ByteOffset
}
- t := c.Type(f.Type);
- n := len(fld);
- fld = fld[0 : n+1];
+ t := c.Type(f.Type)
+ n := len(fld)
+ fld = fld[0 : n+1]
- fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[f.Name])}, Type: t.Go};
- off += t.Size;
- csyntax += t.C + " " + f.Name + "; ";
+ fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[f.Name])}, Type: t.Go}
+ off += t.Size
+ csyntax += t.C + " " + f.Name + "; "
if t.Align > align {
align = t.Align
}
}
if off < dt.ByteSize {
- fld = c.pad(fld, dt.ByteSize-off);
- off = dt.ByteSize;
+ fld = c.pad(fld, dt.ByteSize-off)
+ off = dt.ByteSize
}
if off != dt.ByteSize {
fatal("struct size calculation error")
}
- csyntax += "}";
- expr = &ast.StructType{Fields: fld};
- return;
+ csyntax += "}"
+ expr = &ast.StructType{Fields: fld}
+ return
}
diff --git a/src/cmd/cgo/main.go b/src/cmd/cgo/main.go
index 8202b8e2b..373df3ba2 100644
--- a/src/cmd/cgo/main.go
+++ b/src/cmd/cgo/main.go
@@ -11,12 +11,12 @@
package main
import (
- "fmt";
- "go/ast";
- "os";
+ "fmt"
+ "go/ast"
+ "os"
)
-func usage() { fmt.Fprint(os.Stderr, "usage: cgo [compiler options] file.go\n") }
+func usage() { fmt.Fprint(os.Stderr, "usage: cgo [compiler options] file.go\n") }
var ptrSizeMap = map[string]int64{
"386": 4,
@@ -35,29 +35,29 @@ var expandName = map[string]string{
}
func main() {
- args := os.Args;
+ args := os.Args
if len(args) < 2 {
- usage();
- os.Exit(2);
+ usage()
+ os.Exit(2)
}
- gccOptions := args[1 : len(args)-1];
- input := args[len(args)-1];
+ gccOptions := args[1 : len(args)-1]
+ input := args[len(args)-1]
- arch := os.Getenv("GOARCH");
+ arch := os.Getenv("GOARCH")
if arch == "" {
fatal("$GOARCH is not set")
}
- ptrSize, ok := ptrSizeMap[arch];
+ ptrSize, ok := ptrSizeMap[arch]
if !ok {
fatal("unknown architecture %s", arch)
}
// Clear locale variables so gcc emits English errors [sic].
- os.Setenv("LANG", "en_US.UTF-8");
- os.Setenv("LC_ALL", "C");
- os.Setenv("LC_CTYPE", "C");
+ os.Setenv("LANG", "en_US.UTF-8")
+ os.Setenv("LC_ALL", "C")
+ os.Setenv("LC_CTYPE", "C")
- p := openProg(input);
+ p := openProg(input)
for _, cref := range p.Crefs {
// Convert C.ulong to C.unsigned long, etc.
if expand, ok := expandName[cref.Name]; ok {
@@ -65,42 +65,42 @@ func main() {
}
}
- p.PtrSize = ptrSize;
- p.Preamble = p.Preamble + "\n" + builtinProlog;
- p.GccOptions = gccOptions;
- p.loadDebugInfo();
- p.Vardef = make(map[string]*Type);
- p.Funcdef = make(map[string]*FuncType);
+ p.PtrSize = ptrSize
+ p.Preamble = p.Preamble + "\n" + builtinProlog
+ p.GccOptions = gccOptions
+ p.loadDebugInfo()
+ p.Vardef = make(map[string]*Type)
+ p.Funcdef = make(map[string]*FuncType)
for _, cref := range p.Crefs {
switch cref.Context {
case "call":
if !cref.TypeName {
// Is an actual function call.
- *cref.Expr = &ast.Ident{Value: "_C_" + cref.Name};
- p.Funcdef[cref.Name] = cref.FuncType;
- break;
+ *cref.Expr = &ast.Ident{Value: "_C_" + cref.Name}
+ p.Funcdef[cref.Name] = cref.FuncType
+ break
}
- *cref.Expr = cref.Type.Go;
+ *cref.Expr = cref.Type.Go
case "expr":
if cref.TypeName {
error((*cref.Expr).Pos(), "type C.%s used as expression", cref.Name)
}
// Reference to C variable.
// We declare a pointer and arrange to have it filled in.
- *cref.Expr = &ast.StarExpr{X: &ast.Ident{Value: "_C_" + cref.Name}};
- p.Vardef[cref.Name] = cref.Type;
+ *cref.Expr = &ast.StarExpr{X: &ast.Ident{Value: "_C_" + cref.Name}}
+ p.Vardef[cref.Name] = cref.Type
case "type":
if !cref.TypeName {
error((*cref.Expr).Pos(), "expression C.%s used as type", cref.Name)
}
- *cref.Expr = cref.Type.Go;
+ *cref.Expr = cref.Type.Go
}
}
if nerrors > 0 {
os.Exit(2)
}
- p.PackagePath = os.Getenv("CGOPKGPATH") + "/" + p.Package;
- p.writeOutput(input);
+ p.PackagePath = os.Getenv("CGOPKGPATH") + "/" + p.Package
+ p.writeOutput(input)
}
diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 297ffe40a..9c85bc598 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -5,78 +5,78 @@
package main
import (
- "fmt";
- "go/ast";
- "go/printer";
- "os";
- "strings";
+ "fmt"
+ "go/ast"
+ "go/printer"
+ "os"
+ "strings"
)
func creat(name string) *os.File {
- f, err := os.Open(name, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, 0666);
+ f, err := os.Open(name, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, 0666)
if err != nil {
fatal("%s", err)
}
- return f;
+ return f
}
// writeOutput creates output files to be compiled by 6g, 6c, and gcc.
// (The comments here say 6g and 6c but the code applies to the 8 and 5 tools too.)
func (p *Prog) writeOutput(srcfile string) {
- pkgroot := os.Getenv("GOROOT") + "/pkg/" + os.Getenv("GOOS") + "_" + os.Getenv("GOARCH");
+ pkgroot := os.Getenv("GOROOT") + "/pkg/" + os.Getenv("GOOS") + "_" + os.Getenv("GOARCH")
- base := srcfile;
+ base := srcfile
if strings.HasSuffix(base, ".go") {
base = base[0 : len(base)-3]
}
- fgo1 := creat(base + ".cgo1.go");
- fgo2 := creat(base + ".cgo2.go");
- fc := creat(base + ".cgo3.c");
- fgcc := creat(base + ".cgo4.c");
+ fgo1 := creat(base + ".cgo1.go")
+ fgo2 := creat(base + ".cgo2.go")
+ fc := creat(base + ".cgo3.c")
+ fgcc := creat(base + ".cgo4.c")
// Write Go output: Go input with rewrites of C.xxx to _C_xxx.
- fmt.Fprintf(fgo1, "// Created by cgo - DO NOT EDIT\n");
- fmt.Fprintf(fgo1, "//line %s:1\n", srcfile);
- printer.Fprint(fgo1, p.AST);
+ fmt.Fprintf(fgo1, "// Created by cgo - DO NOT EDIT\n")
+ fmt.Fprintf(fgo1, "//line %s:1\n", srcfile)
+ printer.Fprint(fgo1, p.AST)
// Write second Go output: definitions of _C_xxx.
// In a separate file so that the import of "unsafe" does not
// pollute the original file.
- fmt.Fprintf(fgo2, "// Created by cgo - DO NOT EDIT\n");
- fmt.Fprintf(fgo2, "package %s\n\n", p.Package);
- fmt.Fprintf(fgo2, "import \"unsafe\"\n\n");
- fmt.Fprintf(fgo2, "type _ unsafe.Pointer\n\n");
+ fmt.Fprintf(fgo2, "// Created by cgo - DO NOT EDIT\n")
+ fmt.Fprintf(fgo2, "package %s\n\n", p.Package)
+ fmt.Fprintf(fgo2, "import \"unsafe\"\n\n")
+ fmt.Fprintf(fgo2, "type _ unsafe.Pointer\n\n")
for name, def := range p.Typedef {
- fmt.Fprintf(fgo2, "type %s ", name);
- printer.Fprint(fgo2, def);
- fmt.Fprintf(fgo2, "\n");
+ fmt.Fprintf(fgo2, "type %s ", name)
+ printer.Fprint(fgo2, def)
+ fmt.Fprintf(fgo2, "\n")
}
- fmt.Fprintf(fgo2, "type _C_void [0]byte\n");
+ fmt.Fprintf(fgo2, "type _C_void [0]byte\n")
// While we process the vars and funcs, also write 6c and gcc output.
// Gcc output starts with the preamble.
- fmt.Fprintf(fgcc, "%s\n", p.Preamble);
- fmt.Fprintf(fgcc, "%s\n", gccProlog);
+ fmt.Fprintf(fgcc, "%s\n", p.Preamble)
+ fmt.Fprintf(fgcc, "%s\n", gccProlog)
- fmt.Fprintf(fc, cProlog, pkgroot, pkgroot, pkgroot, pkgroot, p.Package, p.Package);
+ fmt.Fprintf(fc, cProlog, pkgroot, pkgroot, pkgroot, pkgroot, p.Package, p.Package)
for name, def := range p.Vardef {
- fmt.Fprintf(fc, "#pragma dynld %s·_C_%s %s \"%s/%s_%s.so\"\n", p.Package, name, name, pkgroot, p.PackagePath, base);
- fmt.Fprintf(fgo2, "var _C_%s ", name);
- printer.Fprint(fgo2, &ast.StarExpr{X: def.Go});
- fmt.Fprintf(fgo2, "\n");
+ fmt.Fprintf(fc, "#pragma dynld %s·_C_%s %s \"%s/%s_%s.so\"\n", p.Package, name, name, pkgroot, p.PackagePath, base)
+ fmt.Fprintf(fgo2, "var _C_%s ", name)
+ printer.Fprint(fgo2, &ast.StarExpr{X: def.Go})
+ fmt.Fprintf(fgo2, "\n")
}
- fmt.Fprintf(fc, "\n");
+ fmt.Fprintf(fc, "\n")
for name, def := range p.Funcdef {
// Go func declaration.
d := &ast.FuncDecl{
Name: &ast.Ident{Value: "_C_" + name},
Type: def.Go,
- };
- printer.Fprint(fgo2, d);
- fmt.Fprintf(fgo2, "\n");
+ }
+ printer.Fprint(fgo2, d)
+ fmt.Fprintf(fgo2, "\n")
if name == "CString" || name == "GoString" {
// The builtins are already defined in the C prolog.
@@ -88,86 +88,86 @@ func (p *Prog) writeOutput(srcfile string) {
// These assumptions are checked by the gccProlog.
// Also assumes that 6c convention is to word-align the
// input and output parameters.
- structType := "struct {\n";
- off := int64(0);
- npad := 0;
+ structType := "struct {\n"
+ off := int64(0)
+ npad := 0
for i, t := range def.Params {
if off%t.Align != 0 {
- pad := t.Align - off%t.Align;
- structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad);
- off += pad;
- npad++;
+ pad := t.Align - off%t.Align
+ structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
+ off += pad
+ npad++
}
- structType += fmt.Sprintf("\t\t%s p%d;\n", t.C, i);
- off += t.Size;
+ structType += fmt.Sprintf("\t\t%s p%d;\n", t.C, i)
+ off += t.Size
}
if off%p.PtrSize != 0 {
- pad := p.PtrSize - off%p.PtrSize;
- structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad);
- off += pad;
- npad++;
+ pad := p.PtrSize - off%p.PtrSize
+ structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
+ off += pad
+ npad++
}
if t := def.Result; t != nil {
if off%t.Align != 0 {
- pad := t.Align - off%t.Align;
- structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad);
- off += pad;
- npad++;
+ pad := t.Align - off%t.Align
+ structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
+ off += pad
+ npad++
}
- structType += fmt.Sprintf("\t\t%s r;\n", t.C);
- off += t.Size;
+ structType += fmt.Sprintf("\t\t%s r;\n", t.C)
+ off += t.Size
}
if off%p.PtrSize != 0 {
- pad := p.PtrSize - off%p.PtrSize;
- structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad);
- off += pad;
- npad++;
+ pad := p.PtrSize - off%p.PtrSize
+ structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
+ off += pad
+ npad++
}
if len(def.Params) == 0 && def.Result == nil {
- structType += "\t\tchar unused;\n"; // avoid empty struct
- off++;
+ structType += "\t\tchar unused;\n" // avoid empty struct
+ off++
}
- structType += "\t}";
- argSize := off;
+ structType += "\t}"
+ argSize := off
// C wrapper calls into gcc, passing a pointer to the argument frame.
// Also emit #pragma to get a pointer to the gcc wrapper.
- fmt.Fprintf(fc, "#pragma dynld _cgo_%s _cgo_%s \"%s/%s_%s.so\"\n", name, name, pkgroot, p.PackagePath, base);
- fmt.Fprintf(fc, "void (*_cgo_%s)(void*);\n", name);
- fmt.Fprintf(fc, "\n");
- fmt.Fprintf(fc, "void\n");
- fmt.Fprintf(fc, "%s·_C_%s(struct{uint8 x[%d];}p)\n", p.Package, name, argSize);
- fmt.Fprintf(fc, "{\n");
- fmt.Fprintf(fc, "\tcgocall(_cgo_%s, &p);\n", name);
- fmt.Fprintf(fc, "}\n");
- fmt.Fprintf(fc, "\n");
+ fmt.Fprintf(fc, "#pragma dynld _cgo_%s _cgo_%s \"%s/%s_%s.so\"\n", name, name, pkgroot, p.PackagePath, base)
+ fmt.Fprintf(fc, "void (*_cgo_%s)(void*);\n", name)
+ fmt.Fprintf(fc, "\n")
+ fmt.Fprintf(fc, "void\n")
+ fmt.Fprintf(fc, "%s·_C_%s(struct{uint8 x[%d];}p)\n", p.Package, name, argSize)
+ fmt.Fprintf(fc, "{\n")
+ fmt.Fprintf(fc, "\tcgocall(_cgo_%s, &p);\n", name)
+ fmt.Fprintf(fc, "}\n")
+ fmt.Fprintf(fc, "\n")
// Gcc wrapper unpacks the C argument struct
// and calls the actual C function.
- fmt.Fprintf(fgcc, "void\n");
- fmt.Fprintf(fgcc, "_cgo_%s(void *v)\n", name);
- fmt.Fprintf(fgcc, "{\n");
- fmt.Fprintf(fgcc, "\t%s *a = v;\n", structType);
- fmt.Fprintf(fgcc, "\t");
+ fmt.Fprintf(fgcc, "void\n")
+ fmt.Fprintf(fgcc, "_cgo_%s(void *v)\n", name)
+ fmt.Fprintf(fgcc, "{\n")
+ fmt.Fprintf(fgcc, "\t%s *a = v;\n", structType)
+ fmt.Fprintf(fgcc, "\t")
if def.Result != nil {
fmt.Fprintf(fgcc, "a->r = ")
}
- fmt.Fprintf(fgcc, "%s(", name);
+ fmt.Fprintf(fgcc, "%s(", name)
for i := range def.Params {
if i > 0 {
fmt.Fprintf(fgcc, ", ")
}
- fmt.Fprintf(fgcc, "a->p%d", i);
+ fmt.Fprintf(fgcc, "a->p%d", i)
}
- fmt.Fprintf(fgcc, ");\n");
- fmt.Fprintf(fgcc, "}\n");
- fmt.Fprintf(fgcc, "\n");
+ fmt.Fprintf(fgcc, ");\n")
+ fmt.Fprintf(fgcc, "}\n")
+ fmt.Fprintf(fgcc, "\n")
}
- fgo1.Close();
- fgo2.Close();
- fc.Close();
- fgcc.Close();
+ fgo1.Close()
+ fgo2.Close()
+ fc.Close()
+ fgcc.Close()
}
const gccProlog = `
diff --git a/src/cmd/cgo/util.go b/src/cmd/cgo/util.go
index 176e9528e..782efddf4 100644
--- a/src/cmd/cgo/util.go
+++ b/src/cmd/cgo/util.go
@@ -5,11 +5,11 @@
package main
import (
- "exec";
- "fmt";
- "go/token";
- "io/ioutil";
- "os";
+ "exec"
+ "fmt"
+ "go/token"
+ "io/ioutil"
+ "os"
)
// A ByteReaderAt implements io.ReadAt using a slice of bytes.
@@ -19,76 +19,76 @@ func (r ByteReaderAt) ReadAt(p []byte, off int64) (n int, err os.Error) {
if off >= int64(len(r)) || off < 0 {
return 0, os.EOF
}
- return copy(p, r[off:]), nil;
+ return copy(p, r[off:]), nil
}
// run runs the command argv, feeding in stdin on standard input.
// It returns the output to standard output and standard error.
// ok indicates whether the command exited successfully.
func run(stdin []byte, argv []string) (stdout, stderr []byte, ok bool) {
- cmd, err := exec.LookPath(argv[0]);
+ cmd, err := exec.LookPath(argv[0])
if err != nil {
fatal("exec %s: %s", argv[0], err)
}
- r0, w0, err := os.Pipe();
+ r0, w0, err := os.Pipe()
if err != nil {
fatal("%s", err)
}
- r1, w1, err := os.Pipe();
+ r1, w1, err := os.Pipe()
if err != nil {
fatal("%s", err)
}
- r2, w2, err := os.Pipe();
+ r2, w2, err := os.Pipe()
if err != nil {
fatal("%s", err)
}
- pid, err := os.ForkExec(cmd, argv, os.Environ(), "", []*os.File{r0, w1, w2});
+ pid, err := os.ForkExec(cmd, argv, os.Environ(), "", []*os.File{r0, w1, w2})
if err != nil {
fatal("%s", err)
}
- r0.Close();
- w1.Close();
- w2.Close();
- c := make(chan bool);
+ r0.Close()
+ w1.Close()
+ w2.Close()
+ c := make(chan bool)
go func() {
- w0.Write(stdin);
- w0.Close();
- c <- true;
- }();
- var xstdout []byte; // TODO(rsc): delete after 6g can take address of out parameter
+ w0.Write(stdin)
+ w0.Close()
+ c <- true
+ }()
+ var xstdout []byte // TODO(rsc): delete after 6g can take address of out parameter
go func() {
- xstdout, _ = ioutil.ReadAll(r1);
- r1.Close();
- c <- true;
- }();
- stderr, _ = ioutil.ReadAll(r2);
- r2.Close();
- <-c;
- <-c;
- stdout = xstdout;
+ xstdout, _ = ioutil.ReadAll(r1)
+ r1.Close()
+ c <- true
+ }()
+ stderr, _ = ioutil.ReadAll(r2)
+ r2.Close()
+ <-c
+ <-c
+ stdout = xstdout
- w, err := os.Wait(pid, 0);
+ w, err := os.Wait(pid, 0)
if err != nil {
fatal("%s", err)
}
- ok = w.Exited() && w.ExitStatus() == 0;
- return;
+ ok = w.Exited() && w.ExitStatus() == 0
+ return
}
// Die with an error message.
func fatal(msg string, args ...) {
- fmt.Fprintf(os.Stderr, msg+"\n", args);
- os.Exit(2);
+ fmt.Fprintf(os.Stderr, msg+"\n", args)
+ os.Exit(2)
}
var nerrors int
var noPos token.Position
func error(pos token.Position, msg string, args ...) {
- nerrors++;
+ nerrors++
if pos.IsValid() {
fmt.Fprintf(os.Stderr, "%s: ", pos)
}
- fmt.Fprintf(os.Stderr, msg, args);
- fmt.Fprintf(os.Stderr, "\n");
+ fmt.Fprintf(os.Stderr, msg, args)
+ fmt.Fprintf(os.Stderr, "\n")
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-30 05:14:49 +0000