func (s *WarnAboutArchIncompatibleLibraries) Run(ctx *types.Context) error {
if ctx.DebugLevel < 0 {
return nil
}
targetPlatform := ctx.TargetPlatform
buildProperties := ctx.BuildProperties
logger := ctx.GetLogger()
archs := []string{}
archs = append(archs, targetPlatform.PlatformId)
if buildProperties[constants.BUILD_PROPERTIES_ARCH_OVERRIDE_CHECK] != constants.EMPTY_STRING {
overrides := strings.Split(buildProperties[constants.BUILD_PROPERTIES_ARCH_OVERRIDE_CHECK], ",")
for _, override := range overrides {
archs = append(archs, override)
}
}
for _, importedLibrary := range ctx.ImportedLibraries {
if !importedLibrary.SupportsArchitectures(archs) {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_LIBRARY_INCOMPATIBLE_ARCH, importedLibrary.Name, importedLibrary.Archs, archs)
}
}
return nil
}
func (s *PrintUsedAndNotUsedLibraries) Run(ctx *types.Context) error {
var logLevel string
// Print this message as warning when the sketch didn't compile,
// as info when we're verbose and not all otherwise
if s.SketchError {
logLevel = constants.LOG_LEVEL_WARN
} else if ctx.Verbose {
logLevel = constants.LOG_LEVEL_INFO
} else {
return nil
}
logger := ctx.GetLogger()
libraryResolutionResults := ctx.LibrariesResolutionResults
for header, libResResult := range libraryResolutionResults {
logger.Fprintln(os.Stdout, logLevel, constants.MSG_LIBRARIES_MULTIPLE_LIBS_FOUND_FOR, header)
logger.Fprintln(os.Stdout, logLevel, constants.MSG_LIBRARIES_USED, libResResult.Library.Folder)
for _, notUsedLibrary := range libResResult.NotUsedLibraries {
logger.Fprintln(os.Stdout, logLevel, constants.MSG_LIBRARIES_NOT_USED, notUsedLibrary.Folder)
}
}
time.Sleep(100 * time.Millisecond)
return nil
}
func (s *RecipeByPrefixSuffixRunner) Run(ctx *types.Context) error {
logger := ctx.GetLogger()
if ctx.DebugLevel >= 10 {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_DEBUG, constants.MSG_LOOKING_FOR_RECIPES, s.Prefix, s.Suffix)
}
buildProperties := ctx.BuildProperties.Clone()
verbose := ctx.Verbose
recipes := findRecipes(buildProperties, s.Prefix, s.Suffix)
properties := buildProperties.Clone()
for _, recipe := range recipes {
if ctx.DebugLevel >= 10 {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_DEBUG, constants.MSG_RUNNING_RECIPE, recipe)
}
_, err := builder_utils.ExecRecipe(properties, recipe, false, verbose, verbose, logger)
if err != nil {
return i18n.WrapError(err)
}
}
return nil
}
func (s *Linker) Run(ctx *types.Context) error {
objectFilesSketch := ctx.SketchObjectFiles
objectFilesLibraries := ctx.LibrariesObjectFiles
objectFilesCore := ctx.CoreObjectsFiles
var objectFiles []string
objectFiles = append(objectFiles, objectFilesSketch...)
objectFiles = append(objectFiles, objectFilesLibraries...)
objectFiles = append(objectFiles, objectFilesCore...)
coreArchiveFilePath := ctx.CoreArchiveFilePath
buildPath := ctx.BuildPath
coreDotARelPath, err := filepath.Rel(buildPath, coreArchiveFilePath)
if err != nil {
return i18n.WrapError(err)
}
buildProperties := ctx.BuildProperties
verbose := ctx.Verbose
warningsLevel := ctx.WarningsLevel
logger := ctx.GetLogger()
err = link(objectFiles, coreDotARelPath, coreArchiveFilePath, buildProperties, verbose, warningsLevel, logger)
if err != nil {
return i18n.WrapError(err)
}
return nil
}
func (s *FailIfImportedLibraryIsWrong) Run(ctx *types.Context) error {
if len(ctx.ImportedLibraries) == 0 {
return nil
}
logger := ctx.GetLogger()
for _, library := range ctx.ImportedLibraries {
if !library.IsLegacy {
if stat, err := os.Stat(filepath.Join(library.Folder, constants.LIBRARY_FOLDER_ARCH)); err == nil && stat.IsDir() {
return i18n.ErrorfWithLogger(logger, constants.MSG_ARCH_FOLDER_NOT_SUPPORTED)
}
for _, propName := range LIBRARY_MANDATORY_PROPERTIES {
if _, ok := library.Properties[propName]; !ok {
return i18n.ErrorfWithLogger(logger, constants.MSG_PROP_IN_LIBRARY, propName, library.Folder)
}
}
if library.Layout == types.LIBRARY_RECURSIVE {
if stat, err := os.Stat(filepath.Join(library.Folder, constants.LIBRARY_FOLDER_UTILITY)); err == nil && stat.IsDir() {
return i18n.ErrorfWithLogger(logger, constants.MSG_LIBRARY_CAN_USE_SRC_AND_UTILITY_FOLDERS, library.Folder)
}
}
}
}
return nil
}
func (s *CTagsRunner) Run(ctx *types.Context) error {
buildProperties := ctx.BuildProperties
ctagsTargetFilePath := ctx.CTagsTargetFile
logger := ctx.GetLogger()
properties := buildProperties.Clone()
properties.Merge(buildProperties.SubTree(constants.BUILD_PROPERTIES_TOOLS_KEY).SubTree(constants.CTAGS))
properties[constants.BUILD_PROPERTIES_SOURCE_FILE] = ctagsTargetFilePath
pattern := properties[constants.BUILD_PROPERTIES_PATTERN]
if pattern == constants.EMPTY_STRING {
return i18n.ErrorfWithLogger(logger, constants.MSG_PATTERN_MISSING, constants.CTAGS)
}
commandLine := properties.ExpandPropsInString(pattern)
command, err := utils.PrepareCommand(commandLine, logger)
if err != nil {
return i18n.WrapError(err)
}
verbose := ctx.Verbose
if verbose {
fmt.Println(commandLine)
}
sourceBytes, err := command.Output()
if err != nil {
return i18n.WrapError(err)
}
ctx.CTagsOutput = string(sourceBytes)
return nil
}
func (s *WarnAboutPlatformRewrites) Run(ctx *types.Context) error {
if ctx.DebugLevel < 0 {
return nil
}
logger := ctx.GetLogger()
hardwareRewriteResults := ctx.HardwareRewriteResults
targetPlatform := ctx.TargetPlatform
actualPlatform := ctx.ActualPlatform
platforms := []*types.Platform{targetPlatform}
if actualPlatform != targetPlatform {
platforms = append(platforms, actualPlatform)
}
for _, platform := range platforms {
if hardwareRewriteResults[platform] != nil {
for _, rewrite := range hardwareRewriteResults[platform] {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_WARNING_PLATFORM_OLD_VALUES, platform.Properties[constants.PLATFORM_NAME], rewrite.Key+"="+rewrite.OldValue, rewrite.Key+"="+rewrite.NewValue)
}
}
}
return nil
}
func (s *SketchBuilder) Run(ctx *types.Context) error {
sketchBuildPath := ctx.SketchBuildPath
buildProperties := ctx.BuildProperties
includes := ctx.IncludeFolders
includes = utils.Map(includes, utils.WrapWithHyphenI)
verbose := ctx.Verbose
warningsLevel := ctx.WarningsLevel
logger := ctx.GetLogger()
err := utils.EnsureFolderExists(sketchBuildPath)
if err != nil {
return i18n.WrapError(err)
}
var objectFiles []string
objectFiles, err = builder_utils.CompileFiles(objectFiles, sketchBuildPath, false, sketchBuildPath, buildProperties, includes, verbose, warningsLevel, logger)
if err != nil {
return i18n.WrapError(err)
}
// The "src/" subdirectory of a sketch is compiled recursively
sketchSrcPath := filepath.Join(sketchBuildPath, constants.SKETCH_FOLDER_SRC)
if info, err := os.Stat(sketchSrcPath); err == nil && info.IsDir() {
objectFiles, err = builder_utils.CompileFiles(objectFiles, sketchSrcPath, true, sketchSrcPath, buildProperties, includes, verbose, warningsLevel, logger)
if err != nil {
return i18n.WrapError(err)
}
}
ctx.SketchObjectFiles = objectFiles
return nil
}
func printProgressIfProgressEnabledAndMachineLogger(progressEnabled bool, ctx *types.Context, progress float32) {
if !progressEnabled {
return
}
log := ctx.GetLogger()
if log.Name() == "machine" {
log.Println(constants.LOG_LEVEL_INFO, constants.MSG_PROGRESS, strconv.FormatFloat(float64(progress), 'f', 2, 32))
}
}
func (s *HardwareLoader) Run(ctx *types.Context) error {
logger := ctx.GetLogger()
packages := &types.Packages{}
packages.Packages = make(map[string]*types.Package)
packages.Properties = make(map[string]string)
folders := ctx.HardwareFolders
folders, err := utils.AbsolutizePaths(folders)
if err != nil {
return i18n.WrapError(err)
}
for _, folder := range folders {
stat, err := os.Stat(folder)
if err != nil {
return i18n.WrapError(err)
}
if !stat.IsDir() {
return i18n.ErrorfWithLogger(logger, constants.MSG_MUST_BE_A_FOLDER, folder)
}
hardwarePlatformTxt, err := props.SafeLoad(filepath.Join(folder, constants.FILE_PLATFORM_TXT), logger)
if err != nil {
return i18n.WrapError(err)
}
packages.Properties.Merge(hardwarePlatformTxt)
subfolders, err := utils.ReadDirFiltered(folder, utils.FilterDirs)
if err != nil {
return i18n.WrapError(err)
}
subfolders = utils.FilterOutFoldersByNames(subfolders, constants.FOLDER_TOOLS)
for _, subfolder := range subfolders {
subfolderPath := filepath.Join(folder, subfolder.Name())
packageId := subfolder.Name()
if _, err := os.Stat(filepath.Join(subfolderPath, constants.FOLDER_HARDWARE)); err == nil {
subfolderPath = filepath.Join(subfolderPath, constants.FOLDER_HARDWARE)
}
targetPackage := getOrCreatePackage(packages, packageId)
err = loadPackage(targetPackage, subfolderPath, logger)
if err != nil {
return i18n.WrapError(err)
}
packages.Packages[packageId] = targetPackage
}
}
ctx.Hardware = packages
return nil
}
func skipTagsWhere(tags []*types.CTag, skipFunc skipFuncType, ctx *types.Context) {
for _, tag := range tags {
if !tag.SkipMe {
skip := skipFunc(tag)
if skip && ctx.DebugLevel >= 10 {
ctx.GetLogger().Fprintln(os.Stdout, constants.LOG_LEVEL_DEBUG, constants.MSG_SKIPPING_TAG_WITH_REASON, tag.FunctionName, runtime.FuncForPC(reflect.ValueOf(skipFunc).Pointer()).Name())
}
tag.SkipMe = skip
}
}
}
func (s *SetCustomBuildProperties) Run(ctx *types.Context) error {
logger := ctx.GetLogger()
buildProperties := ctx.BuildProperties
customBuildProperties, err := props.LoadFromSlice(ctx.CustomBuildProperties, logger)
if err != nil {
return i18n.WrapError(err)
}
for key, value := range customBuildProperties {
buildProperties[key] = value
}
return nil
}
func removeDefinedProtypes(tags []*types.CTag, ctx *types.Context) {
definedPrototypes := make(map[string]bool)
for _, tag := range tags {
if tag.Kind == KIND_PROTOTYPE {
definedPrototypes[tag.Prototype] = true
}
}
for _, tag := range tags {
if definedPrototypes[tag.Prototype] {
if ctx.DebugLevel >= 10 {
ctx.GetLogger().Fprintln(os.Stdout, constants.LOG_LEVEL_DEBUG, constants.MSG_SKIPPING_TAG_ALREADY_DEFINED, tag.FunctionName)
}
tag.SkipMe = true
}
}
}
func (s *AddBuildBoardPropertyIfMissing) Run(ctx *types.Context) error {
packages := ctx.Hardware
logger := ctx.GetLogger()
for _, aPackage := range packages.Packages {
for _, platform := range aPackage.Platforms {
for _, board := range platform.Boards {
if board.Properties[constants.BUILD_PROPERTIES_BUILD_BOARD] == constants.EMPTY_STRING {
board.Properties[constants.BUILD_PROPERTIES_BUILD_BOARD] = strings.ToUpper(platform.PlatformId + "_" + board.BoardId)
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_MISSING_BUILD_BOARD, aPackage.PackageId, platform.PlatformId, board.BoardId, board.Properties[constants.BUILD_PROPERTIES_BUILD_BOARD])
}
}
}
}
return nil
}
func (s *Sizer) Run(ctx *types.Context) error {
if s.SketchError {
return nil
}
buildProperties := ctx.BuildProperties
verbose := ctx.Verbose
warningsLevel := ctx.WarningsLevel
logger := ctx.GetLogger()
err := checkSize(buildProperties, verbose, warningsLevel, logger)
if err != nil {
return i18n.WrapError(err)
}
return nil
}
func (s *MergeSketchWithBootloader) Run(ctx *types.Context) error {
buildProperties := ctx.BuildProperties
if !utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_BOOTLOADER_NOBLINK) && !utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_BOOTLOADER_FILE) {
return nil
}
buildPath := ctx.BuildPath
sketch := ctx.Sketch
sketchFileName := filepath.Base(sketch.MainFile.Name)
logger := ctx.GetLogger()
sketchInBuildPath := filepath.Join(buildPath, sketchFileName+".hex")
sketchInSubfolder := filepath.Join(buildPath, constants.FOLDER_SKETCH, sketchFileName+".hex")
builtSketchPath := constants.EMPTY_STRING
if _, err := os.Stat(sketchInBuildPath); err == nil {
builtSketchPath = sketchInBuildPath
} else if _, err := os.Stat(sketchInSubfolder); err == nil {
builtSketchPath = sketchInSubfolder
} else {
return nil
}
bootloader := constants.EMPTY_STRING
if utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_BOOTLOADER_NOBLINK) {
bootloader = buildProperties[constants.BUILD_PROPERTIES_BOOTLOADER_NOBLINK]
} else {
bootloader = buildProperties[constants.BUILD_PROPERTIES_BOOTLOADER_FILE]
}
bootloader = buildProperties.ExpandPropsInString(bootloader)
bootloaderPath := filepath.Join(buildProperties[constants.BUILD_PROPERTIES_RUNTIME_PLATFORM_PATH], constants.FOLDER_BOOTLOADERS, bootloader)
if _, err := os.Stat(bootloaderPath); err != nil {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_BOOTLOADER_FILE_MISSING, bootloaderPath)
return nil
}
mergedSketchPath := filepath.Join(filepath.Dir(builtSketchPath), sketchFileName+".with_bootloader.hex")
err := merge(builtSketchPath, bootloaderPath, mergedSketchPath)
return err
}
func (s *SketchLoader) Run(ctx *types.Context) error {
if ctx.SketchLocation == "" {
return nil
}
sketchLocation := ctx.SketchLocation
sketchLocation, err := filepath.Abs(sketchLocation)
if err != nil {
return i18n.WrapError(err)
}
mainSketchStat, err := os.Stat(sketchLocation)
if err != nil {
return i18n.WrapError(err)
}
if mainSketchStat.IsDir() {
sketchLocation = filepath.Join(sketchLocation, mainSketchStat.Name()+".ino")
}
ctx.SketchLocation = sketchLocation
allSketchFilePaths, err := collectAllSketchFiles(filepath.Dir(sketchLocation))
if err != nil {
return i18n.WrapError(err)
}
logger := ctx.GetLogger()
if !utils.SliceContains(allSketchFilePaths, sketchLocation) {
return i18n.ErrorfWithLogger(logger, constants.MSG_CANT_FIND_SKETCH_IN_PATH, sketchLocation, filepath.Dir(sketchLocation))
}
sketch, err := makeSketch(sketchLocation, allSketchFilePaths, logger)
if err != nil {
return i18n.WrapError(err)
}
ctx.SketchLocation = sketchLocation
ctx.Sketch = sketch
return nil
}
func (s *PrintUsedAndNotUsedLibraries) Run(ctx *types.Context) error {
if ctx.DebugLevel < 0 {
return nil
}
logger := ctx.GetLogger()
libraryResolutionResults := ctx.LibrariesResolutionResults
for header, libResResult := range libraryResolutionResults {
if !libResResult.IsLibraryFromPlatform {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_LIBRARIES_MULTIPLE_LIBS_FOUND_FOR, header)
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_LIBRARIES_USED, libResResult.Library.Folder)
for _, notUsedLibrary := range libResResult.NotUsedLibraries {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_LIBRARIES_NOT_USED, notUsedLibrary.Folder)
}
}
}
time.Sleep(100 * time.Millisecond)
return nil
}
func (s *GenerateBuildPathIfMissing) Run(ctx *types.Context) error {
if ctx.BuildPath != "" {
return nil
}
md5sum := utils.MD5Sum([]byte(ctx.SketchLocation))
buildPath := filepath.Join(os.TempDir(), "arduino-sketch-"+strings.ToUpper(md5sum))
_, err := os.Stat(buildPath)
if err != nil && !os.IsNotExist(err) {
return i18n.WrapError(err)
}
if ctx.DebugLevel > 5 {
logger := ctx.GetLogger()
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_SETTING_BUILD_PATH, buildPath)
}
ctx.BuildPath = buildPath
return nil
}
func (s *PlatformKeysRewriteLoader) Run(ctx *types.Context) error {
logger := ctx.GetLogger()
folders := ctx.HardwareFolders
platformKeysRewriteTxtPath, err := findPlatformKeysRewriteTxt(folders)
if err != nil {
return i18n.WrapError(err)
}
if platformKeysRewriteTxtPath == constants.EMPTY_STRING {
return nil
}
platformKeysRewrite := types.PlatforKeysRewrite{}
platformKeysRewrite.Rewrites = []types.PlatforKeyRewrite{}
txt, err := props.Load(platformKeysRewriteTxtPath, logger)
keys := utils.KeysOfMapOfString(txt)
sort.Strings(keys)
for _, key := range keys {
keyParts := strings.Split(key, ".")
if keyParts[0] == constants.PLATFORM_REWRITE_OLD {
index, err := strconv.Atoi(keyParts[1])
if err != nil {
return i18n.WrapError(err)
}
rewriteKey := strings.Join(keyParts[2:], ".")
oldValue := txt[key]
newValue := txt[constants.PLATFORM_REWRITE_NEW+"."+strings.Join(keyParts[1:], ".")]
platformKeyRewrite := types.PlatforKeyRewrite{Key: rewriteKey, OldValue: oldValue, NewValue: newValue}
platformKeysRewrite.Rewrites = growSliceOfRewrites(platformKeysRewrite.Rewrites, index)
platformKeysRewrite.Rewrites[index] = platformKeyRewrite
}
}
ctx.PlatformKeyRewrites = platformKeysRewrite
return nil
}
func (s *CoreBuilder) Run(ctx *types.Context) error {
coreBuildPath := ctx.CoreBuildPath
buildProperties := ctx.BuildProperties
verbose := ctx.Verbose
warningsLevel := ctx.WarningsLevel
logger := ctx.GetLogger()
err := utils.EnsureFolderExists(coreBuildPath)
if err != nil {
return i18n.WrapError(err)
}
archiveFile, objectFiles, err := compileCore(coreBuildPath, buildProperties, verbose, warningsLevel, logger)
if err != nil {
return i18n.WrapError(err)
}
ctx.CoreArchiveFilePath = archiveFile
ctx.CoreObjectsFiles = objectFiles
return nil
}
func (s *FailIfBuildPathEqualsSketchPath) Run(ctx *types.Context) error {
if ctx.BuildPath == "" || ctx.SketchLocation == "" {
return nil
}
buildPath, err := filepath.Abs(ctx.BuildPath)
if err != nil {
return i18n.WrapError(err)
}
sketchPath, err := filepath.Abs(ctx.SketchLocation)
if err != nil {
return i18n.WrapError(err)
}
sketchPath = filepath.Dir(sketchPath)
if buildPath == sketchPath {
return i18n.ErrorfWithLogger(ctx.GetLogger(), constants.MSG_SKETCH_CANT_BE_IN_BUILDPATH)
}
return nil
}
func (s *GCCPreprocRunner) Run(ctx *types.Context) error {
properties, targetFilePath, err := prepareGCCPreprocRecipeProperties(ctx, s.SourceFilePath, s.TargetFileName, s.Includes)
if err != nil {
return i18n.WrapError(err)
}
if properties[constants.RECIPE_PREPROC_MACROS] == constants.EMPTY_STRING {
//generate PREPROC_MACROS from RECIPE_CPP_PATTERN
properties[constants.RECIPE_PREPROC_MACROS] = GeneratePreprocPatternFromCompile(properties[constants.RECIPE_CPP_PATTERN])
}
verbose := ctx.Verbose
logger := ctx.GetLogger()
_, err = builder_utils.ExecRecipe(properties, constants.RECIPE_PREPROC_MACROS, true, verbose, false, logger)
if err != nil {
return i18n.WrapError(err)
}
ctx.FileToRead = targetFilePath
return nil
}
func (s *GCCPreprocRunnerForDiscoveringIncludes) Run(ctx *types.Context) error {
properties, _, err := prepareGCCPreprocRecipeProperties(ctx, s.SourceFilePath, s.TargetFilePath, s.Includes)
if err != nil {
return i18n.WrapError(err)
}
verbose := ctx.Verbose
logger := ctx.GetLogger()
if properties[constants.RECIPE_PREPROC_MACROS] == constants.EMPTY_STRING {
//generate PREPROC_MACROS from RECIPE_CPP_PATTERN
properties[constants.RECIPE_PREPROC_MACROS] = GeneratePreprocPatternFromCompile(properties[constants.RECIPE_CPP_PATTERN])
}
stderr, err := builder_utils.ExecRecipeCollectStdErr(properties, constants.RECIPE_PREPROC_MACROS, true, verbose, false, logger)
if err != nil {
return i18n.WrapError(err)
}
ctx.SourceGccMinusE = string(stderr)
return nil
}
func (s *LibrariesBuilder) Run(ctx *types.Context) error {
librariesBuildPath := ctx.LibrariesBuildPath
buildProperties := ctx.BuildProperties
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)
if err != nil {
return i18n.WrapError(err)
}
ctx.LibrariesObjectFiles = objectFiles
return nil
}
func (s *GCCPreprocRunner) Run(ctx *types.Context) error {
sketchBuildPath := ctx.SketchBuildPath
sketch := ctx.Sketch
properties, targetFilePath, err := prepareGCCPreprocRecipeProperties(ctx, filepath.Join(sketchBuildPath, filepath.Base(sketch.MainFile.Name)+".cpp"), s.TargetFileName)
if err != nil {
return i18n.WrapError(err)
}
if properties[constants.RECIPE_PREPROC_MACROS] == constants.EMPTY_STRING {
//generate PREPROC_MACROS from RECIPE_CPP_PATTERN
properties[constants.RECIPE_PREPROC_MACROS] = GeneratePreprocPatternFromCompile(properties[constants.RECIPE_CPP_PATTERN])
}
verbose := ctx.Verbose
logger := ctx.GetLogger()
_, err = builder_utils.ExecRecipe(properties, constants.RECIPE_PREPROC_MACROS, true, verbose, false, logger)
if err != nil {
return i18n.WrapError(err)
}
ctx.FileToRead = targetFilePath
return nil
}
func (s *PrintUsedLibrariesIfVerbose) Run(ctx *types.Context) error {
verbose := ctx.Verbose
logger := ctx.GetLogger()
if !verbose || len(ctx.ImportedLibraries) == 0 {
return nil
}
for _, library := range ctx.ImportedLibraries {
legacy := constants.EMPTY_STRING
if library.IsLegacy {
legacy = constants.MSG_LIB_LEGACY
}
if library.Version == constants.EMPTY_STRING {
logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_LIBRARY, library.Name, library.Folder, legacy)
} else {
logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_LIBRARY_AT_VERSION, library.Name, library.Version, library.Folder, legacy)
}
}
time.Sleep(100 * time.Millisecond)
return nil
}
func (s *SketchBuilder) Run(ctx *types.Context) error {
sketchBuildPath := ctx.SketchBuildPath
buildProperties := ctx.BuildProperties
includes := ctx.IncludeFolders
includes = utils.Map(includes, utils.WrapWithHyphenI)
verbose := ctx.Verbose
warningsLevel := ctx.WarningsLevel
logger := ctx.GetLogger()
err := utils.EnsureFolderExists(sketchBuildPath)
if err != nil {
return i18n.WrapError(err)
}
var objectFiles []string
objectFiles, err = builder_utils.CompileFiles(objectFiles, sketchBuildPath, true, sketchBuildPath, buildProperties, includes, verbose, warningsLevel, logger)
if err != nil {
return i18n.WrapError(err)
}
ctx.SketchObjectFiles = objectFiles
return nil
}
func (s *WipeoutBuildPathIfBuildOptionsChanged) Run(ctx *types.Context) error {
if ctx.BuildOptionsJsonPrevious == "" {
return nil
}
buildOptionsJson := ctx.BuildOptionsJson
previousBuildOptionsJson := ctx.BuildOptionsJsonPrevious
logger := ctx.GetLogger()
var opts properties.Map
var prevOpts properties.Map
json.Unmarshal([]byte(buildOptionsJson), &opts)
json.Unmarshal([]byte(previousBuildOptionsJson), &prevOpts)
// If SketchLocation path is different but filename is the same, consider it equal
if filepath.Base(opts["sketchLocation"]) == filepath.Base(prevOpts["sketchLocation"]) {
delete(opts, "sketchLocation")
delete(prevOpts, "sketchLocation")
}
if opts.Equals(prevOpts) {
return nil
}
logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_BUILD_OPTIONS_CHANGED)
buildPath := ctx.BuildPath
files, err := gohasissues.ReadDir(buildPath)
if err != nil {
return i18n.WrapError(err)
}
for _, file := range files {
os.RemoveAll(filepath.Join(buildPath, file.Name()))
}
return nil
}
func PrintRingNameIfDebug(ctx *types.Context, command types.Command) {
if ctx.DebugLevel >= 10 {
ctx.GetLogger().Fprintln(os.Stdout, constants.LOG_LEVEL_DEBUG, constants.MSG_RUNNING_COMMAND, strconv.FormatInt(time.Now().Unix(), 10), reflect.Indirect(reflect.ValueOf(command)).Type().Name())
}
}