mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
371 lines
11 KiB
Go
371 lines
11 KiB
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"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/google/wuffs/internal/cgen"
|
|
|
|
cf "github.com/google/wuffs/cmd/commonflags"
|
|
)
|
|
|
|
func doGenrelease(args []string) error {
|
|
flags := flag.FlagSet{}
|
|
commitDateFlag := flags.String("commitdate", "", "git commit date the release was built from")
|
|
gitRevListCountFlag := flags.Int("gitrevlistcount", 0, `git "rev-list --count" that the release was built from`)
|
|
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 (*gitRevListCountFlag < 0) || (0x7FFFFFFF < *gitRevListCountFlag) {
|
|
return fmt.Errorf("bad -gitrevlistcount flag value %d", *gitRevListCountFlag)
|
|
}
|
|
if !cf.IsAlphaNumericIsh(*commitDateFlag) {
|
|
return fmt.Errorf("bad -commitdate flag value %q", *commitDateFlag)
|
|
}
|
|
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()
|
|
|
|
// Calculate the base directory.
|
|
baseDir := ""
|
|
for _, filename := range args {
|
|
if filepath.Base(filename) != "wuffs-base.c" {
|
|
continue
|
|
}
|
|
baseDir = filepath.Dir(filename)
|
|
}
|
|
if baseDir == "" {
|
|
return fmt.Errorf("could not determine base directory")
|
|
}
|
|
baseDirSlash := baseDir + string(filepath.Separator)
|
|
|
|
h := &genReleaseHelper{
|
|
filesList: nil,
|
|
filesMap: map[string]parsedCFile{},
|
|
seen: nil,
|
|
commitDate: *commitDateFlag,
|
|
gitRevListCount: *gitRevListCountFlag,
|
|
revision: *revisionFlag,
|
|
version: v,
|
|
}
|
|
|
|
for _, filename := range args {
|
|
if !strings.HasPrefix(filename, baseDirSlash) {
|
|
return fmt.Errorf("filename %q is not under base directory %q", filename, baseDir)
|
|
}
|
|
relFilename := filename[len(baseDirSlash):]
|
|
|
|
s, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := h.parse(relFilename, s); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
sort.Strings(h.filesList)
|
|
|
|
out := bytes.NewBuffer(nil)
|
|
out.WriteString("#ifndef WUFFS_INCLUDE_GUARD\n")
|
|
out.WriteString("#define WUFFS_INCLUDE_GUARD\n\n")
|
|
out.WriteString(grSingleFileGuidance[1:]) // [1:] skips the initial '\n'.
|
|
out.WriteString(grPragmaPush[1:]) // [1:] skips the initial '\n'.
|
|
|
|
h.seen = map[string]bool{}
|
|
for _, f := range h.filesList {
|
|
if err := h.gen(out, f, 0, 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
out.WriteString("#if defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
|
|
out.WriteString(cgen.EmbeddedString_AuxBaseHh.Trim())
|
|
out.WriteString("\n")
|
|
for _, f := range cgen.EmbeddedStrings_AuxNonBaseHhFiles {
|
|
out.WriteString(f.Trim())
|
|
out.WriteString("\n")
|
|
}
|
|
out.WriteString("#endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n")
|
|
|
|
out.Write(grImplStartsHere)
|
|
out.WriteString("\n")
|
|
|
|
h.seen = map[string]bool{}
|
|
for _, f := range h.filesList {
|
|
if err := h.gen(out, f, 1, 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
out.WriteString("#if defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
|
|
out.WriteString(cgen.EmbeddedString_AuxBaseCc.Trim())
|
|
out.WriteString("\n")
|
|
for _, f := range cgen.EmbeddedStrings_AuxNonBaseCcFiles {
|
|
out.WriteString(f.Trim())
|
|
out.WriteString("\n")
|
|
}
|
|
out.WriteString("#endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
|
|
|
|
out.Write(grImplEndsHere)
|
|
out.WriteString(grPragmaPop)
|
|
out.WriteString("#endif // WUFFS_INCLUDE_GUARD\n")
|
|
|
|
os.Stdout.Write(out.Bytes())
|
|
return nil
|
|
}
|
|
|
|
var (
|
|
grImplStartsHere = []byte("\n// ‼ WUFFS C HEADER ENDS HERE.\n#ifdef WUFFS_IMPLEMENTATION\n")
|
|
grImplEndsHere = []byte("#endif // WUFFS_IMPLEMENTATION\n")
|
|
grIncludeQuote = []byte("#include \"")
|
|
grNN = []byte("\n\n")
|
|
grVOverride = []byte("// ¡ Some code generation programs can override WUFFS_VERSION.\n")
|
|
grVEnd = []byte(`#define WUFFS_VERSION_STRING "0.0.0+0.00000000"`)
|
|
grWmrAbove = []byte("// ¡ WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING ABOVE.\n")
|
|
grWmrBelow = []byte("// ¡ WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING BELOW.\n")
|
|
)
|
|
|
|
const grSingleFileGuidance = `
|
|
// Wuffs ships as a "single file C library" or "header file library" as per
|
|
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
|
|
//
|
|
// To use that single file as a "foo.c"-like implementation, instead of a
|
|
// "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or
|
|
// compiling it.
|
|
|
|
`
|
|
|
|
const grPragmaPush = `
|
|
// Wuffs' C code is generated automatically, not hand-written. These warnings'
|
|
// costs outweigh the benefits.
|
|
//
|
|
// The "elif defined(__clang__)" isn't redundant. While vanilla clang defines
|
|
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
|
|
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
|
|
#pragma GCC diagnostic ignored "-Wunreachable-code"
|
|
#pragma GCC diagnostic ignored "-Wunused-function"
|
|
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
|
#if defined(__cplusplus)
|
|
#pragma GCC diagnostic ignored "-Wold-style-cast"
|
|
#endif
|
|
#elif defined(__clang__)
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
|
|
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
|
|
#pragma clang diagnostic ignored "-Wunreachable-code"
|
|
#pragma clang diagnostic ignored "-Wunused-function"
|
|
#pragma clang diagnostic ignored "-Wunused-parameter"
|
|
#if defined(__cplusplus)
|
|
#pragma clang diagnostic ignored "-Wold-style-cast"
|
|
#endif
|
|
#endif
|
|
|
|
`
|
|
|
|
const grPragmaPop = `
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic pop
|
|
#elif defined(__clang__)
|
|
#pragma clang diagnostic pop
|
|
#endif
|
|
|
|
`
|
|
|
|
type parsedCFile struct {
|
|
includes []string
|
|
// fragments[0] is the header, fragments[1] is the implementation.
|
|
fragments [2][]byte
|
|
}
|
|
|
|
type genReleaseHelper struct {
|
|
filesList []string
|
|
filesMap map[string]parsedCFile
|
|
seen map[string]bool
|
|
commitDate string
|
|
gitRevListCount int
|
|
revision string
|
|
version cf.Version
|
|
}
|
|
|
|
func (h *genReleaseHelper) parse(relFilename string, s []byte) error {
|
|
if _, ok := h.filesMap[relFilename]; ok {
|
|
return fmt.Errorf("duplicate %q", relFilename)
|
|
}
|
|
|
|
f := parsedCFile{}
|
|
|
|
if i := bytes.Index(s, grWmrAbove); i < 0 {
|
|
return fmt.Errorf("could not find %q in %s", grWmrAbove, relFilename)
|
|
} else {
|
|
f.includes = parseIncludes(s[:i])
|
|
s = s[i+len(grWmrAbove):]
|
|
}
|
|
|
|
if i := bytes.LastIndex(s, grWmrBelow); i < 0 {
|
|
return fmt.Errorf("could not find %q in %s", grWmrBelow, relFilename)
|
|
} else {
|
|
s = s[:i]
|
|
}
|
|
|
|
if i := bytes.Index(s, grImplStartsHere); i < 0 {
|
|
return fmt.Errorf("could not find %q in %s", grImplStartsHere, relFilename)
|
|
} else {
|
|
f.fragments[0], s = bytes.TrimSpace(s[:i]), s[i+len(grImplStartsHere):]
|
|
}
|
|
|
|
if i := bytes.LastIndex(s, grImplEndsHere); i < 0 {
|
|
return fmt.Errorf("could not find %q in %s", grImplEndsHere, relFilename)
|
|
} else {
|
|
f.fragments[1] = bytes.TrimSpace(s[:i])
|
|
}
|
|
|
|
if relFilename == "wuffs-base.c" && (h.version != cf.Version{}) {
|
|
if subs, err := h.substituteWuffsVersion(f.fragments[0]); err != nil {
|
|
return err
|
|
} else {
|
|
f.fragments[0] = bytes.TrimSpace(subs)
|
|
}
|
|
}
|
|
|
|
h.filesList = append(h.filesList, relFilename)
|
|
h.filesMap[relFilename] = f
|
|
return nil
|
|
}
|
|
|
|
func parseIncludes(s []byte) (ret []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 || s[0] != '#' || !bytes.HasPrefix(s, grIncludeQuote) {
|
|
continue
|
|
}
|
|
s = s[len(grIncludeQuote):]
|
|
if len(s) < 2 || s[len(s)-2] != '"' || s[len(s)-1] != '\n' {
|
|
continue
|
|
}
|
|
s = s[:len(s)-2]
|
|
|
|
ret = append(ret, string(s))
|
|
}
|
|
sort.Strings(ret)
|
|
return ret
|
|
}
|
|
|
|
func (h *genReleaseHelper) gen(w *bytes.Buffer, relFilename string, which int, depth uint32) error {
|
|
if depth > 1024 {
|
|
return fmt.Errorf("genrelease recursion depth too large")
|
|
}
|
|
depth++
|
|
|
|
if strings.HasPrefix(relFilename, "./") {
|
|
relFilename = relFilename[2:]
|
|
}
|
|
|
|
if h.seen[relFilename] {
|
|
return nil
|
|
}
|
|
f, ok := h.filesMap[relFilename]
|
|
if !ok {
|
|
return fmt.Errorf("cannot resolve %q", relFilename)
|
|
}
|
|
|
|
// Process the files in #include-ee before #include-er order.
|
|
for _, inc := range f.includes {
|
|
if err := h.gen(w, inc, which, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
w.Write(f.fragments[which])
|
|
w.WriteString("\n\n")
|
|
h.seen[relFilename] = true
|
|
return nil
|
|
}
|
|
|
|
func (h *genReleaseHelper) substituteWuffsVersion(s []byte) ([]byte, error) {
|
|
ret := []byte(nil)
|
|
if i := bytes.Index(s, grVOverride); i < 0 {
|
|
return nil, fmt.Errorf("could not find %q in %s", grVOverride, "wuffs-base.c")
|
|
} else {
|
|
ret = append(ret, s[:i]...)
|
|
s = s[i+len(grVOverride):]
|
|
}
|
|
|
|
cut := []byte(nil)
|
|
if i := bytes.Index(s, grNN); i < 0 {
|
|
return nil, fmt.Errorf(`could not find "\n\n" near WUFFS_VERSION`)
|
|
} else {
|
|
cut, s = s[:i], s[i+len(grNN):]
|
|
}
|
|
|
|
if !bytes.HasSuffix(cut, grVEnd) {
|
|
return nil, fmt.Errorf("%q did not end with %q", cut, grVEnd)
|
|
}
|
|
|
|
w := bytes.NewBuffer(nil)
|
|
fmt.Fprintf(w, `// WUFFS_VERSION was overridden by "wuffs gen -version"`)
|
|
if h.revision != "" && h.commitDate != "" {
|
|
fmt.Fprintf(w, " based on revision\n// %s committed on %s", h.revision, h.commitDate)
|
|
}
|
|
|
|
commitDate := "0"
|
|
if h.commitDate != "" {
|
|
commitDate = strings.Replace(h.commitDate, "-", "", -1)
|
|
}
|
|
|
|
buildMetadata := ""
|
|
if h.gitRevListCount != 0 {
|
|
buildMetadata = fmt.Sprintf("+%d.%s", h.gitRevListCount, commitDate)
|
|
}
|
|
|
|
fmt.Fprintf(w, `.
|
|
#define WUFFS_VERSION 0x%09X
|
|
#define WUFFS_VERSION_MAJOR %d
|
|
#define WUFFS_VERSION_MINOR %d
|
|
#define WUFFS_VERSION_PATCH %d
|
|
#define WUFFS_VERSION_PRE_RELEASE_LABEL %q
|
|
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT %d
|
|
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE %s
|
|
#define WUFFS_VERSION_STRING %q
|
|
|
|
`, h.version.Uint64(), h.version.Major, h.version.Minor, h.version.Patch,
|
|
h.version.Extension, h.gitRevListCount, commitDate,
|
|
h.version.String()+buildMetadata)
|
|
|
|
ret = append(ret, w.Bytes()...)
|
|
ret = append(ret, s...)
|
|
return ret, nil
|
|
}
|