Pass types.Context down into compilation helpers

matthijskooijman · matthijskooijman · commit 108e65f0fe62 · 2018-05-28T16:15:06.000+02:00
Previously, the verbose, logger and sometimes warningFlags were
extracted from the Context by the top-level runner and passed down
separately. Since this causes a lot of variable-passing of what is
essentially global state, it is clearer to just pass a types.Context
down and let the helpers get the data they need from that state.

This prepared for a next commit where ExecRecipe will be refactored and
needs access to the Context. Since the next commit will heavily change
ExecRecipe anyway, this commit does not actually change ExecRecipe to
accept the Context.

This commit should not change any behaviour.

Signed-off-by: Matthijs Kooijman &lt;matthijs@stdin.nl&gt;
diff --git a/builder_utils/utils.go b/builder_utils/utils.go
@@ -40,12 +40,13 @@ import (
 
 	"github.com/arduino/arduino-builder/constants"
 	"github.com/arduino/arduino-builder/i18n"
+	"github.com/arduino/arduino-builder/types"
 	"github.com/arduino/arduino-builder/utils"
 	"github.com/arduino/go-properties-map"
 )
 
-func CompileFilesRecursive(objectFiles []string, sourcePath string, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {
-	objectFiles, err := CompileFiles(objectFiles, sourcePath, false, buildPath, buildProperties, includes, verbose, warningsLevel, logger)
+func CompileFilesRecursive(ctx *types.Context, objectFiles []string, sourcePath string, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {
+	objectFiles, err := CompileFiles(ctx, objectFiles, sourcePath, false, buildPath, buildProperties, includes)
 	if err != nil {
 		return nil, i18n.WrapError(err)
 	}
@@ -56,7 +57,7 @@ func CompileFilesRecursive(objectFiles []string, sourcePath string, buildPath st
 	}
 
 	for _, folder := range folders {
-		objectFiles, err = CompileFilesRecursive(objectFiles, filepath.Join(sourcePath, folder.Name()), filepath.Join(buildPath, folder.Name()), buildProperties, includes, verbose, warningsLevel, logger)
+		objectFiles, err = CompileFilesRecursive(ctx, objectFiles, filepath.Join(sourcePath, folder.Name()), filepath.Join(buildPath, folder.Name()), buildProperties, includes)
 		if err != nil {
 			return nil, i18n.WrapError(err)
 		}
@@ -65,28 +66,28 @@ func CompileFilesRecursive(objectFiles []string, sourcePath string, buildPath st
 	return objectFiles, nil
 }
 
-func CompileFiles(objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {
-	objectFiles, err := compileFilesWithExtensionWithRecipe(objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".S", constants.RECIPE_S_PATTERN, verbose, warningsLevel, logger)
+func CompileFiles(ctx *types.Context, objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {
+	objectFiles, err := compileFilesWithExtensionWithRecipe(ctx, objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".S", constants.RECIPE_S_PATTERN)
 	if err != nil {
 		return nil, i18n.WrapError(err)
 	}
-	objectFiles, err = compileFilesWithExtensionWithRecipe(objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".c", constants.RECIPE_C_PATTERN, verbose, warningsLevel, logger)
+	objectFiles, err = compileFilesWithExtensionWithRecipe(ctx, objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".c", constants.RECIPE_C_PATTERN)
 	if err != nil {
 		return nil, i18n.WrapError(err)
 	}
-	objectFiles, err = compileFilesWithExtensionWithRecipe(objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".cpp", constants.RECIPE_CPP_PATTERN, verbose, warningsLevel, logger)
+	objectFiles, err = compileFilesWithExtensionWithRecipe(ctx, objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".cpp", constants.RECIPE_CPP_PATTERN)
 	if err != nil {
 		return nil, i18n.WrapError(err)
 	}
 	return objectFiles, nil
 }
 
-func compileFilesWithExtensionWithRecipe(objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string, extension string, recipe string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {
+func compileFilesWithExtensionWithRecipe(ctx *types.Context, objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string, extension string, recipe string) ([]string, error) {
 	sources, err := findFilesInFolder(sourcePath, extension, recurse)
 	if err != nil {
 		return nil, i18n.WrapError(err)
 	}
-	return compileFilesWithRecipe(objectFiles, sourcePath, sources, buildPath, buildProperties, includes, recipe, verbose, warningsLevel, logger)
+	return compileFilesWithRecipe(ctx, objectFiles, sourcePath, sources, buildPath, buildProperties, includes, recipe)
 }
 
 func findFilesInFolder(sourcePath string, extension string, recurse bool) ([]string, error) {
@@ -145,9 +146,9 @@ func findAllFilesInFolder(sourcePath string, recurse bool) ([]string, error) {
 	return sources, nil
 }
 
-func compileFilesWithRecipe(objectFiles []string, sourcePath string, sources []string, buildPath string, buildProperties properties.Map, includes []string, recipe string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {
+func compileFilesWithRecipe(ctx *types.Context, objectFiles []string, sourcePath string, sources []string, buildPath string, buildProperties properties.Map, includes []string, recipe string) ([]string, error) {
 	for _, source := range sources {
-		objectFile, err := compileFileWithRecipe(sourcePath, source, buildPath, buildProperties, includes, recipe, verbose, warningsLevel, logger)
+		objectFile, err := compileFileWithRecipe(ctx, sourcePath, source, buildPath, buildProperties, includes, recipe)
 		if err != nil {
 			return nil, i18n.WrapError(err)
 		}
@@ -157,9 +158,10 @@ func compileFilesWithRecipe(objectFiles []string, sourcePath string, sources []s
 	return objectFiles, nil
 }
 
-func compileFileWithRecipe(sourcePath string, source string, buildPath string, buildProperties properties.Map, includes []string, recipe string, verbose bool, warningsLevel string, logger i18n.Logger) (string, error) {
+func compileFileWithRecipe(ctx *types.Context, sourcePath string, source string, buildPath string, buildProperties properties.Map, includes []string, recipe string) (string, error) {
+	logger := ctx.GetLogger()
 	properties := buildProperties.Clone()
-	properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+warningsLevel]
+	properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+ctx.WarningsLevel]
 	properties[constants.BUILD_PROPERTIES_INCLUDES] = strings.Join(includes, constants.SPACE)
 	properties[constants.BUILD_PROPERTIES_SOURCE_FILE] = source
 	relativeSource, err := filepath.Rel(sourcePath, source)
@@ -179,11 +181,11 @@ func compileFileWithRecipe(sourcePath string, source string, buildPath string, b
 	}
 
 	if !objIsUpToDate {
-		_, err = ExecRecipe(properties, recipe, false, verbose, verbose, logger)
+		_, err = ExecRecipe(properties, recipe, false, ctx.Verbose, ctx.Verbose, logger)
 		if err != nil {
 			return "", i18n.WrapError(err)
 		}
-	} else if verbose {
+	} else if ctx.Verbose {
 		logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_PREVIOUS_COMPILED_FILE, properties[constants.BUILD_PROPERTIES_OBJECT_FILE])
 	}
 
@@ -309,7 +311,8 @@ func CoreOrReferencedCoreHasChanged(corePath, targetCorePath, targetFile string)
 	return true
 }
 
-func ArchiveCompiledFiles(buildPath string, archiveFile string, objectFiles []string, buildProperties properties.Map, verbose bool, logger i18n.Logger) (string, error) {
+func ArchiveCompiledFiles(ctx *types.Context, buildPath string, archiveFile string, objectFiles []string, buildProperties properties.Map) (string, error) {
+	logger := ctx.GetLogger()
 	archiveFilePath := filepath.Join(buildPath, archiveFile)
 
 	rebuildArchive := false
@@ -332,7 +335,7 @@ func ArchiveCompiledFiles(buildPath string, archiveFile string, objectFiles []st
 				return "", i18n.WrapError(err)
 			}
 		} else {
-			if verbose {
+			if ctx.Verbose {
 				logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_PREVIOUS_COMPILED_FILE, archiveFilePath)
 			}
 			return archiveFilePath, nil
@@ -345,7 +348,7 @@ func ArchiveCompiledFiles(buildPath string, archiveFile string, objectFiles []st
 		properties[constants.BUILD_PROPERTIES_ARCHIVE_FILE_PATH] = archiveFilePath
 		properties[constants.BUILD_PROPERTIES_OBJECT_FILE] = objectFile
 
-		_, err := ExecRecipe(properties, constants.RECIPE_AR_PATTERN, false, verbose, verbose, logger)
+		_, err := ExecRecipe(properties, constants.RECIPE_AR_PATTERN, false, ctx.Verbose, ctx.Verbose, logger)
 		if err != nil {
 			return "", i18n.WrapError(err)
 		}
diff --git a/phases/core_builder.go b/phases/core_builder.go
@@ -46,9 +46,6 @@ func (s *CoreBuilder) Run(ctx *types.Context) error {
 	coreBuildPath := ctx.CoreBuildPath
 	coreBuildCachePath := ctx.CoreBuildCachePath
 	buildProperties := ctx.BuildProperties
-	verbose := ctx.Verbose
-	warningsLevel := ctx.WarningsLevel
-	logger := ctx.GetLogger()
 
 	err := utils.EnsureFolderExists(coreBuildPath)
 	if err != nil {
@@ -62,7 +59,7 @@ func (s *CoreBuilder) Run(ctx *types.Context) error {
 		}
 	}
 
-	archiveFile, objectFiles, err := compileCore(coreBuildPath, coreBuildCachePath, buildProperties, verbose, warningsLevel, logger)
+	archiveFile, objectFiles, err := compileCore(ctx, coreBuildPath, coreBuildCachePath, buildProperties)
 	if err != nil {
 		return i18n.WrapError(err)
 	}
@@ -73,7 +70,8 @@ func (s *CoreBuilder) Run(ctx *types.Context) error {
 	return nil
 }
 
-func compileCore(buildPath string, buildCachePath string, buildProperties properties.Map, verbose bool, warningsLevel string, logger i18n.Logger) (string, []string, error) {
+func compileCore(ctx *types.Context, buildPath string, buildCachePath string, buildProperties properties.Map) (string, []string, error) {
+	logger := ctx.GetLogger()
 	coreFolder := buildProperties[constants.BUILD_PROPERTIES_BUILD_CORE_PATH]
 	variantFolder := buildProperties[constants.BUILD_PROPERTIES_BUILD_VARIANT_PATH]
 
@@ -90,7 +88,7 @@ func compileCore(buildPath string, buildCachePath string, buildProperties proper
 
 	variantObjectFiles := []string{}
 	if variantFolder != constants.EMPTY_STRING {
-		variantObjectFiles, err = builder_utils.CompileFiles(variantObjectFiles, variantFolder, true, buildPath, buildProperties, includes, verbose, warningsLevel, logger)
+		variantObjectFiles, err = builder_utils.CompileFiles(ctx, variantObjectFiles, variantFolder, true, buildPath, buildProperties, includes)
 		if err != nil {
 			return "", nil, i18n.WrapError(err)
 		}
@@ -107,26 +105,26 @@ func compileCore(buildPath string, buildCachePath string, buildProperties proper
 
 		if canUseArchivedCore {
 			// use archived core
-			if verbose {
+			if ctx.Verbose {
 				logger.Println(constants.LOG_LEVEL_INFO, "Using precompiled core: {0}", targetArchivedCore)
 			}
 			return targetArchivedCore, variantObjectFiles, nil
 		}
 	}
 
-	coreObjectFiles, err := builder_utils.CompileFiles([]string{}, coreFolder, true, buildPath, buildProperties, includes, verbose, warningsLevel, logger)
+	coreObjectFiles, err := builder_utils.CompileFiles(ctx, []string{}, coreFolder, true, buildPath, buildProperties, includes)
 	if err != nil {
 		return "", nil, i18n.WrapError(err)
 	}
 
-	archiveFile, err := builder_utils.ArchiveCompiledFiles(buildPath, "core.a", coreObjectFiles, buildProperties, verbose, logger)
+	archiveFile, err := builder_utils.ArchiveCompiledFiles(ctx, buildPath, "core.a", coreObjectFiles, buildProperties)
 	if err != nil {
 		return "", nil, i18n.WrapError(err)
 	}
 
 	// archive core.a
 	if targetArchivedCore != "" {
-		if verbose {
+		if ctx.Verbose {
 			logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_ARCHIVING_CORE_CACHE, targetArchivedCore)
 		}
 		builder_utils.CopyFile(archiveFile, targetArchivedCore)
diff --git a/phases/libraries_builder.go b/phases/libraries_builder.go
@@ -52,16 +52,13 @@ func (s *LibrariesBuilder) Run(ctx *types.Context) error {
 	includes := ctx.IncludeFolders
 	includes = utils.Map(includes, utils.WrapWithHyphenI)
 	libraries := ctx.ImportedLibraries
-	verbose := ctx.Verbose
-	warningsLevel := ctx.WarningsLevel
-	logger := ctx.GetLogger()
 
 	err := utils.EnsureFolderExists(librariesBuildPath)
 	if err != nil {
 		return i18n.WrapError(err)
 	}
 
-	objectFiles, err := compileLibraries(libraries, librariesBuildPath, buildProperties, includes, verbose, warningsLevel, logger)
+	objectFiles, err := compileLibraries(ctx, libraries, librariesBuildPath, buildProperties, includes)
 	if err != nil {
 		return i18n.WrapError(err)
 	}
@@ -99,10 +96,10 @@ func fixLDFLAGforPrecompiledLibraries(ctx *types.Context, libraries []*types.Lib
 	return nil
 }
 
-func compileLibraries(libraries []*types.Library, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {
+func compileLibraries(ctx *types.Context, libraries []*types.Library, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {
 	objectFiles := []string{}
 	for _, library := range libraries {
-		libraryObjectFiles, err := compileLibrary(library, buildPath, buildProperties, includes, verbose, warningsLevel, logger)
+		libraryObjectFiles, err := compileLibrary(ctx, library, buildPath, buildProperties, includes)
 		if err != nil {
 			return nil, i18n.WrapError(err)
 		}
@@ -113,8 +110,9 @@ func compileLibraries(libraries []*types.Library, buildPath string, buildPropert
 
 }
 
-func compileLibrary(library *types.Library, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {
-	if verbose {
+func compileLibrary(ctx *types.Context, library *types.Library, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {
+	logger := ctx.GetLogger()
+	if ctx.Verbose {
 		logger.Println(constants.LOG_LEVEL_INFO, "Compiling library \"{0}\"", library.Name)
 	}
 	libraryBuildPath := filepath.Join(buildPath, library.Name)
@@ -144,12 +142,12 @@ func compileLibrary(library *types.Library, buildPath string, buildProperties pr
 	}
 
 	if library.Layout == types.LIBRARY_RECURSIVE {
-		objectFiles, err = builder_utils.CompileFilesRecursive(objectFiles, library.SrcFolder, libraryBuildPath, buildProperties, includes, verbose, warningsLevel, logger)
+		objectFiles, err = builder_utils.CompileFilesRecursive(ctx, objectFiles, library.SrcFolder, libraryBuildPath, buildProperties, includes)
 		if err != nil {
 			return nil, i18n.WrapError(err)
 		}
 		if library.DotALinkage {
-			archiveFile, err := builder_utils.ArchiveCompiledFiles(libraryBuildPath, library.Name+".a", objectFiles, buildProperties, verbose, logger)
+			archiveFile, err := builder_utils.ArchiveCompiledFiles(ctx, libraryBuildPath, library.Name+".a", objectFiles, buildProperties)
 			if err != nil {
 				return nil, i18n.WrapError(err)
 			}
@@ -159,14 +157,14 @@ func compileLibrary(library *types.Library, buildPath string, buildProperties pr
 		if library.UtilityFolder != "" {
 			includes = append(includes, utils.WrapWithHyphenI(library.UtilityFolder))
 		}
-		objectFiles, err = builder_utils.CompileFiles(objectFiles, library.SrcFolder, false, libraryBuildPath, buildProperties, includes, verbose, warningsLevel, logger)
+		objectFiles, err = builder_utils.CompileFiles(ctx, objectFiles, library.SrcFolder, false, libraryBuildPath, buildProperties, includes)
 		if err != nil {
 			return nil, i18n.WrapError(err)
 		}
 
 		if library.UtilityFolder != "" {
 			utilityBuildPath := filepath.Join(libraryBuildPath, constants.LIBRARY_FOLDER_UTILITY)
-			objectFiles, err = builder_utils.CompileFiles(objectFiles, library.UtilityFolder, false, utilityBuildPath, buildProperties, includes, verbose, warningsLevel, logger)
+			objectFiles, err = builder_utils.CompileFiles(ctx, objectFiles, library.UtilityFolder, false, utilityBuildPath, buildProperties, includes)
 			if err != nil {
 				return nil, i18n.WrapError(err)
 			}
diff --git a/phases/linker.go b/phases/linker.go
@@ -61,32 +61,29 @@ func (s *Linker) Run(ctx *types.Context) error {
 	}
 
 	buildProperties := ctx.BuildProperties
-	verbose := ctx.Verbose
-	warningsLevel := ctx.WarningsLevel
-	logger := ctx.GetLogger()
 
-	err = link(objectFiles, coreDotARelPath, coreArchiveFilePath, buildProperties, verbose, warningsLevel, logger)
+	err = link(ctx, objectFiles, coreDotARelPath, coreArchiveFilePath, buildProperties)
 	if err != nil {
 		return i18n.WrapError(err)
 	}
 
 	return nil
 }
 
-func link(objectFiles []string, coreDotARelPath string, coreArchiveFilePath string, buildProperties properties.Map, verbose bool, warningsLevel string, logger i18n.Logger) error {
+func link(ctx *types.Context, objectFiles []string, coreDotARelPath string, coreArchiveFilePath string, buildProperties properties.Map) error {
 	optRelax := addRelaxTrickIfATMEGA2560(buildProperties)
 
 	objectFiles = utils.Map(objectFiles, wrapWithDoubleQuotes)
 	objectFileList := strings.Join(objectFiles, constants.SPACE)
 
 	properties := buildProperties.Clone()
 	properties[constants.BUILD_PROPERTIES_COMPILER_C_ELF_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_C_ELF_FLAGS] + optRelax
-	properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+warningsLevel]
+	properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+ctx.WarningsLevel]
 	properties[constants.BUILD_PROPERTIES_ARCHIVE_FILE] = coreDotARelPath
 	properties[constants.BUILD_PROPERTIES_ARCHIVE_FILE_PATH] = coreArchiveFilePath
 	properties[constants.BUILD_PROPERTIES_OBJECT_FILES] = objectFileList
 
-	_, err := builder_utils.ExecRecipe(properties, constants.RECIPE_C_COMBINE_PATTERN, false, verbose, verbose, logger)
+	_, err := builder_utils.ExecRecipe(properties, constants.RECIPE_C_COMBINE_PATTERN, false, ctx.Verbose, ctx.Verbose, ctx.GetLogger())
 	return err
 }
 
diff --git a/phases/sizer.go b/phases/sizer.go
@@ -52,22 +52,20 @@ func (s *Sizer) Run(ctx *types.Context) error {
 	}
 
 	buildProperties := ctx.BuildProperties
-	verbose := ctx.Verbose
-	warningsLevel := ctx.WarningsLevel
-	logger := ctx.GetLogger()
 
-	err := checkSize(buildProperties, verbose, warningsLevel, logger)
+	err := checkSize(ctx, buildProperties)
 	if err != nil {
 		return i18n.WrapError(err)
 	}
 
 	return nil
 }
 
-func checkSize(buildProperties properties.Map, verbose bool, warningsLevel string, logger i18n.Logger) error {
+func checkSize(ctx *types.Context, buildProperties properties.Map) error {
+	logger := ctx.GetLogger()
 
 	properties := buildProperties.Clone()
-	properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+warningsLevel]
+	properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+ctx.WarningsLevel]
 
 	maxTextSizeString := properties[constants.PROPERTY_UPLOAD_MAX_SIZE]
 	maxDataSizeString := properties[constants.PROPERTY_UPLOAD_MAX_DATA_SIZE]
@@ -89,7 +87,7 @@ func checkSize(buildProperties properties.Map, verbose bool, warningsLevel strin
 		}
 	}
 
-	textSize, dataSize, _, err := execSizeRecipe(properties, logger)
+	textSize, dataSize, _, err := execSizeRecipe(ctx, properties)
 	if err != nil {
 		logger.Println(constants.LOG_LEVEL_WARN, constants.MSG_SIZER_ERROR_NO_RULE)
 		return nil
@@ -127,8 +125,8 @@ func checkSize(buildProperties properties.Map, verbose bool, warningsLevel strin
 	return nil
 }
 
-func execSizeRecipe(properties properties.Map, logger i18n.Logger) (textSize int, dataSize int, eepromSize int, resErr error) {
-	out, err := builder_utils.ExecRecipe(properties, constants.RECIPE_SIZE_PATTERN, false, false, false, logger)
+func execSizeRecipe(ctx *types.Context, properties properties.Map) (textSize int, dataSize int, eepromSize int, resErr error) {
+	out, err := builder_utils.ExecRecipe(properties, constants.RECIPE_SIZE_PATTERN, false, false, false, ctx.GetLogger())
 	if err != nil {
 		resErr = errors.New("Error while determining sketch size: " + err.Error())
 		return
diff --git a/phases/sketch_builder.go b/phases/sketch_builder.go

Original file line number	Diff line number	Diff line change
`@@ -40,12 +40,13 @@ import (`
`40`	`40`
`41`	`41`	`"github.com/arduino/arduino-builder/constants"`
`42`	`42`	`"github.com/arduino/arduino-builder/i18n"`
	`43`	`+ "github.com/arduino/arduino-builder/types"`
`43`	`44`	`"github.com/arduino/arduino-builder/utils"`
`44`	`45`	`"github.com/arduino/go-properties-map"`
`45`	`46`	`)`
`46`	`47`
`47`		`-func CompileFilesRecursive(objectFiles []string, sourcePath string, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {`
`48`		`- objectFiles, err := CompileFiles(objectFiles, sourcePath, false, buildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`48`	`+func CompileFilesRecursive(ctx *types.Context, objectFiles []string, sourcePath string, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {`
	`49`	`+ objectFiles, err := CompileFiles(ctx, objectFiles, sourcePath, false, buildPath, buildProperties, includes)`
`49`	`50`	`if err != nil {`
`50`	`51`	`return nil, i18n.WrapError(err)`
`51`	`52`	`}`
`@@ -56,7 +57,7 @@ func CompileFilesRecursive(objectFiles []string, sourcePath string, buildPath st`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`for _, folder := range folders {`
`59`		`- objectFiles, err = CompileFilesRecursive(objectFiles, filepath.Join(sourcePath, folder.Name()), filepath.Join(buildPath, folder.Name()), buildProperties, includes, verbose, warningsLevel, logger)`
	`60`	`+ objectFiles, err = CompileFilesRecursive(ctx, objectFiles, filepath.Join(sourcePath, folder.Name()), filepath.Join(buildPath, folder.Name()), buildProperties, includes)`
`60`	`61`	`if err != nil {`
`61`	`62`	`return nil, i18n.WrapError(err)`
`62`	`63`	`}`
`@@ -65,28 +66,28 @@ func CompileFilesRecursive(objectFiles []string, sourcePath string, buildPath st`
`65`	`66`	`return objectFiles, nil`
`66`	`67`	`}`
`67`	`68`
`68`		`-func CompileFiles(objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {`
`69`		`- objectFiles, err := compileFilesWithExtensionWithRecipe(objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".S", constants.RECIPE_S_PATTERN, verbose, warningsLevel, logger)`
	`69`	`+func CompileFiles(ctx *types.Context, objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {`
	`70`	`+ objectFiles, err := compileFilesWithExtensionWithRecipe(ctx, objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".S", constants.RECIPE_S_PATTERN)`
`70`	`71`	`if err != nil {`
`71`	`72`	`return nil, i18n.WrapError(err)`
`72`	`73`	`}`
`73`		`- objectFiles, err = compileFilesWithExtensionWithRecipe(objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".c", constants.RECIPE_C_PATTERN, verbose, warningsLevel, logger)`
	`74`	`+ objectFiles, err = compileFilesWithExtensionWithRecipe(ctx, objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".c", constants.RECIPE_C_PATTERN)`
`74`	`75`	`if err != nil {`
`75`	`76`	`return nil, i18n.WrapError(err)`
`76`	`77`	`}`
`77`		`- objectFiles, err = compileFilesWithExtensionWithRecipe(objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".cpp", constants.RECIPE_CPP_PATTERN, verbose, warningsLevel, logger)`
	`78`	`+ objectFiles, err = compileFilesWithExtensionWithRecipe(ctx, objectFiles, sourcePath, recurse, buildPath, buildProperties, includes, ".cpp", constants.RECIPE_CPP_PATTERN)`
`78`	`79`	`if err != nil {`
`79`	`80`	`return nil, i18n.WrapError(err)`
`80`	`81`	`}`
`81`	`82`	`return objectFiles, nil`
`82`	`83`	`}`
`83`	`84`
`84`		`-func compileFilesWithExtensionWithRecipe(objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string, extension string, recipe string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {`
	`85`	`+func compileFilesWithExtensionWithRecipe(ctx *types.Context, objectFiles []string, sourcePath string, recurse bool, buildPath string, buildProperties properties.Map, includes []string, extension string, recipe string) ([]string, error) {`
`85`	`86`	`sources, err := findFilesInFolder(sourcePath, extension, recurse)`
`86`	`87`	`if err != nil {`
`87`	`88`	`return nil, i18n.WrapError(err)`
`88`	`89`	`}`
`89`		`- return compileFilesWithRecipe(objectFiles, sourcePath, sources, buildPath, buildProperties, includes, recipe, verbose, warningsLevel, logger)`
	`90`	`+ return compileFilesWithRecipe(ctx, objectFiles, sourcePath, sources, buildPath, buildProperties, includes, recipe)`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`func findFilesInFolder(sourcePath string, extension string, recurse bool) ([]string, error) {`
`@@ -145,9 +146,9 @@ func findAllFilesInFolder(sourcePath string, recurse bool) ([]string, error) {`
`145`	`146`	`return sources, nil`
`146`	`147`	`}`
`147`	`148`
`148`		`-func compileFilesWithRecipe(objectFiles []string, sourcePath string, sources []string, buildPath string, buildProperties properties.Map, includes []string, recipe string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {`
	`149`	`+func compileFilesWithRecipe(ctx *types.Context, objectFiles []string, sourcePath string, sources []string, buildPath string, buildProperties properties.Map, includes []string, recipe string) ([]string, error) {`
`149`	`150`	`for _, source := range sources {`
`150`		`- objectFile, err := compileFileWithRecipe(sourcePath, source, buildPath, buildProperties, includes, recipe, verbose, warningsLevel, logger)`
	`151`	`+ objectFile, err := compileFileWithRecipe(ctx, sourcePath, source, buildPath, buildProperties, includes, recipe)`
`151`	`152`	`if err != nil {`
`152`	`153`	`return nil, i18n.WrapError(err)`
`153`	`154`	`}`
`@@ -157,9 +158,10 @@ func compileFilesWithRecipe(objectFiles []string, sourcePath string, sources []s`
`157`	`158`	`return objectFiles, nil`
`158`	`159`	`}`
`159`	`160`
`160`		`-func compileFileWithRecipe(sourcePath string, source string, buildPath string, buildProperties properties.Map, includes []string, recipe string, verbose bool, warningsLevel string, logger i18n.Logger) (string, error) {`
	`161`	`+func compileFileWithRecipe(ctx *types.Context, sourcePath string, source string, buildPath string, buildProperties properties.Map, includes []string, recipe string) (string, error) {`
	`162`	`+ logger := ctx.GetLogger()`
`161`	`163`	`properties := buildProperties.Clone()`
`162`		`- properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+warningsLevel]`
	`164`	`+ properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS] = properties[constants.BUILD_PROPERTIES_COMPILER_WARNING_FLAGS+"."+ctx.WarningsLevel]`
`163`	`165`	`properties[constants.BUILD_PROPERTIES_INCLUDES] = strings.Join(includes, constants.SPACE)`
`164`	`166`	`properties[constants.BUILD_PROPERTIES_SOURCE_FILE] = source`
`165`	`167`	`relativeSource, err := filepath.Rel(sourcePath, source)`
`@@ -179,11 +181,11 @@ func compileFileWithRecipe(sourcePath string, source string, buildPath string, b`
`179`	`181`	`}`
`180`	`182`
`181`	`183`	`if !objIsUpToDate {`
`182`		`- _, err = ExecRecipe(properties, recipe, false, verbose, verbose, logger)`
	`184`	`+ _, err = ExecRecipe(properties, recipe, false, ctx.Verbose, ctx.Verbose, logger)`
`183`	`185`	`if err != nil {`
`184`	`186`	`return "", i18n.WrapError(err)`
`185`	`187`	`}`
`186`		`- } else if verbose {`
	`188`	`+ } else if ctx.Verbose {`
`187`	`189`	`logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_PREVIOUS_COMPILED_FILE, properties[constants.BUILD_PROPERTIES_OBJECT_FILE])`
`188`	`190`	`}`
`189`	`191`
`@@ -309,7 +311,8 @@ func CoreOrReferencedCoreHasChanged(corePath, targetCorePath, targetFile string)`
`309`	`311`	`return true`
`310`	`312`	`}`
`311`	`313`
`312`		`-func ArchiveCompiledFiles(buildPath string, archiveFile string, objectFiles []string, buildProperties properties.Map, verbose bool, logger i18n.Logger) (string, error) {`
	`314`	`+func ArchiveCompiledFiles(ctx *types.Context, buildPath string, archiveFile string, objectFiles []string, buildProperties properties.Map) (string, error) {`
	`315`	`+ logger := ctx.GetLogger()`
`313`	`316`	`archiveFilePath := filepath.Join(buildPath, archiveFile)`
`314`	`317`
`315`	`318`	`rebuildArchive := false`
`@@ -332,7 +335,7 @@ func ArchiveCompiledFiles(buildPath string, archiveFile string, objectFiles []st`
`332`	`335`	`return "", i18n.WrapError(err)`
`333`	`336`	`}`
`334`	`337`	`} else {`
`335`		`- if verbose {`
	`338`	`+ if ctx.Verbose {`
`336`	`339`	`logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_PREVIOUS_COMPILED_FILE, archiveFilePath)`
`337`	`340`	`}`
`338`	`341`	`return archiveFilePath, nil`
`@@ -345,7 +348,7 @@ func ArchiveCompiledFiles(buildPath string, archiveFile string, objectFiles []st`
`345`	`348`	`properties[constants.BUILD_PROPERTIES_ARCHIVE_FILE_PATH] = archiveFilePath`
`346`	`349`	`properties[constants.BUILD_PROPERTIES_OBJECT_FILE] = objectFile`
`347`	`350`
`348`		`- _, err := ExecRecipe(properties, constants.RECIPE_AR_PATTERN, false, verbose, verbose, logger)`
	`351`	`+ _, err := ExecRecipe(properties, constants.RECIPE_AR_PATTERN, false, ctx.Verbose, ctx.Verbose, logger)`
`349`	`352`	`if err != nil {`
`350`	`353`	`return "", i18n.WrapError(err)`
`351`	`354`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,9 +46,6 @@ func (s CoreBuilder) Run(ctx types.Context) error {`
`46`	`46`	`coreBuildPath := ctx.CoreBuildPath`
`47`	`47`	`coreBuildCachePath := ctx.CoreBuildCachePath`
`48`	`48`	`buildProperties := ctx.BuildProperties`
`49`		`- verbose := ctx.Verbose`
`50`		`- warningsLevel := ctx.WarningsLevel`
`51`		`- logger := ctx.GetLogger()`
`52`	`49`
`53`	`50`	`err := utils.EnsureFolderExists(coreBuildPath)`
`54`	`51`	`if err != nil {`
`@@ -62,7 +59,7 @@ func (s CoreBuilder) Run(ctx types.Context) error {`
`62`	`59`	`}`
`63`	`60`	`}`
`64`	`61`
`65`		`- archiveFile, objectFiles, err := compileCore(coreBuildPath, coreBuildCachePath, buildProperties, verbose, warningsLevel, logger)`
	`62`	`+ archiveFile, objectFiles, err := compileCore(ctx, coreBuildPath, coreBuildCachePath, buildProperties)`
`66`	`63`	`if err != nil {`
`67`	`64`	`return i18n.WrapError(err)`
`68`	`65`	`}`
`@@ -73,7 +70,8 @@ func (s CoreBuilder) Run(ctx types.Context) error {`
`73`	`70`	`return nil`
`74`	`71`	`}`
`75`	`72`
`76`		`-func compileCore(buildPath string, buildCachePath string, buildProperties properties.Map, verbose bool, warningsLevel string, logger i18n.Logger) (string, []string, error) {`
	`73`	`+func compileCore(ctx *types.Context, buildPath string, buildCachePath string, buildProperties properties.Map) (string, []string, error) {`
	`74`	`+ logger := ctx.GetLogger()`
`77`	`75`	`coreFolder := buildProperties[constants.BUILD_PROPERTIES_BUILD_CORE_PATH]`
`78`	`76`	`variantFolder := buildProperties[constants.BUILD_PROPERTIES_BUILD_VARIANT_PATH]`
`79`	`77`
`@@ -90,7 +88,7 @@ func compileCore(buildPath string, buildCachePath string, buildProperties proper`
`90`	`88`
`91`	`89`	`variantObjectFiles := []string{}`
`92`	`90`	`if variantFolder != constants.EMPTY_STRING {`
`93`		`- variantObjectFiles, err = builder_utils.CompileFiles(variantObjectFiles, variantFolder, true, buildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`91`	`+ variantObjectFiles, err = builder_utils.CompileFiles(ctx, variantObjectFiles, variantFolder, true, buildPath, buildProperties, includes)`
`94`	`92`	`if err != nil {`
`95`	`93`	`return "", nil, i18n.WrapError(err)`
`96`	`94`	`}`
`@@ -107,26 +105,26 @@ func compileCore(buildPath string, buildCachePath string, buildProperties proper`
`107`	`105`
`108`	`106`	`if canUseArchivedCore {`
`109`	`107`	`// use archived core`
`110`		`- if verbose {`
	`108`	`+ if ctx.Verbose {`
`111`	`109`	`logger.Println(constants.LOG_LEVEL_INFO, "Using precompiled core: {0}", targetArchivedCore)`
`112`	`110`	`}`
`113`	`111`	`return targetArchivedCore, variantObjectFiles, nil`
`114`	`112`	`}`
`115`	`113`	`}`
`116`	`114`
`117`		`- coreObjectFiles, err := builder_utils.CompileFiles([]string{}, coreFolder, true, buildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`115`	`+ coreObjectFiles, err := builder_utils.CompileFiles(ctx, []string{}, coreFolder, true, buildPath, buildProperties, includes)`
`118`	`116`	`if err != nil {`
`119`	`117`	`return "", nil, i18n.WrapError(err)`
`120`	`118`	`}`
`121`	`119`
`122`		`- archiveFile, err := builder_utils.ArchiveCompiledFiles(buildPath, "core.a", coreObjectFiles, buildProperties, verbose, logger)`
	`120`	`+ archiveFile, err := builder_utils.ArchiveCompiledFiles(ctx, buildPath, "core.a", coreObjectFiles, buildProperties)`
`123`	`121`	`if err != nil {`
`124`	`122`	`return "", nil, i18n.WrapError(err)`
`125`	`123`	`}`
`126`	`124`
`127`	`125`	`// archive core.a`
`128`	`126`	`if targetArchivedCore != "" {`
`129`		`- if verbose {`
	`127`	`+ if ctx.Verbose {`
`130`	`128`	`logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_ARCHIVING_CORE_CACHE, targetArchivedCore)`
`131`	`129`	`}`
`132`	`130`	`builder_utils.CopyFile(archiveFile, targetArchivedCore)`
Original file line number	Diff line number	Diff line change
`@@ -52,16 +52,13 @@ func (s LibrariesBuilder) Run(ctx types.Context) error {`
`52`	`52`	`includes := ctx.IncludeFolders`
`53`	`53`	`includes = utils.Map(includes, utils.WrapWithHyphenI)`
`54`	`54`	`libraries := ctx.ImportedLibraries`
`55`		`- verbose := ctx.Verbose`
`56`		`- warningsLevel := ctx.WarningsLevel`
`57`		`- logger := ctx.GetLogger()`
`58`	`55`
`59`	`56`	`err := utils.EnsureFolderExists(librariesBuildPath)`
`60`	`57`	`if err != nil {`
`61`	`58`	`return i18n.WrapError(err)`
`62`	`59`	`}`
`63`	`60`
`64`		`- objectFiles, err := compileLibraries(libraries, librariesBuildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`61`	`+ objectFiles, err := compileLibraries(ctx, libraries, librariesBuildPath, buildProperties, includes)`
`65`	`62`	`if err != nil {`
`66`	`63`	`return i18n.WrapError(err)`
`67`	`64`	`}`
`@@ -99,10 +96,10 @@ func fixLDFLAGforPrecompiledLibraries(ctx types.Context, libraries []types.Lib`
`99`	`96`	`return nil`
`100`	`97`	`}`
`101`	`98`
`102`		`-func compileLibraries(libraries []*types.Library, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {`
	`99`	`+func compileLibraries(ctx types.Context, libraries []types.Library, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {`
`103`	`100`	`objectFiles := []string{}`
`104`	`101`	`for _, library := range libraries {`
`105`		`- libraryObjectFiles, err := compileLibrary(library, buildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`102`	`+ libraryObjectFiles, err := compileLibrary(ctx, library, buildPath, buildProperties, includes)`
`106`	`103`	`if err != nil {`
`107`	`104`	`return nil, i18n.WrapError(err)`
`108`	`105`	`}`
`@@ -113,8 +110,9 @@ func compileLibraries(libraries []*types.Library, buildPath string, buildPropert`
`113`	`110`
`114`	`111`	`}`
`115`	`112`
`116`		`-func compileLibrary(library *types.Library, buildPath string, buildProperties properties.Map, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {`
`117`		`- if verbose {`
	`113`	`+func compileLibrary(ctx types.Context, library types.Library, buildPath string, buildProperties properties.Map, includes []string) ([]string, error) {`
	`114`	`+ logger := ctx.GetLogger()`
	`115`	`+ if ctx.Verbose {`
`118`	`116`	`logger.Println(constants.LOG_LEVEL_INFO, "Compiling library \"{0}\"", library.Name)`
`119`	`117`	`}`
`120`	`118`	`libraryBuildPath := filepath.Join(buildPath, library.Name)`
`@@ -144,12 +142,12 @@ func compileLibrary(library *types.Library, buildPath string, buildProperties pr`
`144`	`142`	`}`
`145`	`143`
`146`	`144`	`if library.Layout == types.LIBRARY_RECURSIVE {`
`147`		`- objectFiles, err = builder_utils.CompileFilesRecursive(objectFiles, library.SrcFolder, libraryBuildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`145`	`+ objectFiles, err = builder_utils.CompileFilesRecursive(ctx, objectFiles, library.SrcFolder, libraryBuildPath, buildProperties, includes)`
`148`	`146`	`if err != nil {`
`149`	`147`	`return nil, i18n.WrapError(err)`
`150`	`148`	`}`
`151`	`149`	`if library.DotALinkage {`
`152`		`- archiveFile, err := builder_utils.ArchiveCompiledFiles(libraryBuildPath, library.Name+".a", objectFiles, buildProperties, verbose, logger)`
	`150`	`+ archiveFile, err := builder_utils.ArchiveCompiledFiles(ctx, libraryBuildPath, library.Name+".a", objectFiles, buildProperties)`
`153`	`151`	`if err != nil {`
`154`	`152`	`return nil, i18n.WrapError(err)`
`155`	`153`	`}`
`@@ -159,14 +157,14 @@ func compileLibrary(library *types.Library, buildPath string, buildProperties pr`
`159`	`157`	`if library.UtilityFolder != "" {`
`160`	`158`	`includes = append(includes, utils.WrapWithHyphenI(library.UtilityFolder))`
`161`	`159`	`}`
`162`		`- objectFiles, err = builder_utils.CompileFiles(objectFiles, library.SrcFolder, false, libraryBuildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`160`	`+ objectFiles, err = builder_utils.CompileFiles(ctx, objectFiles, library.SrcFolder, false, libraryBuildPath, buildProperties, includes)`
`163`	`161`	`if err != nil {`
`164`	`162`	`return nil, i18n.WrapError(err)`
`165`	`163`	`}`
`166`	`164`
`167`	`165`	`if library.UtilityFolder != "" {`
`168`	`166`	`utilityBuildPath := filepath.Join(libraryBuildPath, constants.LIBRARY_FOLDER_UTILITY)`
`169`		`- objectFiles, err = builder_utils.CompileFiles(objectFiles, library.UtilityFolder, false, utilityBuildPath, buildProperties, includes, verbose, warningsLevel, logger)`
	`167`	`+ objectFiles, err = builder_utils.CompileFiles(ctx, objectFiles, library.UtilityFolder, false, utilityBuildPath, buildProperties, includes)`
`170`	`168`	`if err != nil {`
`171`	`169`	`return nil, i18n.WrapError(err)`
`172`	`170`	`}`