code review 3921043: cgo: CGO_CFLAGS and CGO_LDFLAGS support

src/cmd/cgo/gcc.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.
 
 // Annotate Ref in Prog with C types by parsing gcc debug output.
 // Conversion of debug output to Go types.
 
 package main
 
 import (
@@ skipping 10 matching lines @@
         "os"
         "strconv"
         "strings"
         "unicode"
 )
 
 var debugDefine = flag.Bool("debug-define", false, "print relevant #defines")
 var debugGcc = flag.Bool("debug-gcc", false, "print gcc invocations")
 
 var nameToC = map[string]string{
-        "schar":     "signed char",
-        "uchar":     "unsigned char",
-        "ushort":    "unsigned short",
-        "uint":      "unsigned int",
-        "ulong":     "unsigned long",
-        "longlong":  "long long",
-        "ulonglong": "unsigned long long",
+        "schar":         "signed char",
+        "uchar":         "unsigned char",
+        "ushort":        "unsigned short",
+        "uint":          "unsigned int",
+        "ulong":         "unsigned long",
+        "longlong":      "long long",
+        "ulonglong":     "unsigned long long",
+        "complexfloat":  "float complex",
+        "complexdouble": "double complex",
 }
 
 // cname returns the C name to use for C.s.
 // The expansions are listed in nameToC and also
 // struct_foo becomes "struct foo", and similarly for
 // union and enum.
 func cname(s string) string {
         if t, ok := nameToC[s]; ok {
                 return t
         }
@@ skipping 27 matching lines @@
                 fields := strings.Split(l, ":", 2)
                 if len(fields) != 2 {
                         fatal("%s: bad #cgo line: %s", srcfile, line)
                 }
 
                 k := fields[0]
                 v := strings.TrimSpace(fields[1])
                 if k != "CFLAGS" && k != "LDFLAGS" {
                         fatal("%s: unsupported #cgo option %s", srcfile, k)
                 }
+                args, err := splitQuoted(v)
+                if err != nil {
+                        fatal("%s: bad #cgo option %s: %s", srcfile, k, err.String())
+                }
                 if oldv, ok := p.CgoFlags[k]; ok {
                         p.CgoFlags[k] = oldv + " " + v
                 } else {
                         p.CgoFlags[k] = v
                 }
                 if k == "CFLAGS" {
-                        p.GccOptions = append(p.GccOptions, splitArgs(v)...)
+                        p.GccOptions = append(p.GccOptions, args...)
                 }
         }
         f.Preamble = strings.Join(linesOut, "\n")
 }
 
-// splitArgs returns the string splitted in the same way
-// a shell splits arguments in the command line.
+// splitQuoted splits the string s around each instance of one or more consecutive
+// white space characters while taking into account quotes and escaping, and
+// returns an array of substrings of s or an empty list if s contains only white space.
+// Single quotes and double quotes are recognized to prevent splitting within the
+// quoted region, and are removed from the resulting substrings. If a quote in s
+// isn't closed err will be set and r will have the unclosed argument as the
+// last element.  The backslash is used for escaping.
 //
-// TODO(niemeyer): This looks like a handy function to have
-// available, and should probably be moved into the stdlib.
-func splitArgs(s string) []string {
-        args := make([]string, 0, len(s))
+// For example, the following string:
+//
+//     `a b:"c d" 'e''f'  "g\""`
+//
+// Would be parsed as:
+//
+//     []string{"a", "b:c d", "ef", `g"`}
+//
+func splitQuoted(s string) (r []string, err os.Error) {
+        var args []string
         arg := make([]int, len(s))
         escaped := false
+        quoted := false
         quote := 0
         i := 0
         for _, rune := range s {
                 switch {
                 case escaped:
                         escaped = false
-                case rune == int('\\'):
+                case rune == '\\':
                         escaped = true
                         continue
                 case quote != 0:
                         if rune == quote {
                                 quote = 0
                                 continue
                         }
-                case rune == int('"') || rune == int('\''):
+                case rune == '"' || rune == '\'':
+                        quoted = true
                         quote = rune
                         continue
                 case unicode.IsSpace(rune):
-                        if i > 0 {
+                        if quoted || i > 0 {
+                                quoted = false
                                 args = append(args, string(arg[:i]))
                                 i = 0
                         }
                         continue
                 }
                 arg[i] = rune
                 i++
         }
-        if i > 0 {
+        if quoted || i > 0 {
                 args = append(args, string(arg[:i]))
         }
-        return args
+        if quote != 0 {
+                err = os.ErrorString("unclosed quote")
+        } else if escaped {
+                err = os.ErrorString("unfinished escaping")
+        }
+        return args, err
 }
 
 // Translate rewrites f.AST, the original Go input, to remove
 // references to the imported package C, replacing them with
 // references to the equivalent Go types, functions, and variables.
 func (p *Package) Translate(f *File) {
         for _, cref := range f.Ref {
                 // Convert C.ulong to C.unsigned long, etc.
                 cref.Name.C = cname(cref.Name.Go)
         }
@@ skipping 130 matching lines @@
         names := make([]*Name, len(toSniff))
         copy(names, toSniff)
 
         isConst := make([]bool, len(toSniff))
         for i := range isConst {
                 isConst[i] = true // until proven otherwise
         }
 
         for _, line := range strings.Split(stderr, "\n", -1) {
                 if len(line) < 9 || line[0:9] != "cgo-test:" {
-                        if len(line) > 8 && line[0:8] == "<stdin>:" {
-                                fatal("gcc produced unexpected output:\n%s\non input:\n%s", line, b.Bytes())
-                        }
+                        // the user will see any compiler errors when the code is compiled later.
                         continue
                 }
                 line = line[9:]
                 colon := strings.Index(line, ":")
                 if colon < 0 {
                         continue
                 }
                 i, err := strconv.Atoi(line[0:colon])
                 if err != nil {
                         continue
@@ skipping 340 matching lines @@
                 fmt.Fprintf(os.Stderr, "$ %s <<EOF\n", strings.Join(args, " "))
                 os.Stderr.Write(stdin)
                 fmt.Fprint(os.Stderr, "EOF\n")
         }
         stdout, stderr, ok := run(stdin, args)
         if *debugGcc {
                 os.Stderr.Write(stdout)
                 os.Stderr.Write(stderr)
         }
         if !ok {
-                fmt.Fprint(os.Stderr, "Error running gcc:\n")
-                fmt.Fprintf(os.Stderr, "$ %s <<EOF\n", strings.Join(args, " "))
-                os.Stderr.Write(stdin)
-                fmt.Fprint(os.Stderr, "EOF\n")
                 os.Stderr.Write(stderr)
                 os.Exit(2)
         }
         return string(stdout), string(stderr)
 }
 
 // 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
 
         // Predeclared types.
         bool                                   ast.Expr
         byte                                   ast.Expr // denotes padding
         int8, int16, int32, int64              ast.Expr
         uint8, uint16, uint32, uint64, uintptr ast.Expr
         float32, float64                       ast.Expr
+        complex64, complex128                  ast.Expr
         void                                   ast.Expr
         unsafePointer                          ast.Expr
         string                                 ast.Expr
 
         ptrSize int64
 }
 
 var tagGen int
 var typedef = make(map[string]ast.Expr)
 
 func (c *typeConv) Init(ptrSize int64) {
         c.ptrSize = ptrSize
         c.m = make(map[dwarf.Type]*Type)
         c.bool = c.Ident("bool")
         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.complex64 = c.Ident("complex64")
+        c.complex128 = c.Ident("complex128")
         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
@@ skipping 11 matching lines @@
 // Map from dwarf text names to aliases we use in package "C".
 var dwarfToName = map[string]string{
         "long int":               "long",
         "long unsigned int":      "ulong",
         "unsigned int":           "uint",
         "short unsigned int":     "ushort",
         "short int":              "short",
         "long long int":          "longlong",
         "long long unsigned int": "ulonglong",
         "signed char":            "schar",
+        "float complex":          "complexfloat",
+        "double complex":         "complexdouble",
 }
 
 // Type returns a *Type with the same memory layout as
 // dtype when used as the type of a variable or a struct field.
 func (c *typeConv) Type(dtype dwarf.Type) *Type {
         if t, ok := c.m[dtype]; ok {
                 if t.Go == nil {
                         fatal("type conversion loop at %s", dtype)
                 }
                 return t
@@ skipping 76 matching lines @@
                 }
 
         case *dwarf.FloatType:
                 switch t.Size {
                 default:
                         fatal("unexpected: %d-byte float type - %s", t.Size, dtype)
                 case 4:
                         t.Go = c.float32
                 case 8:
                         t.Go = c.float64
+                }
+                if t.Align = t.Size; t.Align >= c.ptrSize {
+                        t.Align = c.ptrSize
+                }
+
+        case *dwarf.ComplexType:
+                switch t.Size {
+                default:
+                        fatal("unexpected: %d-byte complex type - %s", t.Size, dtype)
+                case 8:
+                        t.Go = c.complex64
+                case 16:
+                        t.Go = c.complex128
                 }
                 if t.Align = t.Size; t.Align >= c.ptrSize {
                         t.Align = c.ptrSize
                 }
 
         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
@@ skipping 294 matching lines @@
                 off = dt.ByteSize
         }
         if off != dt.ByteSize {
                 fatal("struct size calculation error")
         }
         buf.WriteString("}")
         csyntax = buf.String()
         expr = &ast.StructType{Fields: &ast.FieldList{List: fld}}
         return
 }