// BuildPkgs builds a list of packages
func (b *Builder) BuildPkgs(pkgs []string) []*lex8.Error {
for _, p := range pkgs {
if _, es := b.prepare(p); es != nil {
return es
}
}
g := &dagvis.Graph{b.deps}
g = g.Reverse()
m, err := dagvis.Layout(g)
if err != nil {
return lex8.SingleErr(err)
}
// TODO: save the package dep map
nodes := m.SortedNodes()
for _, node := range nodes {
if b.Verbose { // report progress
fmt.Println(node.Name)
}
pkg := b.pkgs[node.Name]
if pkg == nil {
panic("package not prepared")
}
pkg.deps = deps(node)
if es := b.build(pkg); es != nil {
return es
}
}
return nil
}
// BuildBareFunc builds a function body into an image.
func BuildBareFunc(f string, rc io.ReadCloser) ([]byte, []*lex8.Error) {
fn, es := parse.BareFunc(f, rc)
if es != nil {
return nil, es
}
// resolving pass
log := lex8.NewErrorList()
rfunc := resolveFunc(log, fn)
if es := log.Errs(); es != nil {
return nil, es
}
// building pass
b := newBuilder("main")
fobj := buildFunc(b, rfunc)
if es := b.Errs(); es != nil {
return nil, es
}
ret, e := link8.LinkBareFunc(fobj)
if e != nil {
return nil, lex8.SingleErr(e)
}
return ret, nil
}
// Build builds a package.
func (b *Builder) Build(p string) []*lex8.Error {
if !b.input.HasPkg(p) {
return lex8.SingleErr(fmt.Errorf(
"package %q not found", p,
))
}
return b.BuildPkgs([]string{p})
}
// Plan returns all the packages required for building the specified
// target packages.
func (b *Builder) Plan(pkgs []string) ([]string, []*lex8.Error) {
for _, p := range pkgs {
if pkg, es := prepare(b.context, p); es != nil {
return nil, es
} else if pkg.err != nil {
return nil, lex8.SingleErr(pkg.err)
}
}
g := &dagvis.Graph{b.deps}
g = g.Reverse()
ret, err := dagvis.TopoSort(g)
if err != nil {
return nil, lex8.SingleErr(err)
}
return ret, nil
}
func (bare bareFunc) Compile(pinfo *build8.PkgInfo, opts *build8.Options) (
pkg *build8.Package, es []*lex8.Error,
) {
// parsing
theFile, e := findTheFile(pinfo)
if e != nil {
return nil, lex8.SingleErr(e)
}
stmts, es := parse.Stmts(theFile.Path, theFile)
if es != nil {
return nil, es
}
// building
b := makeBuilder(pinfo)
if es = b.Errs(); es != nil {
return nil, es
}
if es := buildBareFunc(b, stmts); es != nil {
return nil, es
}
if es := b.Errs(); es != nil {
return nil, es
}
// logging
if e := logIr(pinfo, b); e != nil {
return nil, lex8.SingleErr(e)
}
// codegen
lib, errs := ir.BuildPkg(b.p)
if errs != nil {
return nil, errs
}
ret := &build8.Package{
Lang: "g8-barefunc",
Main: startName,
Lib: lib,
}
return ret, nil
}
func build(c *context, pkgs []string) []*lex8.Error {
for _, p := range pkgs {
if pkg, es := prepare(c, p); es != nil {
return es
} else if pkg.err != nil {
return lex8.SingleErr(pkg.err)
}
}
if c.RunTests {
for _, p := range pkgs {
c.pkgs[p].runTests = true
}
}
g := &dagvis.Graph{c.deps}
g = g.Reverse()
m, err := dagvis.Layout(g)
if err != nil {
return lex8.SingleErr(err)
}
if c.SaveDeps != nil {
c.SaveDeps(m)
}
nodes := m.SortedNodes()
for _, node := range nodes {
if c.Verbose { // report progress
logln(c, node.Name)
}
pkg := c.pkgs[node.Name]
pkg.deps = deps(node)
if es := buildPkg(c, pkg); es != nil {
return es
}
}
return nil
}
// BuildSingleFile builds a package named "main" from a single file.
func BuildSingleFile(f string, rc io.ReadCloser) ([]byte, []*lex8.Error) {
path := "_"
pinfo := build8.SimplePkg(path, f, rc)
pkg, errs := Lang().Compile(pinfo, new(build8.Options))
if errs != nil {
return nil, errs
}
secs, err := link8.LinkSinglePkg(pkg.Lib, pkg.Main)
if err != nil {
return nil, lex8.SingleErr(err)
}
buf := new(bytes.Buffer)
if err := e8.Write(buf, secs); err != nil {
return nil, lex8.SingleErr(err)
}
return buf.Bytes(), nil
}
func buildMainPkg(home *build8.MemHome) (
image []byte, errs []*lex8.Error, log []byte,
) {
b := build8.NewBuilder(home)
if errs := b.BuildAll(); errs != nil {
return nil, errs, nil
}
image = home.Bin("main")
log = home.Log("main", "ir")
if image == nil {
err := errors.New("missing main() function, no binary created")
return nil, lex8.SingleErr(err), log
}
return image, nil, log
}
// FileResult returns a parsing result.
func FileResult(f string, rc io.ReadCloser) (*Result, []*lex8.Error) {
p, rec := newParser(f, rc)
parsed := parseFile(p)
e := rc.Close()
if e != nil {
return nil, lex8.SingleErr(e)
}
if es := p.Errs(); es != nil {
return nil, es
}
res := &Result{
File: parsed,
Tokens: rec.Tokens(),
}
return res, nil
}
// File parses a file.
func File(f string, r io.Reader, golike bool) (
*ast.File, *lex8.Recorder, []*lex8.Error,
) {
bs, err := ioutil.ReadAll(r)
if err != nil {
return nil, nil, lex8.SingleErr(err)
}
es := textbox.CheckRect(f, bytes.NewReader(bs), MaxLine, MaxCol)
if es != nil {
return nil, nil, es
}
p, rec := makeParser(f, bytes.NewReader(bs), golike)
ret := parseFile(p)
if es := p.Errs(); es != nil {
return nil, nil, es
}
return ret, rec, nil
}
// BuildPkgs builds a list of packages
func (b *Builder) BuildPkgs(pkgs []string) []*lex8.Error {
for _, p := range pkgs {
if _, es := b.prepare(p); es != nil {
return es
}
}
if b.RunTests {
for _, p := range pkgs {
b.pkgs[p].runTests = true
}
}
g := &dagvis.Graph{b.deps}
g = g.Reverse()
m, err := dagvis.Layout(g)
if err != nil {
return lex8.SingleErr(err)
}
if b.SaveDeps != nil {
b.SaveDeps(m)
}
nodes := m.SortedNodes()
for _, node := range nodes {
if b.Verbose { // report progress
b.logln(node.Name)
}
pkg := b.pkgs[node.Name]
pkg.deps = deps(node)
if es := b.build(pkg); es != nil {
return es
}
}
return nil
}
func (l *lang) Compile(pinfo *build8.PkgInfo, opts *build8.Options) (
*build8.Package, []*lex8.Error,
) {
// parsing
asts, es := l.parsePkg(pinfo)
if es != nil {
return nil, es
}
// building
b := makeBuilder(pinfo)
if es = b.Errs(); es != nil {
return nil, es
}
p := newPkg(asts)
if es := p.build(b, pinfo); es != nil {
return nil, es
}
g := p.deps
g, err := g.Rename(func(name string) (string, error) {
if strings.HasSuffix(name, ".g") {
return strings.TrimSuffix(name, ".g"), nil
}
return name, fmt.Errorf("filename suffix missing: %q", name)
})
if err != nil {
return nil, lex8.SingleErr(err)
}
if err := logDeps(pinfo, g); err != nil {
return nil, lex8.SingleErr(err)
}
bs, err := dagvis.LayoutJSON(g.Reverse())
if err != nil {
return nil, lex8.SingleErr(err)
}
if err := logDepMap(pinfo, bs); err != nil {
return nil, lex8.SingleErr(err)
}
// codegen
lib, errs := ir.BuildPkg(b.p)
if errs != nil {
return nil, errs
}
// add debug symbols
ir.AddDebug(b.p, pinfo.AddFuncDebug)
// IR logging
if err := logIr(pinfo, b); err != nil {
return nil, lex8.SingleErr(err)
}
tests := make(map[string]uint32)
for i, name := range p.testNames {
tests[name] = uint32(i)
}
ret := &build8.Package{
Lang: "g8",
Init: initName,
Main: startName,
TestMain: testStartName,
Tests: tests,
Lib: lib,
Symbols: p.tops,
}
return ret, nil
}
