Added draft CLI interface with autocompletion

Author: RealA10N

transform/isa.go

@@ -0,0 +1,104 @@
+package transform
+
+import (
+	"strings"
+
+	"alon.kr/x/faststringmap"
+	"alon.kr/x/usm/gen"
+)
+
+type InstructionSet struct {
+	Name        string
+	Aliases     []string
+	Description string
+	Extensions  []string
+
+	GenerationContext gen.GenerationContext
+
+	Transformations TransformationCollection
+}
+
+type InstructionSetCollection struct {
+	InstructionSets      []*InstructionSet
+	NameToInstructionSet faststringmap.Map[*InstructionSet]
+}
+
+func NewIsaCollection(
+	instructionSets ...*InstructionSet,
+) *InstructionSetCollection {
+	entries := []faststringmap.MapEntry[*InstructionSet]{}
+	for _, set := range instructionSets {
+		entries = append(entries, faststringmap.MapEntry[*InstructionSet]{
+			Key:   set.Name,
+			Value: set,
+		})
+
+		for _, alias := range set.Aliases {
+			entries = append(entries, faststringmap.MapEntry[*InstructionSet]{
+				Key:   alias,
+				Value: set,
+			})
+		}
+	}
+
+	return &InstructionSetCollection{
+		InstructionSets:      instructionSets,
+		NameToInstructionSet: faststringmap.NewMap(entries),
+	}
+}
+
+func (c *InstructionSetCollection) TransformationNames() []string {
+	names := []string{}
+	for _, set := range c.InstructionSets {
+		names = append(names, set.Transformations.Names()...)
+	}
+	return names
+}
+
+func (c *InstructionSetCollection) Traverse(
+	start *InstructionSet,
+	transformations []string,
+) *InstructionSet {
+	isa := start
+	for _, transName := range transformations {
+		trans, ok := isa.Transformations.NameToTransformation.LookupString(transName)
+		if !ok {
+			return nil
+		}
+
+		isaName := trans.Target
+		isa, ok = c.NameToInstructionSet.LookupString(isaName)
+		if !ok {
+			return nil
+		}
+	}
+
+	return isa
+}
+
+// Infer the instruction set from the filename extension.
+// Returns nil if no matching instruction set is found.
+// If multiple instruction sets match the filename, the one that matches with
+// the longest prefix is returned.
+func (c *InstructionSetCollection) FilenameToInstructionSet(
+	filename string,
+) *InstructionSet {
+	// TODO: this can be implemented in linear time with, for example, a trie of
+	// reversed prefixes, and traversal of the filename from the end. (faststringmap)
+
+	longest := 0
+	var longestSet *InstructionSet
+
+	for _, set := range c.InstructionSets {
+		for _, ext := range set.Extensions {
+			if strings.HasSuffix(filename, ext) {
+				if len(ext) > longest {
+					longest = len(ext)
+					longestSet = set
+				}
+			}
+		}
+	}
+
+	return longestSet
+}

transform/transformation.go

@@ -0,0 +1,58 @@
+package transform
+
+import (
+	"alon.kr/x/faststringmap"
+	"alon.kr/x/usm/core"
+	"alon.kr/x/usm/gen"
+)
+
+type Transformation struct {
+	Name        string
+	Aliases     []string
+	Description string
+
+	// The name of the target ISA of this transformation.
+	Target string
+
+	// Transform takes a file in the input ISA, and returns a file in the
+	// output ISA.
+	//
+	// The transformation may modify, and possibly invalidate the input
+	// structure.
+	Transform func(*gen.FileInfo) (*gen.FileInfo, core.ResultList)
+}
+
+type TransformationCollection struct {
+	Transformations      []*Transformation
+	NameToTransformation faststringmap.Map[*Transformation]
+}
+
+func (c *TransformationCollection) Names() []string {
+	names := []string{}
+	for _, t := range c.Transformations {
+		names = append(names, t.Name)
+		names = append(names, t.Aliases...)
+	}
+	return names
+}
+
+func NewTransformationCollection(transformations ...*Transformation) *TransformationCollection {
+	entries := []faststringmap.MapEntry[*Transformation]{}
+	for _, t := range transformations {
+		entries = append(entries, faststringmap.MapEntry[*Transformation]{
+			Key:   t.Name,
+			Value: t,
+		})
+		for _, alias := range t.Aliases {
+			entries = append(entries, faststringmap.MapEntry[*Transformation]{
+				Key:   alias,
+				Value: t,
+			})
+		}
+	}
+
+	return &TransformationCollection{
+		Transformations:      transformations,
+		NameToTransformation: faststringmap.NewMap(entries),
+	}
+}