cmd/wuffs/gen.go - third_party/wuffs - Git at Google

 // Copyright 2017 The Wuffs Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package main

 import (
 	"bytes"
 	"flag"
 	"fmt"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
 	"strings"

 	"github.com/google/wuffs/lang/generate"
 	"github.com/google/wuffs/lang/parse"

 	cf "github.com/google/wuffs/cmd/commonflags"

 	a "github.com/google/wuffs/lang/ast"
 	t "github.com/google/wuffs/lang/token"
 )

 func doGen(wuffsRoot string, args []string) error    { return doGenGenlib(wuffsRoot, args, false) }
 func doGenlib(wuffsRoot string, args []string) error { return doGenGenlib(wuffsRoot, args, true) }

 func doGenGenlib(wuffsRoot string, args []string, genlib bool) error {
 	flags := flag.NewFlagSet("gen", flag.ExitOnError)
 	cformatterFlag := flags.String("cformatter", cf.CformatterDefault, cf.CformatterUsage)
 	genlinenumFlag := flags.Bool("genlinenum", cf.GenlinenumDefault, cf.GenlinenumUsage)
 	langsFlag := flags.String("langs", langsDefault, langsUsage)
 	skipgendepsFlag := flags.Bool("skipgendeps", skipgendepsDefault, skipgendepsUsage)

 	skipgenFlag := (*bool)(nil)
 	if genlib {
 		skipgenFlag = flags.Bool("skipgen", skipgenDefault, skipgenUsage)
 	}
 	versionFlag := (*string)(nil)
 	if !genlib {
 		versionFlag = flags.String("version", cf.VersionDefault, cf.VersionUsage)
 	}

 	if err := flags.Parse(args); err != nil {
 		return err
 	}
 	if !cf.IsAlphaNumericIsh(*cformatterFlag) {
 		return fmt.Errorf("bad -cformatter flag value %q", *cformatterFlag)
 	}
 	langs, err := parseLangs(*langsFlag)
 	if err != nil {
 		return err
 	}
 	v := cf.Version{}
 	if !genlib {
 		ok := false
 		v, ok = cf.ParseVersion(*versionFlag)
 		if !ok {
 			return fmt.Errorf("bad -version flag value %q", *versionFlag)
 		}
 	}
 	args = flags.Args()
 	if len(args) == 0 {
 		args = []string{"base", "std/..."}
 	}

 	h := genHelper{
 		wuffsRoot:   wuffsRoot,
 		langs:       langs,
 		cformatter:  *cformatterFlag,
 		genlinenum:  *genlinenumFlag,
 		skipgen:     genlib && *skipgenFlag,
 		skipgendeps: *skipgendepsFlag,
 	}

 	for _, arg := range args {
 		recursive := strings.HasSuffix(arg, "/...")
 		if recursive {
 			arg = arg[:len(arg)-4]
 		}
 		if arg == "" {
 			continue
 		}

 		if err := h.gen(arg, recursive); err != nil {
 			return err
 		}
 	}

 	if genlib {
 		return h.genlibAffected()
 	}
 	return genrelease(wuffsRoot, langs, v)
 }

 type genHelper struct {
 	wuffsRoot   string
 	langs       []string
 	cformatter  string
 	genlinenum  bool
 	skipgen     bool
 	skipgendeps bool

 	affected []string
 	seen     map[string]struct{}
 	tm       t.Map
 }

 func (h *genHelper) gen(dirname string, recursive bool) error {
 	for len(dirname) > 0 && dirname[len(dirname)-1] == '/' {
 		dirname = dirname[:len(dirname)-1]
 	}

 	if h.seen == nil {
 		h.seen = map[string]struct{}{}
 	} else if _, ok := h.seen[dirname]; ok {
 		return nil
 	}
 	h.seen[dirname] = struct{}{}

 	if dirname == "base" {
 		if err := h.genDir(dirname, nil); err != nil {
 			return err
 		}
 		h.affected = append(h.affected, dirname)
 		return nil
 	}

 	if !cf.IsValidUsePath(dirname) {
 		return fmt.Errorf("invalid package path %q", dirname)
 	}

 	qualFilenames, dirnames, err := listDir(
 		filepath.Join(h.wuffsRoot, filepath.FromSlash(dirname)), ".wuffs", recursive)
 	if err != nil {
 		return err
 	}
 	if len(qualFilenames) > 0 {
 		if err := h.genDir(dirname, qualFilenames); err != nil {
 			return err
 		}
 		h.affected = append(h.affected, dirname)
 	}
 	if len(dirnames) > 0 {
 		for _, d := range dirnames {
 			if err := h.gen(dirname+"/"+d, recursive); err != nil {
 				return err
 			}
 		}
 	}
 	return nil
 }

 func (h *genHelper) genDir(dirname string, qualFilenames []string) error {
 	// TODO: skip the generation if the output file already exists and its
 	// mtime is newer than all inputs and the wuffs-gen-foo command.

 	packageName := path.Base(dirname)
 	if !validName(packageName) {
 		return fmt.Errorf(`invalid package %q, not in [a-z0-9]+`, packageName)
 	}

 	if h.skipgen {
 		return nil
 	}
 	if !h.skipgendeps {
 		if err := h.genDirDependencies(qualFilenames); err != nil {
 			return err
 		}
 	}

 	for _, lang := range h.langs {
 		command := "wuffs-" + lang
 		cmdArgs := []string{"gen", "-package_name", packageName}
 		if (lang == "c") && (h.cformatter != cf.CformatterDefault) {
 			cmdArgs = append(cmdArgs, fmt.Sprintf("-cformatter=%s", h.cformatter))
 		}
 		if h.genlinenum != cf.GenlinenumDefault {
 			cmdArgs = append(cmdArgs, fmt.Sprintf("-genlinenum=%t", h.genlinenum))
 		}
 		cmdArgs = append(cmdArgs, qualFilenames...)
 		stdout := &bytes.Buffer{}

 		cmd := exec.Command(command, cmdArgs...)
 		cmd.Stdin = nil
 		cmd.Stdout = stdout
 		cmd.Stderr = os.Stderr
 		if err := cmd.Run(); err == nil {
 			// No-op.
 		} else if _, ok := err.(*exec.ExitError); ok {
 			return fmt.Errorf("%s: failed", command)
 		} else {
 			return err
 		}
 		out := stdout.Bytes()

 		flatDirname := fmt.Sprintf("wuffs-%s", strings.Replace(dirname, "/", "-", -1))
 		if err := h.genFile(flatDirname, lang, out); err != nil {
 			return err
 		}
 	}
 	if len(h.langs) > 0 && packageName != "base" {
 		if err := h.genWuffs(dirname, qualFilenames); err != nil {
 			return err
 		}
 	}
 	return nil
 }

 func (h *genHelper) genDirDependencies(qualifiedFilenames []string) error {
 	files, err := generate.ParseFiles(&h.tm, qualifiedFilenames, nil)
 	if err != nil {
 		return err
 	}
 	for _, f := range files {
 		for _, n := range f.TopLevelDecls() {
 			if n.Kind() != a.KUse {
 				continue
 			}
 			useDirname := h.tm.ByID(n.AsUse().Path())
 			useDirname, _ = t.Unescape(useDirname)
 			if err := h.gen(useDirname, false); err != nil {
 				return err
 			}
 		}
 	}
 	return h.gen("base", false)
 }

 func (h *genHelper) genFile(dirname string, lang string, out []byte) error {
 	return writeFile(
 		filepath.Join(h.wuffsRoot, "gen", lang, filepath.FromSlash(dirname)+"."+lang),
 		out,
 	)
 }

 func (h *genHelper) genWuffs(dirname string, qualifiedFilenames []string) error {
 	files, err := generate.ParseFiles(&h.tm, qualifiedFilenames, &parse.Options{
 		AllowDoubleUnderscoreNames: true,
 	})
 	if err != nil {
 		return err
 	}

 	out := &bytes.Buffer{}
 	fmt.Fprintf(out, "// Code generated by running \"wuffs gen\". DO NOT EDIT.\n\n")

 	for _, f := range files {
 		for _, n := range f.TopLevelDecls() {
 			switch n.Kind() {
 			case a.KConst:
 				n := n.AsConst()
 				if !n.Public() {
 					continue
 				}
 				fmt.Fprintf(out, "pub const %s %s = %v\n",
 					n.QID().Str(&h.tm), n.XType().Str(&h.tm), n.Value().Str(&h.tm))

 			case a.KFunc:
 				n := n.AsFunc()
 				if !n.Public() {
 					continue
 				}
 				if n.Receiver().IsZero() {
 					return fmt.Errorf("TODO: genWuffs for a free-standing function")
 				}
 				// TODO: look at n.Asserts().
 				fmt.Fprintf(out, "pub func %s.%s%v(", n.Receiver().Str(&h.tm), n.FuncName().Str(&h.tm), n.Effect())
 				for i, field := range n.In().Fields() {
 					field := field.AsField()
 					if i > 0 {
 						fmt.Fprintf(out, ", ")
 					}
 					// TODO: what happens if the XType is from another package?
 					// Similarly for the out-param.
 					fmt.Fprintf(out, "%s %s", field.Name().Str(&h.tm), field.XType().Str(&h.tm))
 				}
 				fmt.Fprintf(out, ") ")
 				if o := n.Out(); o != nil {
 					fmt.Fprintf(out, "%s", o.Str(&h.tm))
 				}
 				fmt.Fprintf(out, " { }\n")

 			case a.KStatus:
 				n := n.AsStatus()
 				if !n.Public() {
 					continue
 				}
 				fmt.Fprintf(out, "pub status %s\n", n.QID().Str(&h.tm))

 			case a.KStruct:
 				n := n.AsStruct()
 				if !n.Public() {
 					continue
 				}
 				classy := ""
 				if n.Classy() {
 					classy = "?"
 				}
 				fmt.Fprintf(out, "pub struct %s%s()\n", n.QID().Str(&h.tm), classy)
 			}
 		}
 	}
 	return h.genFile(dirname, "wuffs", out.Bytes())
 }

 func (h *genHelper) genlibAffected() error {
 	for _, lang := range h.langs {
 		command := "wuffs-" + lang
 		args := []string{"genlib"}
 		args = append(args, "-dstdir", filepath.Join(h.wuffsRoot, "gen", "lib", lang))
 		args = append(args, "-srcdir", filepath.Join(h.wuffsRoot, "gen", lang))
 		args = append(args, h.affected...)
 		cmd := exec.Command(command, args...)
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 		if err := cmd.Run(); err != nil {
 			return err
 		}
 	}
 	return nil
 }
	// Copyright 2017 The Wuffs Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package main

	import (
	"bytes"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"strings"

	"github.com/google/wuffs/lang/generate"
	"github.com/google/wuffs/lang/parse"

	cf "github.com/google/wuffs/cmd/commonflags"

	a "github.com/google/wuffs/lang/ast"
	t "github.com/google/wuffs/lang/token"
	)

	func doGen(wuffsRoot string, args []string) error { return doGenGenlib(wuffsRoot, args, false) }
	func doGenlib(wuffsRoot string, args []string) error { return doGenGenlib(wuffsRoot, args, true) }

	func doGenGenlib(wuffsRoot string, args []string, genlib bool) error {
	flags := flag.NewFlagSet("gen", flag.ExitOnError)
	cformatterFlag := flags.String("cformatter", cf.CformatterDefault, cf.CformatterUsage)
	genlinenumFlag := flags.Bool("genlinenum", cf.GenlinenumDefault, cf.GenlinenumUsage)
	langsFlag := flags.String("langs", langsDefault, langsUsage)
	skipgendepsFlag := flags.Bool("skipgendeps", skipgendepsDefault, skipgendepsUsage)

	skipgenFlag := (*bool)(nil)
	if genlib {
	skipgenFlag = flags.Bool("skipgen", skipgenDefault, skipgenUsage)
	}
	versionFlag := (*string)(nil)
	if !genlib {
	versionFlag = flags.String("version", cf.VersionDefault, cf.VersionUsage)
	}

	if err := flags.Parse(args); err != nil {
	return err
	}
	if !cf.IsAlphaNumericIsh(*cformatterFlag) {
	return fmt.Errorf("bad -cformatter flag value %q", *cformatterFlag)
	}
	langs, err := parseLangs(*langsFlag)
	if err != nil {
	return err
	}
	v := cf.Version{}
	if !genlib {
	ok := false
	v, ok = cf.ParseVersion(*versionFlag)
	if !ok {
	return fmt.Errorf("bad -version flag value %q", *versionFlag)
	}
	}
	args = flags.Args()
	if len(args) == 0 {
	args = []string{"base", "std/..."}
	}

	h := genHelper{
	wuffsRoot: wuffsRoot,
	langs: langs,
	cformatter: *cformatterFlag,
	genlinenum: *genlinenumFlag,
	skipgen: genlib && *skipgenFlag,
	skipgendeps: *skipgendepsFlag,
	}

	for _, arg := range args {
	recursive := strings.HasSuffix(arg, "/...")
	if recursive {
	arg = arg[:len(arg)-4]
	}
	if arg == "" {
	continue
	}

	if err := h.gen(arg, recursive); err != nil {
	return err
	}
	}

	if genlib {
	return h.genlibAffected()
	}
	return genrelease(wuffsRoot, langs, v)
	}

	type genHelper struct {
	wuffsRoot string
	langs []string
	cformatter string
	genlinenum bool
	skipgen bool
	skipgendeps bool

	affected []string
	seen map[string]struct{}
	tm t.Map
	}

	func (h *genHelper) gen(dirname string, recursive bool) error {
	for len(dirname) > 0 && dirname[len(dirname)-1] == '/' {
	dirname = dirname[:len(dirname)-1]
	}

	if h.seen == nil {
	h.seen = map[string]struct{}{}
	} else if _, ok := h.seen[dirname]; ok {
	return nil
	}
	h.seen[dirname] = struct{}{}

	if dirname == "base" {
	if err := h.genDir(dirname, nil); err != nil {
	return err
	}
	h.affected = append(h.affected, dirname)
	return nil
	}

	if !cf.IsValidUsePath(dirname) {
	return fmt.Errorf("invalid package path %q", dirname)
	}

	qualFilenames, dirnames, err := listDir(
	filepath.Join(h.wuffsRoot, filepath.FromSlash(dirname)), ".wuffs", recursive)
	if err != nil {
	return err
	}
	if len(qualFilenames) > 0 {
	if err := h.genDir(dirname, qualFilenames); err != nil {
	return err
	}
	h.affected = append(h.affected, dirname)
	}
	if len(dirnames) > 0 {
	for _, d := range dirnames {
	if err := h.gen(dirname+"/"+d, recursive); err != nil {
	return err
	}
	}
	}
	return nil
	}

	func (h *genHelper) genDir(dirname string, qualFilenames []string) error {
	// TODO: skip the generation if the output file already exists and its
	// mtime is newer than all inputs and the wuffs-gen-foo command.

	packageName := path.Base(dirname)
	if !validName(packageName) {
	return fmt.Errorf(`invalid package %q, not in [a-z0-9]+`, packageName)
	}

	if h.skipgen {
	return nil
	}
	if !h.skipgendeps {
	if err := h.genDirDependencies(qualFilenames); err != nil {
	return err
	}
	}

	for _, lang := range h.langs {
	command := "wuffs-" + lang
	cmdArgs := []string{"gen", "-package_name", packageName}
	if (lang == "c") && (h.cformatter != cf.CformatterDefault) {
	cmdArgs = append(cmdArgs, fmt.Sprintf("-cformatter=%s", h.cformatter))
	}
	if h.genlinenum != cf.GenlinenumDefault {
	cmdArgs = append(cmdArgs, fmt.Sprintf("-genlinenum=%t", h.genlinenum))
	}
	cmdArgs = append(cmdArgs, qualFilenames...)
	stdout := &bytes.Buffer{}

	cmd := exec.Command(command, cmdArgs...)
	cmd.Stdin = nil
	cmd.Stdout = stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err == nil {
	// No-op.
	} else if _, ok := err.(*exec.ExitError); ok {
	return fmt.Errorf("%s: failed", command)
	} else {
	return err
	}
	out := stdout.Bytes()

	flatDirname := fmt.Sprintf("wuffs-%s", strings.Replace(dirname, "/", "-", -1))
	if err := h.genFile(flatDirname, lang, out); err != nil {
	return err
	}
	}
	if len(h.langs) > 0 && packageName != "base" {
	if err := h.genWuffs(dirname, qualFilenames); err != nil {
	return err
	}
	}
	return nil
	}

	func (h *genHelper) genDirDependencies(qualifiedFilenames []string) error {
	files, err := generate.ParseFiles(&h.tm, qualifiedFilenames, nil)
	if err != nil {
	return err
	}
	for _, f := range files {
	for _, n := range f.TopLevelDecls() {
	if n.Kind() != a.KUse {
	continue
	}
	useDirname := h.tm.ByID(n.AsUse().Path())
	useDirname, _ = t.Unescape(useDirname)
	if err := h.gen(useDirname, false); err != nil {
	return err
	}
	}
	}
	return h.gen("base", false)
	}

	func (h *genHelper) genFile(dirname string, lang string, out []byte) error {
	return writeFile(
	filepath.Join(h.wuffsRoot, "gen", lang, filepath.FromSlash(dirname)+"."+lang),
	out,
	)
	}

	func (h *genHelper) genWuffs(dirname string, qualifiedFilenames []string) error {
	files, err := generate.ParseFiles(&h.tm, qualifiedFilenames, &parse.Options{
	AllowDoubleUnderscoreNames: true,
	})
	if err != nil {
	return err
	}

	out := &bytes.Buffer{}
	fmt.Fprintf(out, "// Code generated by running \"wuffs gen\". DO NOT EDIT.\n\n")

	for _, f := range files {
	for _, n := range f.TopLevelDecls() {
	switch n.Kind() {
	case a.KConst:
	n := n.AsConst()
	if !n.Public() {
	continue
	}
	fmt.Fprintf(out, "pub const %s %s = %v\n",
	n.QID().Str(&h.tm), n.XType().Str(&h.tm), n.Value().Str(&h.tm))

	case a.KFunc:
	n := n.AsFunc()
	if !n.Public() {
	continue
	}
	if n.Receiver().IsZero() {
	return fmt.Errorf("TODO: genWuffs for a free-standing function")
	}
	// TODO: look at n.Asserts().
	fmt.Fprintf(out, "pub func %s.%s%v(", n.Receiver().Str(&h.tm), n.FuncName().Str(&h.tm), n.Effect())
	for i, field := range n.In().Fields() {
	field := field.AsField()
	if i > 0 {
	fmt.Fprintf(out, ", ")
	}
	// TODO: what happens if the XType is from another package?
	// Similarly for the out-param.
	fmt.Fprintf(out, "%s %s", field.Name().Str(&h.tm), field.XType().Str(&h.tm))
	}
	fmt.Fprintf(out, ") ")
	if o := n.Out(); o != nil {
	fmt.Fprintf(out, "%s", o.Str(&h.tm))
	}
	fmt.Fprintf(out, " { }\n")

	case a.KStatus:
	n := n.AsStatus()
	if !n.Public() {
	continue
	}
	fmt.Fprintf(out, "pub status %s\n", n.QID().Str(&h.tm))

	case a.KStruct:
	n := n.AsStruct()
	if !n.Public() {
	continue
	}
	classy := ""
	if n.Classy() {
	classy = "?"
	}
	fmt.Fprintf(out, "pub struct %s%s()\n", n.QID().Str(&h.tm), classy)
	}
	}
	}
	return h.genFile(dirname, "wuffs", out.Bytes())
	}

	func (h *genHelper) genlibAffected() error {
	for _, lang := range h.langs {
	command := "wuffs-" + lang
	args := []string{"genlib"}
	args = append(args, "-dstdir", filepath.Join(h.wuffsRoot, "gen", "lib", lang))
	args = append(args, "-srcdir", filepath.Join(h.wuffsRoot, "gen", lang))
	args = append(args, h.affected...)
	cmd := exec.Command(command, args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
	return err
	}
	}
	return nil
	}