Rename PUFFS to WUFFS, part 3 of N

This commit is contained in:
Nigel Tao committed 2017-11-30 16:26:16 +11:00
1 parent 0cea46531b
commit 7a6a598d1e
17 files changed
+4 -4

No files matched your search

+173
View File
@@ -0,0 +1,173 @@
// Copyright 2017 The Puffs 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"
"io/ioutil"
"os"
"os/exec"
"path"
"path/filepath"
"strings"
)
func doGen(puffsRoot string, args []string) error { return doGenGenlib(puffsRoot, args, false) }
func doGenlib(puffsRoot string, args []string) error { return doGenGenlib(puffsRoot, args, true) }
func doGenGenlib(puffsRoot string, args []string, genlib bool) error {
flags := flag.NewFlagSet("gen", flag.ExitOnError)
langsFlag := flags.String("langs", langsDefault, langsUsage)
if err := flags.Parse(args); err != nil {
return err
}
langs, err := parseLangs(*langsFlag)
if err != nil {
return err
}
args = flags.Args()
if len(args) == 0 {
args = []string{"std/..."}
}
affected := []string(nil)
for _, arg := range args {
recursive := strings.HasSuffix(arg, "/...")
if recursive {
arg = arg[:len(arg)-4]
}
var err error
affected, err = gen(affected, puffsRoot, arg, langs, recursive)
if err != nil {
return err
}
}
if genlib {
if err := genlibAffected(puffsRoot, langs, affected); err != nil {
return err
}
}
return nil
}
func gen(affected []string, puffsRoot, dirname string, langs []string, recursive bool) (retAffected []string, retErr error) {
filenames, dirnames, err := listDir(puffsRoot, dirname, recursive)
if err != nil {
return nil, err
}
if len(filenames) > 0 {
if err := genDir(puffsRoot, dirname, filenames, langs); err != nil {
return nil, err
}
affected = append(affected, dirname)
}
if len(dirnames) > 0 {
for _, d := range dirnames {
var err error
affected, err = gen(affected, puffsRoot, dirname+"/"+d, langs, recursive)
if err != nil {
return nil, err
}
}
}
return affected, nil
}
func genDir(puffsRoot string, dirname string, filenames []string, langs []string) error {
// TODO: skip the generation if the output file already exists and its
// mtime is newer than all inputs and the puffs-gen-foo command.
packageName := path.Base(dirname)
if !validName(packageName) {
return fmt.Errorf(`invalid package %q, not in [a-z0-9]+`, packageName)
}
cmdArgs := []string{"gen", "-package_name", packageName}
for _, filename := range filenames {
cmdArgs = append(cmdArgs,
filepath.Join(puffsRoot, filepath.FromSlash(dirname), filename))
}
for _, lang := range langs {
command := "puffs-" + lang
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()
if err := genFile(puffsRoot, dirname, lang, out); err != nil {
return err
}
// Special-case the "c" generator to also write a .h file.
if lang != "c" {
continue
}
if i := bytes.Index(out, cHeaderEndsHere); i < 0 {
return fmt.Errorf("%s: output did not contain %q", command, cHeaderEndsHere)
} else {
out = out[:i]
}
if err := genFile(puffsRoot, dirname, "h", out); err != nil {
return err
}
}
return nil
}
var cHeaderEndsHere = []byte("\n// C HEADER ENDS HERE.\n\n")
func genFile(puffsRoot string, dirname string, lang string, out []byte) error {
outFilename := filepath.Join(puffsRoot, "gen", lang, filepath.FromSlash(dirname)+"."+lang)
if existing, err := ioutil.ReadFile(outFilename); err == nil && bytes.Equal(existing, out) {
fmt.Println("gen unchanged: ", outFilename)
return nil
}
if err := os.MkdirAll(filepath.Dir(outFilename), 0755); err != nil {
return err
}
if err := ioutil.WriteFile(outFilename, out, 0644); err != nil {
return err
}
fmt.Println("gen wrote: ", outFilename)
return nil
}
func genlibAffected(puffsRoot string, langs []string, affected []string) error {
for _, lang := range langs {
command := "puffs-" + lang
args := []string{"genlib"}
args = append(args, "-dstdir", filepath.Join(puffsRoot, "gen", "lib", lang))
args = append(args, "-srcdir", filepath.Join(puffsRoot, "gen", lang))
args = append(args, affected...)
cmd := exec.Command(command, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
return err
}
}
return nil
}
+149
View File
@@ -0,0 +1,149 @@
// Copyright 2017 The Puffs 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.
// puffs is a tool for managing Puffs source code.
package main
import (
"errors"
"flag"
"fmt"
"go/build"
"os"
"path/filepath"
"sort"
"strings"
)
var commands = []struct {
name string
do func(puffsRoot string, args []string) error
}{
{"bench", doBench},
{"gen", doGen},
{"genlib", doGenlib},
{"test", doTest},
}
func usage() {
fmt.Fprintf(os.Stderr, `Puffs is a tool for managing Puffs source code.
Usage:
puffs command [arguments]
The commands are:
bench benchmark packages
gen generate code for packages and dependencies
genlib generate software libraries
test test packages
`)
}
func main() {
if err := main1(); err != nil {
os.Stderr.WriteString(err.Error() + "\n")
os.Exit(1)
}
}
func main1() error {
flag.Usage = usage
flag.Parse()
puffsRoot, err := findPuffsRoot()
if err != nil {
return err
}
if args := flag.Args(); len(args) > 0 {
for _, c := range commands {
if args[0] == c.name {
return c.do(puffsRoot, args[1:])
}
}
}
usage()
os.Exit(1)
return nil
}
func findPuffsRoot() (string, error) {
// TODO: look for a PUFFSROOT environment variable?
for _, p := range filepath.SplitList(build.Default.GOPATH) {
p = filepath.Join(p, "src", "github.com", "google", "puffs")
if o, err := os.Stat(p); err == nil && o.IsDir() {
return p, nil
}
}
return "", errors.New("could not find Puffs root directory")
}
func listDir(puffsRoot string, dirname string, returnSubdirs bool) (filenames []string, dirnames []string, err error) {
f, err := os.Open(filepath.Join(puffsRoot, filepath.FromSlash(dirname)))
if err != nil {
return nil, nil, err
}
defer f.Close()
infos, err := f.Readdir(-1)
if err != nil {
return nil, nil, err
}
for _, o := range infos {
name := o.Name()
if o.IsDir() {
if returnSubdirs {
dirnames = append(dirnames, name)
}
} else if strings.HasSuffix(name, ".puffs") {
filenames = append(filenames, name)
}
}
sort.Strings(filenames)
sort.Strings(dirnames)
return filenames, dirnames, nil
}
const (
langsDefault = "c"
langsUsage = `comma-separated list of target languages (file extensions), e.g. "c,go,rs"`
skipgenDefault = false
skipgenUsage = `whether to skip automatically generating code when testing`
)
func parseLangs(commaSeparated string) ([]string, error) {
ret := []string(nil)
for _, s := range strings.Split(commaSeparated, ",") {
if !validName(s) {
return nil, fmt.Errorf(`invalid lang %q, not in [a-z0-9]+`, s)
}
ret = append(ret, s)
}
return ret, nil
}
func validName(s string) bool {
if len(s) == 0 {
return false
}
for _, c := range s {
if (c < '0' || '9' < c) && (c < 'a' || 'z' < c) {
return false
}
}
return true
}
+170
View File
@@ -0,0 +1,170 @@
// Copyright 2017 The Puffs 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 (
"flag"
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
cf "github.com/google/wuffs/cmd/commonflags"
)
func doBench(puffsRoot string, args []string) error { return doBenchTest(puffsRoot, args, true) }
func doTest(puffsRoot string, args []string) error { return doBenchTest(puffsRoot, args, false) }
func doBenchTest(puffsRoot string, args []string, bench bool) error {
flags := flag.NewFlagSet("test", flag.ExitOnError)
ccompilersFlag := flags.String("ccompilers", cf.CcompilersDefault, cf.CcompilersUsage)
focusFlag := flags.String("focus", cf.FocusDefault, cf.FocusUsage)
langsFlag := flags.String("langs", langsDefault, langsUsage)
mimicFlag := flags.Bool("mimic", cf.MimicDefault, cf.MimicUsage)
repsFlag := flags.Int("reps", cf.RepsDefault, cf.RepsUsage)
skipgenFlag := flags.Bool("skipgen", skipgenDefault, skipgenUsage)
if err := flags.Parse(args); err != nil {
return err
}
langs, err := parseLangs(*langsFlag)
if err != nil {
return err
}
if !cf.IsAlphaNumericIsh(*ccompilersFlag) {
return fmt.Errorf("bad -ccompilers flag value %q", *ccompilersFlag)
}
if !cf.IsAlphaNumericIsh(*focusFlag) {
return fmt.Errorf("bad -focus flag value %q", *focusFlag)
}
if *repsFlag < cf.RepsMin || cf.RepsMax < *repsFlag {
return fmt.Errorf("bad -reps flag value %d, outside the range [%d..%d]", *repsFlag, cf.RepsMin, cf.RepsMax)
}
args = flags.Args()
if len(args) == 0 {
args = []string{"std/..."}
}
cmdArgs := []string(nil)
if bench {
cmdArgs = append(cmdArgs, "bench", fmt.Sprintf("-reps=%d", *repsFlag))
} else {
cmdArgs = append(cmdArgs, "test")
}
if *focusFlag != "" {
cmdArgs = append(cmdArgs, fmt.Sprintf("-focus=%s", *focusFlag))
}
if *mimicFlag {
cmdArgs = append(cmdArgs, "-mimic")
}
b := btHelper{
puffsRoot: puffsRoot,
langs: langs,
cmdArgs: cmdArgs,
ccompilers: *ccompilersFlag,
}
failed := false
for _, arg := range args {
recursive := strings.HasSuffix(arg, "/...")
if recursive {
arg = arg[:len(arg)-4]
}
// Ensure that we are testing the latest version of the generated code.
if !*skipgenFlag {
if _, err := gen(nil, puffsRoot, arg, langs, recursive); err != nil {
return err
}
}
// Proceed with benching / testing the generated code.
f, err := b.benchTest(arg, recursive)
if err != nil {
return err
}
failed = failed || f
}
if failed {
s0, s1 := "test", "tests"
if bench {
s0, s1 = "bench", "benchmarks"
}
return fmt.Errorf("puffs %s: some %s failed", s0, s1)
}
return nil
}
type btHelper struct {
puffsRoot string
langs []string
cmdArgs []string
ccompilers string
}
func (b *btHelper) benchTest(dirname string, recursive bool) (failed bool, err error) {
filenames, dirnames, err := listDir(b.puffsRoot, dirname, recursive)
if err != nil {
return false, err
}
if len(filenames) > 0 {
f, err := b.benchTestDir(dirname)
if err != nil {
return false, err
}
failed = failed || f
}
if len(dirnames) > 0 {
for _, d := range dirnames {
f, err := b.benchTest(filepath.Join(dirname, d), recursive)
if err != nil {
return false, err
}
failed = failed || f
}
}
return failed, nil
}
func (b *btHelper) benchTestDir(dirname string) (failed bool, err error) {
if packageName := filepath.Base(dirname); !validName(packageName) {
return false, fmt.Errorf(`invalid package %q, not in [a-z0-9]+`, packageName)
}
for _, lang := range b.langs {
command := "puffs-" + lang
args := []string(nil)
args = append(args, b.cmdArgs...)
if lang == "c" {
args = append(args, fmt.Sprintf("-ccompilers=%s", b.ccompilers))
}
args = append(args, filepath.Join(b.puffsRoot, "test", lang, filepath.FromSlash(dirname)))
cmd := exec.Command(command, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err == nil {
// No-op.
} else if _, ok := err.(*exec.ExitError); ok {
failed = true
} else {
return false, err
}
}
return failed, nil
}