作者：me-no-de
项目：arduino-builde
func findFilesInFolder(sourcePath string, extension string, recurse bool) ([]string, error) {
files, err := utils.ReadDirFiltered(sourcePath, utils.FilterFilesWithExtension(extension))
if err != nil {
return nil, i18n.WrapError(err)
}
var sources []string
for _, file := range files {
sources = append(sources, filepath.Join(sourcePath, file.Name()))
}
if recurse {
folders, err := utils.ReadDirFiltered(sourcePath, utils.FilterDirs)
if err != nil {
return nil, i18n.WrapError(err)
}
for _, folder := range folders {
otherSources, err := findFilesInFolder(filepath.Join(sourcePath, folder.Name()), extension, recurse)
if err != nil {
return nil, i18n.WrapError(err)
}
sources = append(sources, otherSources...)
}
}
return sources, nil
}
作者：ricklo
项目：arduino-builde
func (s *HardwareLoader) Run(context map[string]interface{}) error {
mainHardwarePlatformTxt := make(map[string]string)
packages := make(map[string]*types.Package)
folders := context[constants.CTX_HARDWARE_FOLDERS].([]string)
folders, err := utils.AbsolutizePaths(folders)
if err != nil {
return utils.WrapError(err)
}
for _, folder := range folders {
stat, err := os.Stat(folder)
if err != nil {
return utils.WrapError(err)
}
if !stat.IsDir() {
return utils.Errorf(context, constants.MSG_MUST_BE_A_FOLDER, folder)
}
if len(mainHardwarePlatformTxt) == 0 {
mainHardwarePlatformTxt, err = props.SafeLoad(filepath.Join(folder, constants.FILE_PLATFORM_TXT))
if err != nil {
return utils.WrapError(err)
}
}
hardwarePlatformTxt, err := props.SafeLoad(filepath.Join(folder, constants.FILE_PLATFORM_TXT))
if err != nil {
return utils.WrapError(err)
}
hardwarePlatformTxt = utils.MergeMapsOfStrings(make(map[string]string), mainHardwarePlatformTxt, hardwarePlatformTxt)
subfolders, err := utils.ReadDirFiltered(folder, utils.FilterDirs)
if err != nil {
return utils.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, hardwarePlatformTxt)
if err != nil {
return utils.WrapError(err)
}
packages[packageId] = targetPackage
}
}
context[constants.CTX_HARDWARE] = packages
return nil
}
作者：me-no-de
项目：arduino-builde
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
}
作者：me-no-de
项目：arduino-builde
func loadToolsFromFolderStructure(tools *[]*types.Tool, folder string) error {
toolsNames, err := utils.ReadDirFiltered(folder, utils.FilterDirs)
if err != nil {
return i18n.WrapError(err)
}
for _, toolName := range toolsNames {
toolVersions, err := utils.ReadDirFiltered(filepath.Join(folder, toolName.Name()), utils.FilterDirs)
if err != nil {
return i18n.WrapError(err)
}
for _, toolVersion := range toolVersions {
toolFolder, err := filepath.Abs(filepath.Join(folder, toolName.Name(), toolVersion.Name()))
if err != nil {
return i18n.WrapError(err)
}
if !toolsSliceContains(tools, toolName.Name(), toolVersion.Name()) {
*tools = append(*tools, &types.Tool{Name: toolName.Name(), Version: toolVersion.Name(), Folder: toolFolder})
}
}
}
return nil
}
作者：me-no-de
项目：arduino-builde
func CompileFilesRecursive(objectFiles []string, sourcePath string, buildPath string, buildProperties props.PropertiesMap, includes []string, verbose bool, warningsLevel string, logger i18n.Logger) ([]string, error) {
objectFiles, err := CompileFiles(objectFiles, sourcePath, false, buildPath, buildProperties, includes, verbose, warningsLevel, logger)
if err != nil {
return nil, i18n.WrapError(err)
}
folders, err := utils.ReadDirFiltered(sourcePath, utils.FilterDirs)
if err != nil {
return nil, i18n.WrapError(err)
}
for _, folder := range folders {
objectFiles, err = CompileFilesRecursive(objectFiles, filepath.Join(sourcePath, folder.Name()), filepath.Join(buildPath, folder.Name()), buildProperties, includes, verbose, warningsLevel, logger)
if err != nil {
return nil, i18n.WrapError(err)
}
}
return objectFiles, nil
}
作者：andy52
项目：arduino-builde
func loadPackage(targetPackage *types.Package, folder string, logger i18n.Logger) error {
packagePlatformTxt, err := props.SafeLoad(filepath.Join(folder, constants.FILE_PLATFORM_TXT), logger)
if err != nil {
return utils.WrapError(err)
}
targetPackage.Properties = utils.MergeMapsOfStrings(targetPackage.Properties, packagePlatformTxt)
subfolders, err := utils.ReadDirFiltered(folder, utils.FilterDirs)
if err != nil {
return utils.WrapError(err)
}
subfolders = utils.FilterOutFoldersByNames(subfolders, constants.FOLDER_TOOLS)
platforms := targetPackage.Platforms
for _, subfolder := range subfolders {
subfolderPath := filepath.Join(folder, subfolder.Name())
platformId := subfolder.Name()
_, err := os.Stat(filepath.Join(subfolderPath, constants.FILE_BOARDS_TXT))
if err != nil && os.IsNotExist(err) {
theOnlySubfolder, err := utils.TheOnlySubfolderOf(subfolderPath)
if err != nil {
return utils.WrapError(err)
}
if theOnlySubfolder != constants.EMPTY_STRING {
subfolderPath = filepath.Join(subfolderPath, theOnlySubfolder)
}
}
platform := getOrCreatePlatform(platforms, platformId)
err = loadPlatform(platform, targetPackage.PackageId, subfolderPath, logger)
if err != nil {
return utils.WrapError(err)
}
platforms[platformId] = platform
}
return nil
}
作者：andy52
项目：arduino-builde
func (s *LibrariesLoader) Run(context map[string]interface{}) error {
sortedLibrariesFolders := []string{}
builtInLibrariesFolders := []string{}
if utils.MapHas(context, constants.CTX_BUILT_IN_LIBRARIES_FOLDERS) {
builtInLibrariesFolders = context[constants.CTX_BUILT_IN_LIBRARIES_FOLDERS].([]string)
}
builtInLibrariesFolders, err := utils.AbsolutizePaths(builtInLibrariesFolders)
if err != nil {
return utils.WrapError(err)
}
sortedLibrariesFolders = utils.AppendIfNotPresent(sortedLibrariesFolders, builtInLibrariesFolders...)
platform := context[constants.CTX_TARGET_PLATFORM].(*types.Platform)
debugLevel := utils.DebugLevel(context)
logger := context[constants.CTX_LOGGER].(i18n.Logger)
actualPlatform := context[constants.CTX_ACTUAL_PLATFORM].(*types.Platform)
if actualPlatform != platform {
sortedLibrariesFolders = appendPathToLibrariesFolders(sortedLibrariesFolders, filepath.Join(actualPlatform.Folder, constants.FOLDER_LIBRARIES))
}
sortedLibrariesFolders = appendPathToLibrariesFolders(sortedLibrariesFolders, filepath.Join(platform.Folder, constants.FOLDER_LIBRARIES))
librariesFolders := []string{}
if utils.MapHas(context, constants.CTX_OTHER_LIBRARIES_FOLDERS) {
librariesFolders = context[constants.CTX_OTHER_LIBRARIES_FOLDERS].([]string)
}
librariesFolders, err = utils.AbsolutizePaths(librariesFolders)
if err != nil {
return utils.WrapError(err)
}
sortedLibrariesFolders = utils.AppendIfNotPresent(sortedLibrariesFolders, librariesFolders...)
context[constants.CTX_LIBRARIES_FOLDERS] = sortedLibrariesFolders
var libraries []*types.Library
for _, libraryFolder := range sortedLibrariesFolders {
subFolders, err := utils.ReadDirFiltered(libraryFolder, utils.FilterDirs)
if err != nil {
return utils.WrapError(err)
}
for _, subFolder := range subFolders {
library, err := makeLibrary(filepath.Join(libraryFolder, subFolder.Name()), debugLevel, logger)
if err != nil {
return utils.WrapError(err)
}
libraries = append(libraries, library)
}
}
context[constants.CTX_LIBRARIES] = libraries
headerToLibraries := make(map[string][]*types.Library)
for _, library := range libraries {
headers, err := utils.ReadDirFiltered(library.SrcFolder, utils.FilterFilesWithExtension(".h"))
if err != nil {
return utils.WrapError(err)
}
for _, header := range headers {
headerFileName := header.Name()
headerToLibraries[headerFileName] = append(headerToLibraries[headerFileName], library)
}
}
context[constants.CTX_HEADER_TO_LIBRARIES] = headerToLibraries
return nil
}
作者：andy52
项目：arduino-builde
func makeNewLibrary(libraryFolder string, debugLevel int, logger i18n.Logger) (*types.Library, error) {
properties, err := props.Load(filepath.Join(libraryFolder, constants.LIBRARY_PROPERTIES), logger)
if err != nil {
return nil, utils.WrapError(err)
}
if properties[constants.LIBRARY_MAINTAINER] == constants.EMPTY_STRING && properties[constants.LIBRARY_EMAIL] != constants.EMPTY_STRING {
properties[constants.LIBRARY_MAINTAINER] = properties[constants.LIBRARY_EMAIL]
}
for _, propName := range LIBRARY_NOT_SO_MANDATORY_PROPERTIES {
if properties[propName] == constants.EMPTY_STRING {
properties[propName] = "-"
}
}
library := &types.Library{}
if stat, err := os.Stat(filepath.Join(libraryFolder, constants.LIBRARY_FOLDER_SRC)); err == nil && stat.IsDir() {
library.Layout = types.LIBRARY_RECURSIVE
library.SrcFolder = filepath.Join(libraryFolder, constants.LIBRARY_FOLDER_SRC)
} else {
library.Layout = types.LIBRARY_FLAT
library.SrcFolder = libraryFolder
}
subFolders, err := utils.ReadDirFiltered(libraryFolder, utils.FilterDirs)
if err != nil {
return nil, utils.WrapError(err)
}
if debugLevel > 0 {
for _, subFolder := range subFolders {
if utils.IsSCCSOrHiddenFile(subFolder) {
if !utils.IsSCCSFile(subFolder) && utils.IsHiddenFile(subFolder) {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_WARNING_SPURIOUS_FILE_IN_LIB, filepath.Base(subFolder.Name()), properties[constants.LIBRARY_NAME])
}
}
}
}
if properties[constants.LIBRARY_ARCHITECTURES] == constants.EMPTY_STRING {
properties[constants.LIBRARY_ARCHITECTURES] = constants.LIBRARY_ALL_ARCHS
}
library.Archs = []string{}
for _, arch := range strings.Split(properties[constants.LIBRARY_ARCHITECTURES], ",") {
library.Archs = append(library.Archs, strings.TrimSpace(arch))
}
properties[constants.LIBRARY_CATEGORY] = strings.TrimSpace(properties[constants.LIBRARY_CATEGORY])
if !LIBRARY_CATEGORIES[properties[constants.LIBRARY_CATEGORY]] {
logger.Fprintln(os.Stdout, constants.LOG_LEVEL_WARN, constants.MSG_WARNING_LIB_INVALID_CATEGORY, properties[constants.LIBRARY_CATEGORY], properties[constants.LIBRARY_NAME], constants.LIB_CATEGORY_UNCATEGORIZED)
properties[constants.LIBRARY_CATEGORY] = constants.LIB_CATEGORY_UNCATEGORIZED
}
library.Category = properties[constants.LIBRARY_CATEGORY]
if properties[constants.LIBRARY_LICENSE] == constants.EMPTY_STRING {
properties[constants.LIBRARY_LICENSE] = constants.LIB_LICENSE_UNSPECIFIED
}
library.License = properties[constants.LIBRARY_LICENSE]
library.Folder = libraryFolder
library.Name = filepath.Base(libraryFolder)
library.Version = strings.TrimSpace(properties[constants.LIBRARY_VERSION])
library.Author = strings.TrimSpace(properties[constants.LIBRARY_AUTHOR])
library.Maintainer = strings.TrimSpace(properties[constants.LIBRARY_MAINTAINER])
library.Sentence = strings.TrimSpace(properties[constants.LIBRARY_SENTENCE])
library.Paragraph = strings.TrimSpace(properties[constants.LIBRARY_PARAGRAPH])
library.URL = strings.TrimSpace(properties[constants.LIBRARY_URL])
library.IsLegacy = false
library.DotALinkage = strings.TrimSpace(properties[constants.LIBRARY_DOT_A_LINKAGE]) == "true"
library.Properties = properties
return library, nil
}
作者：facchin
项目：arduino-builde
func (s *LibrariesLoader) Run(ctx *types.Context) error {
builtInLibrariesFolders := ctx.BuiltInLibrariesFolders
builtInLibrariesFolders, err := utils.AbsolutizePaths(builtInLibrariesFolders)
if err != nil {
return i18n.WrapError(err)
}
sortedLibrariesFolders := []string{}
sortedLibrariesFolders = utils.AppendIfNotPresent(sortedLibrariesFolders, builtInLibrariesFolders...)
platform := ctx.TargetPlatform
debugLevel := ctx.DebugLevel
logger := ctx.GetLogger()
actualPlatform := ctx.ActualPlatform
if actualPlatform != platform {
sortedLibrariesFolders = appendPathToLibrariesFolders(sortedLibrariesFolders, filepath.Join(actualPlatform.Folder, constants.FOLDER_LIBRARIES))
}
sortedLibrariesFolders = appendPathToLibrariesFolders(sortedLibrariesFolders, filepath.Join(platform.Folder, constants.FOLDER_LIBRARIES))
librariesFolders := ctx.OtherLibrariesFolders
librariesFolders, err = utils.AbsolutizePaths(librariesFolders)
if err != nil {
return i18n.WrapError(err)
}
sortedLibrariesFolders = utils.AppendIfNotPresent(sortedLibrariesFolders, librariesFolders...)
ctx.LibrariesFolders = sortedLibrariesFolders
var libraries []*types.Library
for _, libraryFolder := range sortedLibrariesFolders {
subFolders, err := utils.ReadDirFiltered(libraryFolder, utils.FilterDirs)
if err != nil {
return i18n.WrapError(err)
}
for _, subFolder := range subFolders {
library, err := makeLibrary(filepath.Join(libraryFolder, subFolder.Name()), debugLevel, logger)
if err != nil {
return i18n.WrapError(err)
}
libraries = append(libraries, library)
}
}
ctx.Libraries = libraries
headerToLibraries := make(map[string][]*types.Library)
for _, library := range libraries {
headers, err := utils.ReadDirFiltered(library.SrcFolder, utils.FilterFilesWithExtensions(".h", ".hpp", ".hh"))
if err != nil {
return i18n.WrapError(err)
}
for _, header := range headers {
headerFileName := header.Name()
headerToLibraries[headerFileName] = append(headerToLibraries[headerFileName], library)
}
}
ctx.HeaderToLibraries = headerToLibraries
return nil
}
