Add Go build support for GN.

build/go/go.py

Index: build/go/go.py
diff --git a/build/go/go.py b/build/go/go.py
new file mode 100755
index 0000000000000000000000000000000000000000..c2986fe1bdadc8e5f7eb15b977ef4d5ddffc66a3
--- /dev/null
+++ b/build/go/go.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+This script invokes the go build tool.
+Must be called as follows:
+python go.py <go-binary> <build directory> <output file> <src directory>
+<CGO_CFLAGS> <CGO_LDFLAGS> <go-binary options>
+eg.
+python go.py /usr/lib/google-golang/bin/go out/build out/a.out .. "-I."
+"-L. -ltest" test -c test/test.go
+"""
+
+import os
+import shutil
+import string
+import sys
+
+def main():
+  args = sys.argv
+  go_binary = args[1]

[qsr, 2014/09/15 09:54:24]

You can use argpath. That would make it clearer what you are expected, and you
will gain a --help for free.

[tburkard, 2014/09/16 12:29:13]

You mean argparse? I was trying to do that, however, the python script then has
to have knowledge of all the possible go args that may be passed in. I thought
that might not be desirable, and to just specify a set of fixed args needed by
the python script, and relay everything else to the go binary?

But I am open to other suggestions. What do you think?

[qsr, 2014/09/18 08:30:38]

I'm not sure to understand, you can do something like this:

parser.add_argument('a1')
parser.add_argument('a2')
parser.add_argument('a3')
parser.add_argument('remaining', nargs='*')

 Which would name your 3 first argument on the command line, and let you get all
the following ones in remaining.

[tburkard, 2014/09/18 14:23:42]

Yup, I tried doing that, however, if 'remaining' contains leading dash(es),
there will be an error. So I could use argparse, but I would have to hard code
in the semantics of all flags passed to go, which is what I wanted to avoid.
Would you prefer doing that?

[qsr, 2014/09/18 14:30:55]

 You can use -- to tell argparse all arguments is positional. So you will use
you go.py like this:
go.py --my_arg1=1 --my_arg2=1 -- --my-arg3 --my-arg4

[tburkard, 2014/09/18 15:20:09]

Done.

+  build_dir = args[2]
+  out_file = os.path.abspath(args[3])
+  # The src directory specified is relative. We will later need this as an
+  # absolute path.
+  src_root = os.path.abspath(args[4]) + "/"
+  # GOPATH must be absolute, and point to one directory up from |src_Root|
+  go_path = os.path.abspath(src_root + "..")

[qsr, 2014/09/15 09:54:24]

Instead of using concatenation, and so needing to / or not, use os.path.join

[tburkard, 2014/09/18 15:20:09]

Done.

+  # CGO_CFLAGS and CGO_LDFLAGS contain a paths relative to |src_root|
+  # We need to make these absolute paths by prepending the (absolute) |src_root|
+  cgo_cflags = string.replace(" " + args[5], " -I", " -I" + src_root)[1:]

[qsr, 2014/09/15 09:54:24]

If you expect this to be a list of -Ifoo -Ibar, just take foo and bar, and build
the thing yourself. Same for -L

[tburkard, 2014/09/16 12:29:13]

Well, one issue is that Go works more consistently with absolute paths. So I'd
still need to fix up the paths. But you are suggesting to provide this as a list
of items relative to the src, and then use that to come up with the right -I?
Again, one motivation why I started this way is so that the script does not have
to know about potential other args that may be needed, but they will just be
passed through.

Thoughts? I am open to changing it based on your suggestion.
So you are suggesting (in conjunction with the change above), something like
--cgo_cflag_i=foo --cgo_cflag_i=bar, and in the python script, to translate that
into -I/path/to/src/foo -I/path/to/src/bar?

[qsr, 2014/09/18 08:30:38]

 Hum, ok I see. Then should this script hardcode the -I and -L it needs to add.
You could pass the output_dir to the script, and hardcode -I{src_dir}
-L{output_dir}

 Then you can just have 2 optional arguments go_clfags and go_dflags and
construct the final cflags and dflags from those.

[tburkard, 2014/09/18 14:23:41]

.. but there's a bit more to it than just the output_dir: First, lib's/so's
could be in different subdirectories of an output directory. So it'd have to be
a list.
Second, I also need to pass in the -l libs. So in the end, it would look pretty
similar to what I already have? Does this sound reasonable?

[qsr, 2014/09/18 14:30:55]

 That I do not understand, your libs should all be in OUTPUT_DIR/lib on linux.
Where else do you expect to get libraries?
 Those would be there yes, as the remaining arguments. But those do not contain
path, so you should just pass back what has been given to you, and you will not
need to change this to add absolute paths.

[tburkard, 2014/09/18 15:20:09]

Ah, yes, that makes sense.
So I'd have a positional argument indicating the (single) path. And I'd fix that
up. The -l ones will be pased in the remaining options. Does this sound
reasonable?

In the general case though, couldn't libs come from multiple places? Eg what if
there is the gyp out, and the gn out, wouldn't libs be in separate direcotires?

Maybe Brett can chime in on this before i make the change.

Thanks.

+  cgo_ldflags = string.replace(" " + args[6], " -L", " -L" + src_root)[1:]
+  go_options = args[7:]
+  try:
+    shutil.rmtree(build_dir, True)
+    os.mkdir(build_dir)
+  except:
+    pass
+  old_directory = os.getcwd()
+  os.chdir(build_dir)

[qsr, 2014/09/15 09:54:23]

Do you really need to chdir, doesn't the go compiler allows you to specify an
output directory?

[tburkard, 2014/09/16 12:29:13]

Go does support it for binaries, but not for test binaries! I double checked it
with Russ Cox, and specifying a target is not supported at this time. This was
the only way I could get it to work.

+  os.environ["GOPATH"] = go_path
+  os.environ["CGO_CFLAGS"] = cgo_cflags
+  os.environ["CGO_LDFLAGS"] = cgo_ldflags
+  os.system("%s %s" % (go_binary, " ".join(go_options)))
+  out_files = [ f for f in os.listdir(".") if os.path.isfile(f)]
+  if (len(out_files) > 0):
+    shutil.move(out_files[0], out_file)
+  os.chdir(old_directory)
+  try:
+    shutil.rmtree(build_dir, True)
+  except:
+    pass
+
+if __name__ == '__main__':
+  sys.exit(main())