You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by st...@apache.org on 2016/03/07 01:24:17 UTC

incubator-mynewt-newt git commit: add compilerinfo section

Repository: incubator-mynewt-newt
Updated Branches:
  refs/heads/rename_project_app 464ba3329 -> 1f9c494ef


add compilerinfo section


Project: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/commit/1f9c494e
Tree: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/tree/1f9c494e
Diff: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/diff/1f9c494e

Branch: refs/heads/rename_project_app
Commit: 1f9c494efed2f056e57edbfdcdd98420633cc70a
Parents: 464ba33
Author: Sterling Hughes <st...@apache.org>
Authored: Sun Mar 6 16:24:06 2016 -0800
Committer: Sterling Hughes <st...@apache.org>
Committed: Sun Mar 6 16:24:06 2016 -0800

----------------------------------------------------------------------
 newt/builder/build.go        | 29 ++++++++------
 newt/builder/buildpackage.go | 83 +++++++++++++++++++++++++++++++++------
 2 files changed, 90 insertions(+), 22 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/1f9c494e/newt/builder/build.go
----------------------------------------------------------------------
diff --git a/newt/builder/build.go b/newt/builder/build.go
index 89f77d3..057c28c 100644
--- a/newt/builder/build.go
+++ b/newt/builder/build.go
@@ -20,10 +20,9 @@
 package builder
 
 import (
-	"fmt"
-
 	"mynewt.apache.org/newt/newt/pkg"
 	"mynewt.apache.org/newt/newt/target"
+	"mynewt.apache.org/newt/util"
 )
 
 type Builder struct {
@@ -41,29 +40,29 @@ func (b *Builder) AddIdentity(identity string) {
 	b.identities[identity] = true
 }
 
-func (b *Builder) HasPackage(pkg *pkg.LocalPackage) bool {
+func (b *Builder) GetPackage(pkg *pkg.LocalPackage) (*BuildPackage, bool) {
 	if pkg == nil {
 		panic("Package should not equal NIL")
 	}
 
-	_, ok := b.Packages[pkg]
+	bpkg, ok := b.Packages[pkg]
 	if !ok {
-		return false
+		return nil, false
 	} else {
-		return true
+		return bpkg, true
 	}
 }
 
 func (b *Builder) AddPackage(pkg *pkg.LocalPackage) {
 	// Don't allow nil entries to the map
 	if pkg == nil {
-		return
+		panic("Cannot add nil package builder map")
 	}
 
 	b.Packages[pkg] = NewBuildPackage(pkg)
 }
 
-func (b *Builder) ResolvePackageDeps() error {
+func (b *Builder) LoadDeps() error {
 	for {
 		reprocess := false
 		for _, bpkg := range b.Packages {
@@ -90,14 +89,22 @@ func (b *Builder) Build() error {
 	b.AddPackage(b.target.App())
 	b.AddPackage(b.target.Compiler())
 
-	if err := b.ResolvePackageDeps(); err != nil {
+	if err := b.LoadDeps(); err != nil {
 		return err
 	}
 
-	for _, bpkg := range b.Packages {
-		fmt.Printf("Package %s being built\n", bpkg.Name())
+	bspPackage, ok := b.GetPackage(b.target.Bsp())
+	if !ok {
+		return util.NewNewtError("BSP package not found!")
 	}
 
+	baseCi := NewCompilerInfo()
+	baseCi.AddCompilerInfo(bspPackage.PackageCompilerInfo())
+
+	// Loop through all packages and build them
+
+	// Now, get the App, and link the application
+
 	return nil
 }
 

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/1f9c494e/newt/builder/buildpackage.go
----------------------------------------------------------------------
diff --git a/newt/builder/buildpackage.go b/newt/builder/buildpackage.go
index b26eff4..e35fcca 100644
--- a/newt/builder/buildpackage.go
+++ b/newt/builder/buildpackage.go
@@ -36,13 +36,73 @@ type CompilerInfo struct {
 type BuildPackage struct {
 	*pkg.LocalPackage
 
-	compilerInfo *CompilerInfo
-	isBsp        bool
+	pkgCi  *CompilerInfo
+	fullCi *CompilerInfo
+
+	isBsp bool
 
 	loaded bool
 }
 
-func (bpkg *BuildPackage) LoadIdentities(b *Builder) (map[string]bool, bool) {
+func (ci *CompilerInfo) AddCompilerInfo(newCi *CompilerInfo) {
+	ci.Includes = append(ci.Includes, newCi.Includes...)
+	ci.Cflags = append(ci.Cflags, newCi.Cflags...)
+	ci.Lflags = append(ci.Lflags, newCi.Lflags...)
+	ci.Aflags = append(ci.Aflags, newCi.Aflags...)
+}
+
+func NewCompilerInfo() *CompilerInfo {
+	ci := &CompilerInfo{}
+	ci.Includes = []string{}
+	ci.Cflags = []string{}
+	ci.Lflags = []string{}
+	ci.Aflags = []string{}
+
+	return ci
+}
+
+func (bpkg *BuildPackage) PackageCompilerInfo() *CompilerInfo {
+	return bpkg.pkgCi
+}
+
+func (bpkg *BuildPackage) FullCompilerInfo(b *Builder) (*CompilerInfo, error) {
+	if !bpkg.loaded {
+		return nil, util.NewNewtError("Package must be loaded before Compiler info is fetched")
+	}
+
+	if bpkg.fullCi != nil {
+		return bpkg.fullCi, nil
+	}
+
+	ci := NewCompilerInfo()
+	ci.AddCompilerInfo(bpkg.pkgCi)
+
+	// Go through every dependency, and add the compiler information for that
+	// dependency
+	for _, dep := range bpkg.Deps() {
+		pkg, err := project.GetProject().ResolveDependency(dep)
+		if err != nil {
+			return nil, err
+		}
+
+		if pkg == nil {
+			return nil, util.NewNewtError("Cannot resolve dep " + dep.String())
+		}
+
+		bpkg, ok := b.GetPackage(pkg)
+		if !ok {
+			return nil, util.NewNewtError("Unknown build info for package " + pkg.Name())
+		}
+
+		ci.AddCompilerInfo(bpkg.PackageCompilerInfo())
+	}
+
+	bpkg.fullCi = ci
+
+	return bpkg.fullCi, nil
+}
+
+func (bpkg *BuildPackage) loadIdentities(b *Builder) (map[string]bool, bool) {
 	idents := b.Identities()
 
 	foundNewIdent := false
@@ -63,7 +123,7 @@ func (bpkg *BuildPackage) LoadIdentities(b *Builder) (map[string]bool, bool) {
 	}
 }
 
-func (bpkg *BuildPackage) LoadDeps(b *Builder, idents map[string]bool) (bool, error) {
+func (bpkg *BuildPackage) loadDeps(b *Builder, idents map[string]bool) (bool, error) {
 	proj := project.GetProject()
 
 	foundNewDep := false
@@ -85,7 +145,8 @@ func (bpkg *BuildPackage) LoadDeps(b *Builder, idents map[string]bool) (bool, er
 				newDep.String())
 		}
 
-		if !b.HasPackage(pkg) {
+		_, ok := b.GetPackage(pkg)
+		if !ok {
 			foundNewDep = true
 			b.AddPackage(pkg)
 		}
@@ -105,8 +166,8 @@ func (bpkg *BuildPackage) Load(b *Builder) (bool, error) {
 
 	// Circularly resolve dependencies and identities until no more new
 	// dependencies or identities exist.
-	idents, newIdents := bpkg.LoadIdentities(b)
-	newDeps, err := bpkg.LoadDeps(b, idents)
+	idents, newIdents := bpkg.loadIdentities(b)
+	newDeps, err := bpkg.loadDeps(b, idents)
 	if err != nil {
 		return false, err
 	}
@@ -116,7 +177,7 @@ func (bpkg *BuildPackage) Load(b *Builder) (bool, error) {
 	}
 
 	// Now, load the rest of the package, this should happen only once.
-	apis := cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.apis")
+	apis := cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.caps")
 	for _, apiStr := range apis {
 		api, err := pkg.NewDependency(bpkg.Repo(), apiStr)
 		if err != nil {
@@ -125,7 +186,7 @@ func (bpkg *BuildPackage) Load(b *Builder) (bool, error) {
 		bpkg.AddApi(api)
 	}
 
-	reqApis := cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.req_apis")
+	reqApis := cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.req_caps")
 	for _, apiStr := range reqApis {
 		api, err := pkg.NewDependency(bpkg.Repo(), apiStr)
 		if err != nil {
@@ -134,13 +195,13 @@ func (bpkg *BuildPackage) Load(b *Builder) (bool, error) {
 		bpkg.AddReqApi(api)
 	}
 
-	ci := CompilerInfo{}
+	ci := NewCompilerInfo()
 	ci.Cflags = cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.cflags")
 	ci.Lflags = cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.lflags")
 	ci.Aflags = cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.aflags")
 	ci.Includes = cli.GetStringSliceIdentities(bpkg.Viper, idents, "pkg.includes")
 
-	bpkg.compilerInfo = &ci
+	bpkg.pkgCi = ci
 
 	bpkg.loaded = true