feat(cli): Re-engineer CLIs, split play & compile

Play depends on bridge and compile on compiler package. Before, the compiler depended on bridge, but we could not use the compiler to build the library, as the bridge depends on the library. Also, play can now start having slightly more options e.g. wav out etc.

compiler/compiler.go

@@ -12,70 +12,73 @@ import (
 	"github.com/vsariola/sointu"
 )
 
-//go:generate go run generate.go
-
 type Compiler struct {
-	Template        *template.Template
-	Amd64           bool
-	OS              string
-	DisableSections bool
+	Template *template.Template
+	OS       string
+	Arch     string
 }
 
 // New returns a new compiler using the default .asm templates
-func New() (*Compiler, error) {
+func New(os string, arch string) (*Compiler, error) {
 	_, myname, _, _ := runtime.Caller(0)
 	templateDir := filepath.Join(path.Dir(myname), "..", "templates")
-	compiler, err := NewFromTemplates(templateDir)
+	compiler, err := NewFromTemplates(os, arch, templateDir)
 	return compiler, err
 }
 
-func NewFromTemplates(directory string) (*Compiler, error) {
-	globPtrn := filepath.Join(directory, "*.*")
+func NewFromTemplates(os string, arch string, templateDirectory string) (*Compiler, error) {
+	globPtrn := filepath.Join(templateDirectory, "*.*")
 	tmpl, err := template.New("base").Funcs(sprig.TxtFuncMap()).ParseGlob(globPtrn)
 	if err != nil {
-		return nil, fmt.Errorf(`could not create template based on directory "%v": %v`, directory, err)
+		return nil, fmt.Errorf(`could not create template based on directory "%v": %v`, templateDirectory, err)
 	}
-	return &Compiler{Template: tmpl, Amd64: runtime.GOARCH == "amd64", OS: runtime.GOOS}, nil
-}
-
-func (com *Compiler) compile(templateName string, data interface{}) (string, error) {
-	result := bytes.NewBufferString("")
-	err := com.Template.ExecuteTemplate(result, templateName, data)
-	return result.String(), err
+	return &Compiler{Template: tmpl, OS: os, Arch: arch}, nil
 }
 
 func (com *Compiler) Library() (map[string]string, error) {
+	if com.Arch != "386" && com.Arch != "amd64" {
+		return nil, fmt.Errorf(`compiling as a library is supported only on 386 and amd64 architectures (targeted architecture was %v)`, com.Arch)
+	}
+	templates := []string{"library.asm", "library.h"}
 	features := AllFeatures{}
-	m := NewMacros(*com, features)
-	m.Library = true
-	asmCode, err := com.compile("library.asm", m)
-	if err != nil {
-		return nil, fmt.Errorf(`could not execute template "library.asm": %v`, err)
+	retmap := map[string]string{}
+	for _, templateName := range templates {
+		macros := NewMacros(*com, features)
+		macros.Library = true
+		populatedTemplate, extension, err := com.compile(templateName, macros)
+		if err != nil {
+			return nil, fmt.Errorf(`could not execute template "%v": %v`, templateName, err)
+		}
+		retmap[extension] = populatedTemplate
 	}
-
-	m = NewMacros(*com, features)
-	m.Library = true
-	header, err := com.compile("library.h", &m)
-	if err != nil {
-		return nil, fmt.Errorf(`could not execute template "library.h": %v`, err)
-	}
-	return map[string]string{"asm": asmCode, "h": header}, nil
+	return retmap, nil
 }
 
-func (com *Compiler) Player(song *sointu.Song, maxSamples int) (map[string]string, error) {
+func (com *Compiler) Song(song *sointu.Song) (map[string]string, error) {
+	if com.Arch != "386" && com.Arch != "amd64" {
+		return nil, fmt.Errorf(`compiling a song player is supported only on 386 and amd64 architectures (targeted architecture was %v)`, com.Arch)
+	}
+	templates := []string{"player.asm", "player.h"}
 	features := NecessaryFeaturesFor(song.Patch)
+	retmap := map[string]string{}
 	encodedPatch, err := Encode(&song.Patch, features)
 	if err != nil {
 		return nil, fmt.Errorf(`could not encode patch: %v`, err)
 	}
-	asmCode, err := com.compile("player.asm", NewPlayerMacros(*com, features, song, encodedPatch, maxSamples))
-	if err != nil {
-		return nil, fmt.Errorf(`could not execute template "player.asm": %v`, err)
+	for _, templateName := range templates {
+		macros := NewPlayerMacros(*com, features, song, encodedPatch)
+		populatedTemplate, extension, err := com.compile(templateName, macros)
+		if err != nil {
+			return nil, fmt.Errorf(`could not execute template "%v": %v`, templateName, err)
+		}
+		retmap[extension] = populatedTemplate
 	}
-
-	header, err := com.compile("player.h", NewPlayerMacros(*com, features, song, encodedPatch, maxSamples))
-	if err != nil {
-		return nil, fmt.Errorf(`could not execute template "player.h": %v`, err)
-	}
-	return map[string]string{"asm": asmCode, "h": header}, nil
+	return retmap, nil
+}
+
+func (com *Compiler) compile(templateName string, data interface{}) (string, string, error) {
+	result := bytes.NewBufferString("")
+	err := com.Template.ExecuteTemplate(result, templateName, data)
+	extension := filepath.Ext(templateName)
+	return result.String(), extension, err
 }