cmd/wuffs-c/release.go

// Copyright 2018 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"
	"io/ioutil"
	"os"
	"os/exec"
	"time"

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

func doGenrelease(args []string) error {
	flags := flag.FlagSet{}
	cformatterFlag := flags.String("cformatter", cf.CformatterDefault, cf.CformatterUsage)
	revisionFlag := flags.String("revision", "", "git revision the release was built from")
	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)
	}
	if !cf.IsAlphaNumericIsh(*revisionFlag) {
		return fmt.Errorf("bad -revision flag value %q", *revisionFlag)
	}
	v, ok := cf.ParseVersion(*versionFlag)
	if !ok {
		return fmt.Errorf("bad -version flag value %q", *versionFlag)
	}
	args = flags.Args()

	h := &genReleaseHelper{
		seen:     map[string]bool{},
		revision: *revisionFlag,
		version:  v,
	}

	unformatted := bytes.NewBuffer(nil)
	unformatted.WriteString("#ifndef WUFFS_INCLUDE_GUARD\n")
	unformatted.WriteString("#define WUFFS_INCLUDE_GUARD\n\n")

	// First, cat all of the headers together, filtering out duplicate
	// WUFFS_INCLUDE_GUARD__FOO sections and overriding WUFFS_VERSION.
	for _, filename := range args {
		s, err := ioutil.ReadFile(filename)
		if err != nil {
			return err
		}

		if i := bytes.Index(s, grCHeader); i >= 0 {
			s = s[:i]
		} else {
			return fmt.Errorf("could not find %q", grCHeader)
		}

		if err := h.gen(unformatted, s); err != nil {
			return fmt.Errorf("%v in %s", err, filename)
		}
	}

	unformatted.WriteString("\n\n#endif  // WUFFS_INCLUDE_GUARD\n\n")
	unformatted.Write(grCHeader)
	unformatted.WriteString("\n")

	// Then, cat all of the implementations together, filtering out duplicate
	// WUFFS_INCLUDE_GUARD__BASE_PRIVATE sections.
	for _, filename := range args {
		s, err := ioutil.ReadFile(filename)
		if err != nil {
			return err
		}

		if i := bytes.Index(s, grCHeader); i >= 0 {
			s = s[i+len(grCHeader):]
		} else {
			continue
		}

		if err := h.gen(unformatted, s); err != nil {
			return fmt.Errorf("%v in %s", err, filename)
		}
	}

	cmd := exec.Command(*cformatterFlag, "-style=Chromium")
	cmd.Stdin = unformatted
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd.Run()
}

var (
	grCHeader   = []byte("// !! C HEADER ENDS HERE.\n")
	grNN        = []byte("\n\n")
	grVOverride = []byte("// !! Some code generation programs can override WUFFS_VERSION.\n")
	grVString   = []byte(`#define WUFFS_VERSION_STRING "0.0.0"`)

	grDefine = []byte("#define WUFFS_INCLUDE_GUARD__")
	grEndif  = []byte("#endif  // WUFFS_INCLUDE_GUARD__")
	grIfndef = []byte("#ifndef WUFFS_INCLUDE_GUARD__")
)

type genReleaseHelper struct {
	seen     map[string]bool
	revision string
	version  cf.Version
}

func (h *genReleaseHelper) gen(w *bytes.Buffer, s []byte) error {
	skipping := 0
	stack := []string{}

	for remaining := []byte(nil); len(s) > 0; s, remaining = remaining, nil {
		if i := bytes.IndexByte(s, '\n'); i >= 0 {
			s, remaining = s[:i+1], s[i+1:]
		}
		if len(s) == 0 {
			continue
		}

		if s[0] == '#' {
			switch {
			case bytes.HasPrefix(s, grIfndef):
				pkg := string(s[len(grIfndef):])
				for _, p := range stack {
					if p == pkg {
						return fmt.Errorf("unexpected %q", s)
					}
				}

				if h.seen[pkg] {
					skipping++
				}

				stack = append(stack, pkg)
				continue

			case bytes.HasPrefix(s, grDefine):
				pkg := string(s[len(grDefine):])
				if (len(stack) == 0) || (stack[len(stack)-1] != pkg) {
					return fmt.Errorf("unexpected %q", s)
				}
				continue

			case bytes.HasPrefix(s, grEndif):
				pkg := string(s[len(grEndif):])
				if (len(stack) == 0) || (stack[len(stack)-1] != pkg) {
					return fmt.Errorf("unexpected %q", s)
				}

				if h.seen[pkg] {
					skipping--
				} else {
					h.seen[pkg] = true
				}

				stack = stack[:len(stack)-1]
				continue
			}
		}

		if skipping > 0 {
			continue
		}

		if s[0] == '/' {
			switch {
			case bytes.Equal(s, grVOverride):
				var err error
				remaining, err = h.genWuffsVersion(w, remaining)
				if err != nil {
					return err
				}
				continue
			}
		}

		w.Write(s)
	}

	if len(stack) != 0 {
		return fmt.Errorf("unmatched %q", string(grIfndef)+stack[len(stack)-1])
	}
	return nil
}

func (h *genReleaseHelper) genWuffsVersion(w *bytes.Buffer, s []byte) (remaining []byte, err error) {
	cut := []byte(nil)
	if i := bytes.Index(s, grNN); i >= 0 {
		cut, s = s[:i], s[i+len(grNN):]
	} else {
		return nil, fmt.Errorf(`could not find "\n\n" near WUFFS_VERSION`)
	}

	if !bytes.HasSuffix(cut, grVString) {
		return nil, fmt.Errorf("%q did not end with %q", cut, grVString)
	}

	fmt.Fprintf(w, "// WUFFS_VERSION was overridden by \"wuffs genrelease\" on %v UTC",
		time.Now().UTC().Format("2006-01-02"))
	if h.revision != "" {
		fmt.Fprintf(w, ",\n// based on revision %s", h.revision)
	}

	fmt.Fprintf(w, `.
		#define WUFFS_VERSION ((uint64_t)0x%016X)
		#define WUFFS_VERSION_MAJOR ((uint64_t)0x%08X)
		#define WUFFS_VERSION_MINOR ((uint64_t)0x%04X)
		#define WUFFS_VERSION_PATCH ((uint64_t)0x%04X)
		#define WUFFS_VERSION_EXTENSION %q
		#define WUFFS_VERSION_STRING %q

	`, h.version.Uint64(), h.version.Major, h.version.Minor, h.version.Patch,
		h.version.Extension, h.version)

	return s, nil
}