experimental/tskit/go/gen_types/gen_types.go - skia - Git at Google

 // Copyright 2021 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.

 package main

 import (
 	"flag"
 	"fmt"
 	"io/ioutil"
 	"path/filepath"
 	"regexp"
 	"sort"
 	"strings"

 	"go.skia.org/infra/go/skerr"
 	"go.skia.org/infra/go/sklog"
 )

 func main() {
 	inputCPPDir := flag.String("input_cpp_dir", "", "A folder containing .cpp binding files that make use of the TS_* macros")
 	outputNamespaceDir := flag.String("output_namespace_dir", "", "The folder where the ambient namespace (.d.ts) files that correspond to the C++ API should be written")

 	flag.Parse()
 	if *inputCPPDir == "" || *outputNamespaceDir == "" {
 		sklog.Fatalf("--input_cpp_dir and --output_namespace_dir must be specified")
 	}

 	cppInputs, err := ioutil.ReadDir(*inputCPPDir)
 	if err != nil {
 		sklog.Fatalf("Could not read directory %s: %s", *inputCPPDir, err)
 	}
 	for _, file := range cppInputs {
 		name := file.Name()
 		if strings.HasSuffix(name, ".cpp") {
 			fp := filepath.Join(*inputCPPDir, name)
 			contents, err := ioutil.ReadFile(fp)
 			if err != nil {
 				sklog.Fatalf("Could not read file %s: %s", fp, err)
 			}
 			namespace := strings.TrimSuffix(name, ".cpp")
 			output, err := generateAmbientNamespace(namespace, string(contents))
 			if err != nil {
 				sklog.Fatalf("Could not generate ambient namespace from %s: %s", fp, err)
 			}
 			fp = filepath.Join(*outputNamespaceDir, namespace+".d.ts")
 			if err := ioutil.WriteFile(fp, []byte(output), 0666); err != nil {
 				sklog.Fatalf("Could not write to %s: %s", fp, err)
 			}
 		}
 	}
 }

 var (
 	privateExportLine    = regexp.MustCompile(`TS_PRIVATE_EXPORT\("(?P<export>.+)"\)`)
 	publicExportLine     = regexp.MustCompile(`TS_EXPORT\("(?P<export>.+)"\)`)
 	classDefinitionStart = regexp.MustCompile(`class_<.+>\("(?P<name>.+)"\)`)
 	classDefinitionEnd   = regexp.MustCompile(`\.(function|constructor).+;`)
 	typeAnnotation       = regexp.MustCompile(`@type\s+(?P<optional>@optional)?\s*(?P<type>\w+)`)
 	valueObjectStart     = regexp.MustCompile(`value_object<.+>\("(?P<name>.+)"\)`)
 	valueObjectField     = regexp.MustCompile(`.field\("(?P<name>.+?)",.+\);?`)
 	constantDefinition   = regexp.MustCompile(`constant\("(?P<name>.+?)",.+\);`)
 )

 // generateAmbientNamespace reads through the given file contents line by line. It looks for
 // explicit macro annotations (e.g. TS_EXPORT) and embind signatures (e.g. constant("foo", "bar").
 // From these, it generates the ambient namespace declarations and returns it as a string.
 // In general, it will put declarations in alphabetical order for deterministic ordering.
 func generateAmbientNamespace(namespace, contents string) (string, error) {
 	var privateModuleFunctions []string
 	var publicModuleFunctions []string
 	var wasmObjects []*wasmObject
 	var valueObjects []*valueObject
 	var constants []string

 	var currentWasmObject *wasmObject
 	var currentValueObject *valueObject
 	var lastTypeAnnotation string
 	var lastTypeOptional bool
 	lines := strings.Split(contents, "\n")
 	for i, line := range lines {
 		if match := classDefinitionStart.FindStringSubmatch(line); match != nil {
 			currentWasmObject = &wasmObject{
 				name: match[1],
 			}
 			wasmObjects = append(wasmObjects, currentWasmObject)
 		}
 		if classDefinitionEnd.MatchString(line) {
 			currentWasmObject = nil
 		}
 		if match := privateExportLine.FindStringSubmatch(line); match != nil {
 			export := match[1]
 			if currentWasmObject == nil {
 				privateModuleFunctions = append(privateModuleFunctions, export)
 			} else {
 				currentWasmObject.privateMethods = append(currentWasmObject.privateMethods, export)
 			}
 		}
 		if match := publicExportLine.FindStringSubmatch(line); match != nil {
 			export := match[1]
 			if currentWasmObject == nil {
 				publicModuleFunctions = append(publicModuleFunctions, export)
 			} else {
 				if strings.HasPrefix(export, "new") {
 					currentWasmObject.constructors = append(currentWasmObject.constructors, export)
 				} else {
 					currentWasmObject.publicMethods = append(currentWasmObject.publicMethods, export)
 				}
 			}
 		}
 		if match := typeAnnotation.FindStringSubmatch(line); match != nil {
 			lastTypeOptional = match[1] != ""
 			lastTypeAnnotation = match[2]
 		}
 		if match := valueObjectStart.FindStringSubmatch(line); match != nil {
 			currentValueObject = &valueObject{
 				name: match[1],
 			}
 			valueObjects = append(valueObjects, currentValueObject)
 		}
 		if match := valueObjectField.FindStringSubmatch(line); match != nil {
 			if currentValueObject == nil {
 				// Should never happen for valid code - embind wouldn't compile with this.
 				return "", skerr.Fmt("Line %d: Found a .field outside a value object declaration", i+1)
 			}
 			if lastTypeAnnotation == "" {
 				return "", skerr.Fmt("Line %d: field %q must be preceded by a @type annotation", i+1, match[1])
 			}
 			fieldWithType := fmt.Sprintf("%s: %s", match[1], lastTypeAnnotation)
 			if lastTypeOptional {
 				fieldWithType = fmt.Sprintf("%s?: %s", match[1], lastTypeAnnotation)
 			}
 			currentValueObject.fields = append(currentValueObject.fields, fieldWithType)
 			lastTypeAnnotation = "" // It's been consumed, so reset it
 			lastTypeOptional = false
 			if strings.HasSuffix(match[0], ";") {
 				currentValueObject = nil // we've gotten to the end of our value object
 			}
 		}
 		if match := constantDefinition.FindStringSubmatch(line); match != nil {
 			if lastTypeAnnotation == "" {
 				return "", skerr.Fmt("Line %d: constant %q must be preceded by a @type annotation", i+1, match[1])
 			}
 			constWithType := fmt.Sprintf("readonly %s: %s", match[1], lastTypeAnnotation)
 			if lastTypeOptional {
 				constWithType = fmt.Sprintf("readonly %s?: %s", match[1], lastTypeAnnotation)
 			}
 			constants = append(constants, constWithType)
 			lastTypeAnnotation = "" // It's been consumed, so reset it
 			lastTypeOptional = false
 		}
 	}

 	sort.Strings(privateModuleFunctions)
 	sort.Strings(publicModuleFunctions)
 	sort.Slice(wasmObjects, func(i, j int) bool {
 		return wasmObjects[i].name < wasmObjects[j].name
 	})
 	sort.Slice(valueObjects, func(i, j int) bool {
 		return valueObjects[i].name < valueObjects[j].name
 	})
 	sort.Strings(constants)

 	output := fmt.Sprintf(`/// <reference path="embind.d.ts" />
 /* This file is autogenerated using gen_types.go and make generate */
 declare namespace %s {
 	export interface Bindings {
 `, namespace)

 	for _, export := range privateModuleFunctions {
 		output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(export))
 	}
 	output += "\n"

 	for _, export := range publicModuleFunctions {
 		output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(export))
 	}
 	output += "\n"

 	for _, obj := range wasmObjects {
 		output += fmt.Sprintf("\t\treadonly %s: %sConstructor;\n", obj.name, obj.name)
 	}
 	output += "\n"

 	for _, c := range constants {
 		output += fmt.Sprintf("\t\t%s;\n", c)
 	}

 	output += "\t}\n\n"

 	// The constructors for all exposed objects.
 	for _, obj := range wasmObjects {
 		sort.Strings(obj.constructors)
 		output += fmt.Sprintf("\texport interface %sConstructor {\n", obj.name)
 		for _, c := range obj.constructors {
 			output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(c))
 		}
 		output += "\t}\n\n"
 	}
 	// The exposed objects themselves
 	for _, obj := range wasmObjects {
 		sort.Strings(obj.privateMethods)
 		sort.Strings(obj.publicMethods)
 		output += fmt.Sprintf("\texport interface %s extends embind.EmbindObject<%s> {\n", obj.name, obj.name)
 		for _, m := range obj.privateMethods {
 			output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(m))
 		}
 		if len(obj.privateMethods) > 0 {
 			output += "\n"
 		}
 		for _, m := range obj.publicMethods {
 			output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(m))
 		}
 		output += "\t}\n\n"
 	}

 	for _, obj := range valueObjects {
 		sort.Strings(obj.fields)
 		output += fmt.Sprintf("\texport interface %s {\n", obj.name)
 		for _, f := range obj.fields {
 			output += fmt.Sprintf("\t\t%s,\n", f)
 		}
 		output += "\t}\n\n"
 	}

 	output = strings.TrimSuffix(output, "\n")
 	output += "}\n"
 	return output, nil
 }

 func ensureSemicolon(js string) string {
 	if !strings.HasSuffix(js, ";") {
 		return js + ";"
 	}
 	return js
 }

 type wasmObject struct {
 	name           string
 	constructors   []string
 	publicMethods  []string
 	privateMethods []string
 }

 type valueObject struct {
 	name   string
 	fields []string
 }
	// Copyright 2021 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.

	package main

	import (
	"flag"
	"fmt"
	"io/ioutil"
	"path/filepath"
	"regexp"
	"sort"
	"strings"

	"go.skia.org/infra/go/skerr"
	"go.skia.org/infra/go/sklog"
	)

	func main() {
	inputCPPDir := flag.String("input_cpp_dir", "", "A folder containing .cpp binding files that make use of the TS_* macros")
	outputNamespaceDir := flag.String("output_namespace_dir", "", "The folder where the ambient namespace (.d.ts) files that correspond to the C++ API should be written")

	flag.Parse()
	if inputCPPDir == "" \|\| outputNamespaceDir == "" {
	sklog.Fatalf("--input_cpp_dir and --output_namespace_dir must be specified")
	}

	cppInputs, err := ioutil.ReadDir(*inputCPPDir)
	if err != nil {
	sklog.Fatalf("Could not read directory %s: %s", *inputCPPDir, err)
	}
	for _, file := range cppInputs {
	name := file.Name()
	if strings.HasSuffix(name, ".cpp") {
	fp := filepath.Join(*inputCPPDir, name)
	contents, err := ioutil.ReadFile(fp)
	if err != nil {
	sklog.Fatalf("Could not read file %s: %s", fp, err)
	}
	namespace := strings.TrimSuffix(name, ".cpp")
	output, err := generateAmbientNamespace(namespace, string(contents))
	if err != nil {
	sklog.Fatalf("Could not generate ambient namespace from %s: %s", fp, err)
	}
	fp = filepath.Join(*outputNamespaceDir, namespace+".d.ts")
	if err := ioutil.WriteFile(fp, []byte(output), 0666); err != nil {
	sklog.Fatalf("Could not write to %s: %s", fp, err)
	}
	}
	}
	}

	var (
	privateExportLine = regexp.MustCompile(`TS_PRIVATE_EXPORT\("(?P<export>.+)"\)`)
	publicExportLine = regexp.MustCompile(`TS_EXPORT\("(?P<export>.+)"\)`)
	classDefinitionStart = regexp.MustCompile(`class_<.+>\("(?P<name>.+)"\)`)
	classDefinitionEnd = regexp.MustCompile(`\.(function\|constructor).+;`)
	typeAnnotation = regexp.MustCompile(`@type\s+(?P<optional>@optional)?\s*(?P<type>\w+)`)
	valueObjectStart = regexp.MustCompile(`value_object<.+>\("(?P<name>.+)"\)`)
	valueObjectField = regexp.MustCompile(`.field\("(?P<name>.+?)",.+\);?`)
	constantDefinition = regexp.MustCompile(`constant\("(?P<name>.+?)",.+\);`)
	)

	// generateAmbientNamespace reads through the given file contents line by line. It looks for
	// explicit macro annotations (e.g. TS_EXPORT) and embind signatures (e.g. constant("foo", "bar").
	// From these, it generates the ambient namespace declarations and returns it as a string.
	// In general, it will put declarations in alphabetical order for deterministic ordering.
	func generateAmbientNamespace(namespace, contents string) (string, error) {
	var privateModuleFunctions []string
	var publicModuleFunctions []string
	var wasmObjects []*wasmObject
	var valueObjects []*valueObject
	var constants []string

	var currentWasmObject *wasmObject
	var currentValueObject *valueObject
	var lastTypeAnnotation string
	var lastTypeOptional bool
	lines := strings.Split(contents, "\n")
	for i, line := range lines {
	if match := classDefinitionStart.FindStringSubmatch(line); match != nil {
	currentWasmObject = &wasmObject{
	name: match[1],
	}
	wasmObjects = append(wasmObjects, currentWasmObject)
	}
	if classDefinitionEnd.MatchString(line) {
	currentWasmObject = nil
	}
	if match := privateExportLine.FindStringSubmatch(line); match != nil {
	export := match[1]
	if currentWasmObject == nil {
	privateModuleFunctions = append(privateModuleFunctions, export)
	} else {
	currentWasmObject.privateMethods = append(currentWasmObject.privateMethods, export)
	}
	}
	if match := publicExportLine.FindStringSubmatch(line); match != nil {
	export := match[1]
	if currentWasmObject == nil {
	publicModuleFunctions = append(publicModuleFunctions, export)
	} else {
	if strings.HasPrefix(export, "new") {
	currentWasmObject.constructors = append(currentWasmObject.constructors, export)
	} else {
	currentWasmObject.publicMethods = append(currentWasmObject.publicMethods, export)
	}
	}
	}
	if match := typeAnnotation.FindStringSubmatch(line); match != nil {
	lastTypeOptional = match[1] != ""
	lastTypeAnnotation = match[2]
	}
	if match := valueObjectStart.FindStringSubmatch(line); match != nil {
	currentValueObject = &valueObject{
	name: match[1],
	}
	valueObjects = append(valueObjects, currentValueObject)
	}
	if match := valueObjectField.FindStringSubmatch(line); match != nil {
	if currentValueObject == nil {
	// Should never happen for valid code - embind wouldn't compile with this.
	return "", skerr.Fmt("Line %d: Found a .field outside a value object declaration", i+1)
	}
	if lastTypeAnnotation == "" {
	return "", skerr.Fmt("Line %d: field %q must be preceded by a @type annotation", i+1, match[1])
	}
	fieldWithType := fmt.Sprintf("%s: %s", match[1], lastTypeAnnotation)
	if lastTypeOptional {
	fieldWithType = fmt.Sprintf("%s?: %s", match[1], lastTypeAnnotation)
	}
	currentValueObject.fields = append(currentValueObject.fields, fieldWithType)
	lastTypeAnnotation = "" // It's been consumed, so reset it
	lastTypeOptional = false
	if strings.HasSuffix(match[0], ";") {
	currentValueObject = nil // we've gotten to the end of our value object
	}
	}
	if match := constantDefinition.FindStringSubmatch(line); match != nil {
	if lastTypeAnnotation == "" {
	return "", skerr.Fmt("Line %d: constant %q must be preceded by a @type annotation", i+1, match[1])
	}
	constWithType := fmt.Sprintf("readonly %s: %s", match[1], lastTypeAnnotation)
	if lastTypeOptional {
	constWithType = fmt.Sprintf("readonly %s?: %s", match[1], lastTypeAnnotation)
	}
	constants = append(constants, constWithType)
	lastTypeAnnotation = "" // It's been consumed, so reset it
	lastTypeOptional = false
	}
	}

	sort.Strings(privateModuleFunctions)
	sort.Strings(publicModuleFunctions)
	sort.Slice(wasmObjects, func(i, j int) bool {
	return wasmObjects[i].name < wasmObjects[j].name
	})
	sort.Slice(valueObjects, func(i, j int) bool {
	return valueObjects[i].name < valueObjects[j].name
	})
	sort.Strings(constants)

	output := fmt.Sprintf(`/// <reference path="embind.d.ts" />
	/* This file is autogenerated using gen_types.go and make generate */
	declare namespace %s {
	export interface Bindings {
	`, namespace)

	for _, export := range privateModuleFunctions {
	output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(export))
	}
	output += "\n"

	for _, export := range publicModuleFunctions {
	output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(export))
	}
	output += "\n"

	for _, obj := range wasmObjects {
	output += fmt.Sprintf("\t\treadonly %s: %sConstructor;\n", obj.name, obj.name)
	}
	output += "\n"

	for _, c := range constants {
	output += fmt.Sprintf("\t\t%s;\n", c)
	}

	output += "\t}\n\n"

	// The constructors for all exposed objects.
	for _, obj := range wasmObjects {
	sort.Strings(obj.constructors)
	output += fmt.Sprintf("\texport interface %sConstructor {\n", obj.name)
	for _, c := range obj.constructors {
	output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(c))
	}
	output += "\t}\n\n"
	}
	// The exposed objects themselves
	for _, obj := range wasmObjects {
	sort.Strings(obj.privateMethods)
	sort.Strings(obj.publicMethods)
	output += fmt.Sprintf("\texport interface %s extends embind.EmbindObject<%s> {\n", obj.name, obj.name)
	for _, m := range obj.privateMethods {
	output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(m))
	}
	if len(obj.privateMethods) > 0 {
	output += "\n"
	}
	for _, m := range obj.publicMethods {
	output += fmt.Sprintf("\t\t%s\n", ensureSemicolon(m))
	}
	output += "\t}\n\n"
	}

	for _, obj := range valueObjects {
	sort.Strings(obj.fields)
	output += fmt.Sprintf("\texport interface %s {\n", obj.name)
	for _, f := range obj.fields {
	output += fmt.Sprintf("\t\t%s,\n", f)
	}
	output += "\t}\n\n"
	}

	output = strings.TrimSuffix(output, "\n")
	output += "}\n"
	return output, nil
	}

	func ensureSemicolon(js string) string {
	if !strings.HasSuffix(js, ";") {
	return js + ";"
	}
	return js
	}

	type wasmObject struct {
	name string
	constructors []string
	publicMethods []string
	privateMethods []string
	}

	type valueObject struct {
	name string
	fields []string
	}