code review 3733046: new cgo windows port.

src/cmd/cgo/out.go

 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package main
 
 import (
         "bytes"
         "debug/elf"
         "debug/macho"
@@ skipping 17 matching lines @@
                 // OS X requires its own prefix for a relative path
                 soprefix = "@rpath/"
         }
 
         fgo2 := creat("_cgo_gotypes.go")
         fc := creat("_cgo_defun.c")
         fm := creat("_cgo_main.c")
 
         // Write C main file for using gcc to resolve imports.
         fmt.Fprintf(fm, "int main() { return 0; }\n")
-        fmt.Fprintf(fm, "int crosscall2;\n\n")
+        fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*, int), void *a, int c) { }\n")
+        fmt.Fprintf(fm, "void _cgo_allocate(void *a, int c) { }\n")
+        fmt.Fprintf(fm, "void _cgo_panic(void *a, int c) { }\n")
 
         // 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\n")
         fmt.Fprintf(fgo2, "package %s\n\n", p.PackageName)
         fmt.Fprintf(fgo2, "import \"unsafe\"\n\n")
         fmt.Fprintf(fgo2, "import \"os\"\n\n")
         fmt.Fprintf(fgo2, "import _ \"runtime/cgo\"\n\n")
         fmt.Fprintf(fgo2, "type _ unsafe.Pointer\n\n")
@@ skipping 127 matching lines @@
                 off += pad
         }
         if n.AddError {
                 fmt.Fprint(&buf, "\t\tvoid *e[2]; /* os.Error */\n")
                 off += 2 * p.PtrSize
         }
         if off == 0 {
                 fmt.Fprintf(&buf, "\t\tchar unused;\n") // avoid empty struct
                 off++
         }
-        fmt.Fprintf(&buf, "\t}\n")
+        fmt.Fprintf(&buf, "\t}")
         return buf.String(), off
 }
 
 func (p *Package) writeDefsFunc(fc, fgo2 *os.File, n *Name, soprefix, sopath string) {
         name := n.Go
         gtype := n.FuncType.Go
         if n.AddError {
                 // Add "os.Error" to return type list.
                 // Type list is known to be 0 or 1 element - it's a C function.
                 err := &ast.Field{Type: ast.NewIdent("os.Error")}
@@ skipping 405 matching lines @@
                 }
                 if t.Name == "string" {
                         return &Type{Size: p.PtrSize + 4, Align: p.PtrSize, C: "GoString"}
                 }
                 if r, ok := goTypes[t.Name]; ok {
                         if r.Align > p.PtrSize {
                                 r.Align = p.PtrSize
                         }
                         return r
                 }
+        case *ast.SelectorExpr:
+                id, ok := t.X.(*ast.Ident)
+                if ok && id.Name == "unsafe" && t.Sel.Name == "Pointer" {
+                        return &Type{Size: p.PtrSize, Align: p.PtrSize, C: "void*"}
+                }
         }
         error(e.Pos(), "unrecognized Go type %T", e)
         return &Type{Size: 4, Align: 4, C: "int"}
 }
 
 const gccProlog = `
 // Usual nonsense: if x and y are not equal, the type will be invalid
 // (have a negative array count) and an inscrutable error will come
 // out of the compiler and hopefully mention "name".
 #define __cgo_compile_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2+1];
@@ skipping 57 matching lines @@
 typedef unsigned short ushort;
 typedef long long int64;
 typedef unsigned long long uint64;
 typedef __SIZE_TYPE__ uintptr;
 
 typedef struct { char *p; int n; } GoString;
 typedef void *GoMap;
 typedef void *GoChan;
 typedef struct { void *t; void *v; } GoInterface;
 `