def __automake_install_private_headers(self, makefile_am):
# now for the private header files. this is a bit more
# complicated as we have to do it by hand, using the all-local
# hook.
makefile_am.add_all_local('confix-install-local')
makefile_am.add_clean_local('confix-clean-local')
install_local_rule = makefile.Rule(targets=['confix-install-local'], prerequisites=[], commands=[])
clean_local_rule = makefile.Rule(targets=['confix-clean-local'], prerequisites=[], commands=[])
makefile_am.add_element(install_local_rule)
makefile_am.add_element(clean_local_rule)
for installpath, files in self.__private_headers.iterate_dirs():
if len(installpath):
targetdir = '/'.join(['$(top_builddir)', const.LOCAL_INCLUDE_DIR]+installpath)
else:
targetdir = '/'.join(['$(top_builddir)', const.LOCAL_INCLUDE_DIR])
pass
# add mkdir rules for every subdirectory
makefile_am.add_element(
makefile.Rule(targets=[targetdir],
prerequisites=[],
commands=['-$(mkinstalldirs) '+targetdir]))
# copy files
for f in files:
targetfile = '/'.join([targetdir, f])
makefile_am.add_element(
makefile.Rule(targets=[targetfile],
prerequisites=[f],
commands=['-@$(mkinstalldirs) '+targetdir,
'cp -fp $? '+' '+targetdir,
'chmod 0444 '+targetfile]))
makefile_am.add_element(
makefile.Rule(targets=[targetfile+'-clean'],
prerequisites=[],
commands=['rm -f '+targetfile]))
install_local_rule.add_prerequisite(targetfile)
clean_local_rule.add_prerequisite(targetfile+'-clean')
pass
pass
pass
def addAsSourceFileToMakeFile (sourcePath,
make,
BUILD_DIR,
ASBUILD_DIR,
AS_TOOL_WITH_OPTIONS,
includeDirsInCompilerCommand) :
source = os.path.basename (sourcePath)
objectFile = BUILD_DIR + "/" + source + ".o"
objectFileForChecking = BUILD_DIR + "/" + source + ".check.o"
asObjectFile = ASBUILD_DIR + "/" + source + ".s"
if sourcePath != "" :
rule = makefile.Rule ([objectFile], "Assembling " + source)
rule.mOpenSourceOnError = False
rule.mCommand += AS_TOOL_WITH_OPTIONS
rule.mCommand += [sourcePath]
rule.mCommand += ["-o", objectFile]
rule.mCommand += includeDirsInCompilerCommand
rule.mCommand += ["--MD", objectFile + ".dep"]
rule.mDependences.append (sourcePath)
rule.mDependences.append ("makefile.json")
rule.enterSecondaryDependanceFile (objectFile + ".dep", make)
make.addRule (rule)
# objectFileList.append (objectFile)
#--- Add listing file
listingFile = ASBUILD_DIR + "/" + source + ".list"
rule = makefile.Rule ([listingFile], "Assembling -> listing " + source)
rule.mOpenSourceOnError = False
rule.mCommand += AS_TOOL_WITH_OPTIONS
rule.mCommand += [sourcePath]
rule.mCommand += includeDirsInCompilerCommand
rule.mCommand += ["-o", "/dev/null"]
rule.mCommand += ["-aln=" + listingFile]
rule.mDependences.append (sourcePath)
rule.mDependences.append ("makefile.json")
make.addRule (rule)
# asObjectFileList.append (listingFile)
#--- Return ([goal], [objectFile], [listingFile])
return ([objectFile], [listingFile])
def buildDeployment(PRODUCT, deployment, verbose):
goal = PRODUCT + ".uf2"
rule = makefile.Rule([PRODUCT + ".uf2"],
"Converting elf to UF2 " + PRODUCT + ".elf")
rule.mDependences.append(PRODUCT + ".elf")
rule.mDependences.append("makefile.json")
ELF2UF2_TOOL_PATH = download_and_install_elf_to_uf2.compile_install_elf2uf2(
)
rule.mCommand.append(ELF2UF2_TOOL_PATH)
if verbose:
rule.mCommand.append("-v")
rule.mCommand.append(PRODUCT + ".elf")
rule.mCommand.append(PRODUCT + ".uf2")
return (goal, rule)
def run(self):
startTime = time.time()
#--- Source file list
SOURCES = self.mDictionary["SOURCES"]
#--- LIBPM
LIBPM_DIRECTORY_PATH = self.mDictionary["LIBPM_DIRECTORY_PATH"]
#--------------------------------------------------------------------------- System
if self.mCrossCompilation == "":
(SYSTEM_NAME, MODE_NAME, SYSTEM_RELEASE, SYSTEM_VERSION,
MACHINE) = os.uname()
if SYSTEM_NAME == "Darwin":
MACHINE = "Intel"
SYSTEM_MACHINE = SYSTEM_NAME + "-" + MACHINE
else:
SYSTEM_MACHINE = self.mCrossCompilation
#--- GMP
GMP_DIRECTORY_PATH = LIBPM_DIRECTORY_PATH + "/gmp"
#--- Source directory list
SOURCES_DIR = self.mDictionary["SOURCES_DIR"]
#--------------------------------------------------------------------------- Include dirs
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/bdd")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/command_line_interface")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/files")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/galgas")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/galgas2")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/gmp")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/streams")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/time")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/strings")
SOURCES_DIR.append(LIBPM_DIRECTORY_PATH + "/utilities")
includeDirs = ["-I" + GMP_DIRECTORY_PATH]
for d in SOURCES_DIR:
includeDirs.append("-I" + d)
#--- Make object
make = makefile.Make(
self.mGoal, self.mMaxParallelJobs ==
1) # Display command utility tool path if sequential build
#--------------------------------------------------------------------------- Add Compile rule for sources (release)
#--- Object file directory
objectDirectory = "../build/cli-objects/makefile-" + self.mTargetName + "-objects"
#---
objectFileList = []
for source in SOURCES:
objectFile = objectDirectory + "/" + source + ".o"
objectFileList.append(objectFile)
sourcePath = make.searchFileInDirectories(source, SOURCES_DIR)
if sourcePath != "":
extension = os.path.splitext(source)[1]
rule = makefile.Rule([objectFile],
self.mCompilationMessage + ": " + source)
rule.deleteTargetDirectoryOnClean()
rule.mDependences.append(sourcePath)
rule.enterSecondaryDependanceFile(objectFile + ".dep", make)
rule.mCommand += self.mCompilerTool
rule.mCommand += self.mCompilerReleaseOptions
rule.mCommand += self.mAllCompilerOptions
if extension == ".c":
rule.mCommand += self.m_C_CompilerOptions
elif extension == ".cpp":
rule.mCommand += self.m_Cpp_CompilerOptions
rule.mCommand += ["-c", sourcePath]
rule.mCommand += ["-o", objectFile]
rule.mCommand += includeDirs
rule.mCommand += ["-MD", "-MP", "-MF", objectFile + ".dep"]
make.addRule(rule)
#--------------------------------------------------------------------------- Add EXECUTABLE link rule
EXECUTABLE = self.mExecutable + self.mExecutableSuffix
rule = makefile.Rule([EXECUTABLE],
self.mLinkingMessage + ": " + EXECUTABLE)
rule.mOnErrorDeleteTarget = True
rule.deleteTargetFileOnClean()
rule.mDependences += objectFileList
rule.mDependences.append(self.mJSONfilePath)
rule.mCommand += self.mLinkerTool
rule.mCommand += objectFileList
rule.mCommand += ["-o", EXECUTABLE]
rule.mCommand += self.mLinkerOptions
postCommand = makefile.PostCommand(self.mStripMessage + " " +
EXECUTABLE)
postCommand.mCommand += self.mStripTool
postCommand.mCommand.append(EXECUTABLE)
rule.mPostCommands.append(postCommand)
rule.mPriority = 1
make.addRule(rule)
#--------------------------------------------------------------------------- Add Compile rule for sources (debug)
#--- Object file directory
debugObjectDirectory = "../build/cli-objects/makefile-" + self.mTargetName + "-debug-objects"
#---
debugObjectFileList = []
for source in SOURCES:
objectFile = debugObjectDirectory + "/" + source + ".o"
debugObjectFileList.append(objectFile)
sourcePath = make.searchFileInDirectories(source, SOURCES_DIR)
if sourcePath != "":
extension = os.path.splitext(source)[1]
rule = makefile.Rule([objectFile], self.mCompilationMessage +
" (debug): " + source)
rule.deleteTargetDirectoryOnClean()
rule.mDependences.append(sourcePath)
rule.enterSecondaryDependanceFile(objectFile + ".dep", make)
rule.mCommand += self.mCompilerTool
rule.mCommand += self.mCompilerDebugOptions
rule.mCommand += self.mAllCompilerOptions
if extension == ".c":
rule.mCommand += self.m_C_CompilerOptions
elif extension == ".cpp":
rule.mCommand += self.m_Cpp_CompilerOptions
rule.mCommand += ["-c", sourcePath]
rule.mCommand += ["-o", objectFile]
rule.mCommand += includeDirs
rule.mCommand += ["-MD", "-MP", "-MF", objectFile + ".dep"]
make.addRule(rule)
#--------------------------------------------------------------------------- Add EXECUTABLE_DEBUG link rule
EXECUTABLE_DEBUG = self.mExecutable + "-debug" + self.mExecutableSuffix
rule = makefile.Rule([EXECUTABLE_DEBUG], self.mLinkingMessage +
" (debug): " + EXECUTABLE_DEBUG)
rule.mOnErrorDeleteTarget = True
rule.deleteTargetFileOnClean()
rule.mDependences += debugObjectFileList
rule.mDependences.append(self.mJSONfilePath)
rule.mCommand += self.mLinkerTool
rule.mCommand += debugObjectFileList
rule.mCommand += ["-o", EXECUTABLE_DEBUG]
rule.mCommand += self.mLinkerOptions
make.addRule(rule)
#--------------------------------------------------------------------------- Add Compile rule for sources (lto)
#--- Object file directory
objectLTODirectory = "../build/cli-objects/makefile-" + self.mTargetName + "-objects-lto"
#---
ltoObjectFileList = []
for source in SOURCES:
objectFile = objectLTODirectory + "/" + source + ".o"
ltoObjectFileList.append(objectFile)
sourcePath = make.searchFileInDirectories(source, SOURCES_DIR)
if sourcePath != "":
extension = os.path.splitext(source)[1]
rule = makefile.Rule([objectFile], self.mCompilationMessage +
" (lto): " + source)
rule.deleteTargetDirectoryOnClean()
rule.mDependences.append(sourcePath)
rule.enterSecondaryDependanceFile(objectFile + ".dep", make)
rule.mCommand += self.mCompilerTool
rule.mCommand += self.mCompilerReleaseOptions
rule.mCommand += self.mAllCompilerOptions
rule.mCommand += ["-flto"]
if extension == ".c":
rule.mCommand += self.m_C_CompilerOptions
elif extension == ".cpp":
rule.mCommand += self.m_Cpp_CompilerOptions
rule.mCommand += ["-c", sourcePath]
rule.mCommand += ["-o", objectFile]
rule.mCommand += includeDirs
rule.mCommand += ["-MD", "-MP", "-MF", objectFile + ".dep"]
make.addRule(rule)
#--------------------------------------------------------------------------- Add EXECUTABLE link rule
EXECUTABLE_LTO = self.mExecutable + "-lto" + self.mExecutableSuffix
rule = makefile.Rule([EXECUTABLE_LTO],
self.mLinkingMessage + ": " + EXECUTABLE_LTO)
rule.mOnErrorDeleteTarget = True
rule.deleteTargetFileOnClean()
rule.mDependences += ltoObjectFileList
rule.mDependences.append(self.mJSONfilePath)
rule.mCommand += self.mLinkerTool
rule.mCommand += ltoObjectFileList
rule.mCommand += ["-o", EXECUTABLE_LTO]
rule.mCommand += self.mLinkerOptions
rule.mCommand += ["-flto"]
postCommand = makefile.PostCommand(self.mStripMessage + " " +
EXECUTABLE_LTO)
postCommand.mCommand += self.mStripTool
postCommand.mCommand.append(EXECUTABLE_LTO)
rule.mPostCommands.append(postCommand)
rule.mPriority = 1
make.addRule(rule)
#--------------------------------------------------------------------------- Add install EXECUTABLE file rule
if len(self.mSudoTool) > 0:
INSTALL_EXECUTABLE = "/usr/local/bin/" + EXECUTABLE
rule = makefile.Rule([INSTALL_EXECUTABLE],
self.mInstallationgMessage + ": " +
INSTALL_EXECUTABLE)
rule.mDependences.append(EXECUTABLE)
rule.mCommand += self.mSudoTool
rule.mCommand += ["cp", EXECUTABLE, INSTALL_EXECUTABLE]
make.addRule(rule)
#--------------------------------------------------------------------------- Add install EXECUTABLE-lto file rule
if len(self.mSudoTool) > 0:
INSTALL_EXECUTABLE_LTO = "/usr/local/bin/" + EXECUTABLE_LTO
rule = makefile.Rule([INSTALL_EXECUTABLE_LTO],
self.mInstallationgMessage + ": " +
INSTALL_EXECUTABLE_LTO)
rule.mDependences.append(EXECUTABLE)
rule.mCommand += self.mSudoTool
rule.mCommand += ["cp", EXECUTABLE_LTO, INSTALL_EXECUTABLE_LTO]
make.addRule(rule)
#--------------------------------------------------------------------------- Add install EXECUTABLE-debug file rule
if len(self.mSudoTool) > 0:
INSTALL_EXECUTABLE_DEBUG = "/usr/local/bin/" + EXECUTABLE_DEBUG
rule = makefile.Rule([INSTALL_EXECUTABLE_DEBUG],
self.mInstallationgMessage + " (debug): " +
INSTALL_EXECUTABLE_DEBUG)
rule.mDependences.append(INSTALL_EXECUTABLE_DEBUG)
rule.mCommand += self.mSudoTool
rule.mCommand += ["cp", EXECUTABLE_DEBUG, INSTALL_EXECUTABLE_DEBUG]
make.addRule(rule)
#--------------------------------------------------------------------------- Compute jobs
# make.printRules ()
make.addGoal("all", [EXECUTABLE, EXECUTABLE_DEBUG],
"Build " + EXECUTABLE + " and " + EXECUTABLE_DEBUG)
make.addGoal("debug", [EXECUTABLE_DEBUG], "Build " + EXECUTABLE_DEBUG)
make.addGoal("release", [EXECUTABLE], "Build " + EXECUTABLE)
make.addGoal("lto", [EXECUTABLE_LTO], "Build " + EXECUTABLE_LTO)
if len(self.mSudoTool) > 0:
make.addGoal("install-lto", [INSTALL_EXECUTABLE_LTO],
"Build and install " + INSTALL_EXECUTABLE_LTO)
make.addGoal("install-release", [INSTALL_EXECUTABLE],
"Build and install " + INSTALL_EXECUTABLE)
make.addGoal("install-debug", [INSTALL_EXECUTABLE_DEBUG],
"Build and install " + INSTALL_EXECUTABLE_DEBUG)
#--------------------------------------------------------------------------- Run jobs
# make.printGoals ()
make.runGoal(self.mMaxParallelJobs, self.mDisplayCommands)
#--------------------------------------------------------------------------- Ok ?
make.printErrorCountAndExitOnError()
displayDurationFromStartTime(startTime)
cppSourceList.append(projfile.ProjectFile("machines/avr/arduino/cores/arduino/HardwareSerial0.cpp", trampoline_base_path))
cppSourceList.append(projfile.ProjectFile("machines/avr/arduino/cores/arduino/HardwareSerial1.cpp", trampoline_base_path))
cppSourceList.append(projfile.ProjectFile("machines/avr/arduino/cores/arduino/HardwareSerial2.cpp", trampoline_base_path))
cppSourceList.append(projfile.ProjectFile("machines/avr/arduino/cores/arduino/HardwareSerial3.cpp", trampoline_base_path))
cppSourceList.append(projfile.ProjectFile("machines/avr/arduino/cores/arduino/HardwareSerial.cpp", trampoline_base_path))
#----------------------------------------------------------------------
#--- Build the object list and the compiler dependancies
#----------------------------------------------------------------------
objectList = []
for sourceFile in cSourceList:
source = sourceFile.src()
object = sourceFile.obj("build")
depObject = sourceFile.dep("build")
objectList.append(object)
rule = makefile.Rule([object], "Compiling " + source)
rule.deleteTargetDirectoryOnClean()
rule.mDependences.append(source)
rule.mCommand.append(compiler)
rule.mCommand += precflags
rule.mCommand += ["-c", source]
rule.mCommand += ["-o", object]
rule.mCommand += ["-MD", "-MP", "-MF", depObject]
rule.mCommand += cflags
rule.enterSecondaryDependanceFile (depObject, make)
make.addRule(rule)
for sourceFile in cppSourceList:
source = sourceFile.src()
object = sourceFile.obj("build")
depObject = sourceFile.dep("build")
trampoline_base_path = "../../trampoline/"
#----------------------------------------------------------------------
#--- Build the source files list
#----------------------------------------------------------------------
oilSourceList = []
sourceList = []
#--- Add generated files
sourceList.append("conf/tpl_app_config.c")
sourceList.append("conf/tpl_dispatch_table.c")
sourceList.append("conf/tpl_invoque.S")
sourceList.append("conf/tpl_interrupts.c")
rule = makefile.Rule(sourceList, "Compiling OIL file " + oilFile)
rule.deleteTargetFileOnClean()
rule.mDeleteTargetOnError = True
rule.mDependences.append(oilFile)
rule.enterSecondaryDependanceFile(oilFileDep, make)
rule.mCommand.append("goil")
rule.mCommand += oilFlags
rule.mCommand.append(oilFile)
make.addRule(rule)
make.addGoal("all", sourceList, "Building all")
if goal == "all" or goal == "clean":
make.runGoal(maxParallelJobs, maxParallelJobs == 1)
#----------------------------------------------------------------------
def buildCode(GOAL, projectDir, maxConcurrentJobs, showCommand):
#--------------------------------------------------------------------------- Prepare
os.chdir(projectDir)
make = makefile.Make(GOAL)
make.mMacTextEditor = "TextWrangler" # "Atom"
allGoal = []
#--------------------------------------------------------------------------- Install Linux UDEV rules ?
platform = dev_platform.getPlatform()
if (platform == "linux") or (platform == "linux32"):
import udev_on_linux
udev_on_linux.installUDEVrulesOnLinux()
#--------------------------------------------------------------------------- Install compiler ?
BASE_NAME = "arm-none-eabi"
TOOL_DIR = download_and_install_gccarm.installGCCARMandGetToolDirectory()
AS_TOOL_WITH_OPTIONS = [
TOOL_DIR + "/bin/" + BASE_NAME + "-as", "-mthumb", "-mcpu=cortex-m4"
]
COMPILER_TOOL_WITH_OPTIONS = [
TOOL_DIR + "/bin/" + BASE_NAME + "-gcc", "-mthumb", "-mcpu=cortex-m4"
]
LD_TOOL_WITH_OPTIONS = [TOOL_DIR + "/bin/" + BASE_NAME + "-ld"]
LD_TOOL_WITH_OPTIONS = COMPILER_TOOL_WITH_OPTIONS
OBJCOPY_TOOL_WITH_OPTIONS = [TOOL_DIR + "/bin/" + BASE_NAME + "-objcopy"]
DISPLAY_OBJ_SIZE_TOOL = [TOOL_DIR + "/bin/" + BASE_NAME + "-size"]
OBJDUMP_TOOL = TOOL_DIR + "/bin/" + BASE_NAME + "-objdump"
#--------------------------------------------------------------------------- Install Teensy loader CLI ?
TEENSY_CLI_LOADER_PATH = teensy_cli_loader_builder.buildAndGetPath(
TOOL_DIR + "/bin")
#--------------------------------------------------------------------------- Analyze JSON file
print(makefile.BOLD_GREEN() + "--- Making " + projectDir + makefile.ENDC())
dictionaire = dictionaryFromJsonFile(projectDir + "/makefile.json")
#--- TEENSY
linkerScript = "common-sources/teensy-3-6.ld"
teensyName = "TEENSY36"
#--- ASSERTION_GENERATION
ASSERTION_GENERATION = False
if ("ASSERTION-GENERATION"
in dictionaire) and dictionaire["ASSERTION-GENERATION"]:
ASSERTION_GENERATION = True
#--- CPU_MHZ
CPU_MHZ = 0
if "CPU-MHZ" in dictionaire:
CPU_MHZ = dictionaire["CPU-MHZ"]
#--- SOURCE_FILE_DIRECTORIES
SOURCE_FILE_DIRECTORIES = []
if "SOURCE-DIR" in dictionaire:
SOURCE_FILE_DIRECTORIES = dictionaire["SOURCE-DIR"]
#--- GROUP_SOURCES
GROUP_SOURCES = False
if "GROUP-SOURCES" in dictionaire:
GROUP_SOURCES = dictionaire["GROUP-SOURCES"]
#--- TASK_COUNT
TASK_COUNT = "0" # Means TASK_COUNT is not defined by JSON file
if "TASK-COUNT" in dictionaire:
TASK_COUNT = str(dictionaire["TASK-COUNT"])
#--- LTO
usesLTO = False
if ("LTO" in dictionaire) and dictionaire["LTO"]:
usesLTO = True
#--- SERVICE
serviceScheme = ""
if "SERVICE-SCHEME" in dictionaire:
serviceScheme = dictionaire["SERVICE-SCHEME"]
#--- SECTION
sectionScheme = ""
if "SECTION-SCHEME" in dictionaire:
sectionScheme = dictionaire["SECTION-SCHEME"]
#--------------------------------------------------------------------------- Directories
BUILD_DIR = common_definitions.buildDirectory()
GENERATED_SOURCE_DIR = common_definitions.generatedSourceDirectory()
PRODUCT_DIR = common_definitions.productDirectory()
ASBUILD_DIR = common_definitions.asDirectory()
#--------------------------------------------------------------------------- Build source lists
includeDirsInCompilerCommand = [
"-I", GENERATED_SOURCE_DIR, "-I", projectDir
]
H_SOURCE_LIST = []
CPP_SOURCE_LIST = []
S_SOURCE_LIST = []
for f in SOURCE_FILE_DIRECTORIES:
for root, dirs, files in os.walk(f):
includeDirsInCompilerCommand += ["-I", root]
for name in files:
sourcePath = os.path.join(root, name)
(b, extension) = os.path.splitext(sourcePath)
if extension == ".cpp":
CPP_SOURCE_LIST.append(sourcePath)
elif extension == ".h":
H_SOURCE_LIST.append(sourcePath)
elif extension == ".s":
S_SOURCE_LIST.append(sourcePath)
elif extension == ".ld":
pass # Ignored file
elif extension != "": # Ceci permet d'ignorer les fichés cachés (dont les noms commencent par un point)
print(makefile.MAGENTA() + makefile.BOLD() +
"Note: unhandled file " + sourcePath +
makefile.ENDC())
#--------------------------------------------------------------------------- Build base header file
baseHeader_file = GENERATED_SOURCE_DIR + "/base.h"
H_SOURCE_LIST.insert(0, baseHeader_file)
rule = makefile.Rule([baseHeader_file], "Build base header file")
rule.mOpenSourceOnError = False
rule.mDependences.append("makefile.json")
rule.mCommand += [
"python", "../../dev-files/build_base_header_file.py", baseHeader_file,
str(CPU_MHZ), TASK_COUNT, teensyName,
"1" if ASSERTION_GENERATION else "0"
]
rule.mPriority = -1
make.addRule(rule)
#--------------------------------------------------------------------------- Build all header file
allHeadersSecondaryDependenceFile = BUILD_DIR + "/all-headers.dep"
allHeaders_file = GENERATED_SOURCE_DIR + "/all-headers.h"
rule = makefile.Rule([allHeaders_file, allHeadersSecondaryDependenceFile],
"Build all headers file")
rule.mOpenSourceOnError = False
rule.mDependences.append("makefile.json")
rule.mDependences += H_SOURCE_LIST
rule.mCommand += [
"python", "../../dev-files/build_all_header_file.py", allHeaders_file,
allHeadersSecondaryDependenceFile
]
rule.mCommand += H_SOURCE_LIST
rule.enterSecondaryDependanceFile(allHeadersSecondaryDependenceFile, make)
rule.mPriority = -1
make.addRule(rule)
#--------------------------------------------------------------------------- Build interrupt handler files
interruptHandlerSFile = GENERATED_SOURCE_DIR + "/interrupt-handlers.s"
interruptHandlerCppFile = GENERATED_SOURCE_DIR + "/interrupt-handler-helper.cpp"
S_SOURCE_LIST.append(interruptHandlerSFile)
CPP_SOURCE_LIST.append(interruptHandlerCppFile)
rule = makefile.Rule([interruptHandlerSFile, interruptHandlerCppFile],
"Build interrupt files")
rule.mOpenSourceOnError = False
rule.mDependences += H_SOURCE_LIST
rule.mDependences.append("makefile.json")
rule.mDependences.append("../../dev-files/build_interrupt_handlers.py")
rule.mCommand += ["python", "../../dev-files/build_interrupt_handlers.py"]
rule.mCommand += [interruptHandlerCppFile]
rule.mCommand += [interruptHandlerSFile]
rule.mCommand += [serviceScheme]
rule.mCommand += [sectionScheme]
rule.mCommand += H_SOURCE_LIST
rule.mPriority = -1
make.addRule(rule)
#--------------------------------------------------------------------------- Group sources ?
if GROUP_SOURCES:
allSourceFile = GENERATED_SOURCE_DIR + "/all-sources.cpp"
rule = makefile.Rule([allSourceFile], "Group all sources")
rule.mOpenSourceOnError = False
rule.mDependences += CPP_SOURCE_LIST
rule.mDependences.append("makefile.json")
rule.mCommand += [
"python", "../../dev-files/build_grouped_sources.py", allSourceFile
]
rule.mCommand += CPP_SOURCE_LIST
rule.mPriority = -1
make.addRule(rule)
CPP_SOURCE_LIST = [allSourceFile]
#--------------------------------------------------------------------------- Build makefile rules
objectFileList = []
asObjectFileList = []
#--- CPP source files
for sourcePath in CPP_SOURCE_LIST:
source = os.path.basename(sourcePath)
objectFile = BUILD_DIR + "/" + source + ".o"
objectFileForChecking = BUILD_DIR + "/" + source + ".check.o"
asObjectFile = BUILD_DIR + "/" + source + ".s"
#--- Checking source
rule = makefile.Rule([objectFileForChecking], "Checking " + source)
rule.mOpenSourceOnError = False
rule.mDependences.append(allHeaders_file)
rule.mDependences.append(sourcePath)
rule.mDependences.append("makefile.json")
rule.enterSecondaryDependanceFile(objectFileForChecking + ".dep", make)
rule.mCommand += COMPILER_TOOL_WITH_OPTIONS
rule.mCommand += common_definitions.checkModeOptions()
rule.mCommand += common_definitions.C_Cpp_optimizationOptions()
rule.mCommand += common_definitions.Cpp_actualOptions(False)
rule.mCommand += ["-c", sourcePath]
rule.mCommand += ["-o", objectFileForChecking]
rule.mCommand += ["-DSTATIC="]
rule.mCommand += includeDirsInCompilerCommand
rule.mCommand += ["-MD", "-MP", "-MF", objectFileForChecking + ".dep"]
make.addRule(rule)
rule.mPriority = -1
allGoal.append(objectFileForChecking)
#--- Compile source
rule = makefile.Rule([objectFile], "Compiling " + source)
rule.mOpenSourceOnError = False
rule.mCommand += COMPILER_TOOL_WITH_OPTIONS
rule.mCommand += common_definitions.C_Cpp_optimizationOptions()
rule.mCommand += common_definitions.Cpp_actualOptions(usesLTO)
rule.mCommand += ["-g"]
rule.mCommand += ["-c", sourcePath]
rule.mCommand += ["-o", objectFile]
rule.mCommand += ["-DSTATIC=static __attribute__((unused))"
] if GROUP_SOURCES else ["-DSTATIC="]
rule.mCommand += includeDirsInCompilerCommand
rule.mCommand += ["-MD", "-MP", "-MF", objectFile + ".dep"]
rule.mDependences.append(allHeaders_file)
rule.mDependences.append(sourcePath)
rule.mDependences.append("makefile.json")
rule.enterSecondaryDependanceFile(objectFile + ".dep", make)
make.addRule(rule)
objectFileList.append(objectFile)
#--- objdump python source
objdumpPythonFile = BUILD_DIR + "/" + source + ".objdump.py"
rule = makefile.Rule([objdumpPythonFile],
"Building " + source + ".objdump.py")
rule.mDependences.append(objectFile)
rule.mDependences.append("makefile.json")
rule.mCommand += [
"python", "../../dev-files/build_objdump.py", OBJDUMP_TOOL, source,
objdumpPythonFile
]
rule.mPriority = -1
make.addRule(rule)
allGoal.append(objdumpPythonFile)
#--- AS rule
rule = makefile.Rule([asObjectFile], "Compiling -> s " + source)
rule.mOpenSourceOnError = False
rule.mCommand += COMPILER_TOOL_WITH_OPTIONS
rule.mCommand += common_definitions.C_Cpp_optimizationOptions()
rule.mCommand += common_definitions.Cpp_actualOptions(usesLTO)
rule.mCommand += ["-S", sourcePath]
rule.mCommand += ["-o", asObjectFile]
rule.mCommand += ["-DSTATIC="]
rule.mCommand += includeDirsInCompilerCommand
rule.mCommand += ["-MD", "-MP", "-MF", asObjectFile + ".dep"]
rule.mDependences.append(sourcePath)
rule.mDependences.append(allHeaders_file)
rule.mDependences.append("makefile.json")
rule.enterSecondaryDependanceFile(asObjectFile + ".dep", make)
make.addRule(rule)
#--- AS rule, getting output assembler file
listingFile = ASBUILD_DIR + "/" + source + ".s.list"
rule = makefile.Rule([listingFile], "Assembling -> listing " + source)
rule.mOpenSourceOnError = False
rule.mCommand += AS_TOOL_WITH_OPTIONS
rule.mCommand += [asObjectFile]
rule.mCommand += ["-o", "/dev/null"]
rule.mCommand += ["-aln=" + listingFile]
rule.mDependences.append(asObjectFile)
rule.mDependences.append(allHeaders_file)
rule.mDependences.append("makefile.json")
make.addRule(rule)
asObjectFileList.append(listingFile)
#-- Add ARM S files
for sourcePath in S_SOURCE_LIST:
source = os.path.basename(sourcePath)
objectFile = BUILD_DIR + "/" + source + ".o"
objectFileForChecking = BUILD_DIR + "/" + source + ".check.o"
asObjectFile = ASBUILD_DIR + "/" + source + ".s"
if sourcePath != "":
rule = makefile.Rule([objectFile], "Assembling " + source)
rule.mOpenSourceOnError = False
rule.mCommand += AS_TOOL_WITH_OPTIONS
rule.mCommand += [sourcePath]
rule.mCommand += ["-o", objectFile]
rule.mCommand += includeDirsInCompilerCommand
rule.mCommand += ["--MD", objectFile + ".dep"]
rule.mDependences.append(sourcePath)
rule.mDependences.append("makefile.json")
rule.enterSecondaryDependanceFile(objectFile + ".dep", make)
make.addRule(rule)
objectFileList.append(objectFile)
#--- Add listing file
listingFile = ASBUILD_DIR + "/" + source + ".list"
rule = makefile.Rule([listingFile],
"Assembling -> listing " + source)
rule.mOpenSourceOnError = False
rule.mCommand += AS_TOOL_WITH_OPTIONS
rule.mCommand += [sourcePath]
rule.mCommand += ["-o", "/dev/null"]
rule.mCommand += ["-aln=" + listingFile]
rule.mDependences.append(sourcePath)
rule.mDependences.append("makefile.json")
make.addRule(rule)
asObjectFileList.append(listingFile)
#--------------------------------------------------------------------------- Link for internal flash
PRODUCT_INTERNAL_FLASH = PRODUCT_DIR + "/product"
LINKER_SCRIPT_INTERNAL_FLASH = "../../dev-files/" + linkerScript
allGoal.append(PRODUCT_INTERNAL_FLASH + ".elf")
#--- Add link rule
rule = makefile.Rule([PRODUCT_INTERNAL_FLASH + ".elf"],
"Linking " + PRODUCT_INTERNAL_FLASH + ".elf")
rule.mDependences += objectFileList
rule.mDependences.append(LINKER_SCRIPT_INTERNAL_FLASH)
rule.mDependences.append("makefile.json")
rule.mCommand += LD_TOOL_WITH_OPTIONS
rule.mCommand += objectFileList
rule.mCommand += ["-T" + LINKER_SCRIPT_INTERNAL_FLASH]
rule.mCommand.append("-Wl,-Map=" + PRODUCT_INTERNAL_FLASH + ".map")
rule.mCommand += common_definitions.commonLinkerFlags(usesLTO)
rule.mCommand += ["-o", PRODUCT_INTERNAL_FLASH + ".elf"]
make.addRule(rule)
#--- Add hex rule
allGoal.append(PRODUCT_INTERNAL_FLASH + ".hex")
rule = makefile.Rule([PRODUCT_INTERNAL_FLASH + ".hex"],
"Hexing " + PRODUCT_INTERNAL_FLASH + ".hex")
rule.mDependences.append(PRODUCT_INTERNAL_FLASH + ".elf")
rule.mDependences.append("makefile.json")
rule.mCommand += OBJCOPY_TOOL_WITH_OPTIONS
rule.mCommand.append("-O")
rule.mCommand.append("ihex")
rule.mCommand.append(PRODUCT_INTERNAL_FLASH + ".elf")
rule.mCommand.append(PRODUCT_INTERNAL_FLASH + ".hex")
make.addRule(rule)
#--------------------------------------------------------------------------- Goals
make.addGoal("all", allGoal, "Build all")
make.addGoal("run", allGoal, "Building all and run")
make.addGoal("view-hex", allGoal, "Building all and show hex")
make.addGoal("display-obj-size", allGoal,
"Build binaries and display object sizes")
make.addGoal("as", asObjectFileList, "Compile C and C++ to assembly")
#--------------------------------------------------------------------------- Run jobs
#make.printRules ()
#make.checkRules ()
# make.writeRuleDependancesInDotFile ("dependances.dot")
make.runGoal(maxConcurrentJobs, showCommand)
#--------------------------------------------------------------------------- Ok ?
make.printErrorCountAndExitOnError()
#---------------------------------------------------------------------------- "display-obj-size"
if GOAL == "display-obj-size":
makefile.runCommand(DISPLAY_OBJ_SIZE_TOOL + objectFileList + ["-t"],
"Display Object Size", False, showCommand)
#---------------------------------------------------------------------------- "All" or "run"
if (GOAL == "all") or (GOAL == "run") or (GOAL == "view-hex"):
s = runProcessAndGetOutput(DISPLAY_OBJ_SIZE_TOOL + ["-t"] +
[PRODUCT_INTERNAL_FLASH + ".elf"])
secondLine = s.split('\n')[1]
numbers = [int(s) for s in secondLine.split() if s.isdigit()]
print(" ROM code: " + str(numbers[0]) + " bytes")
print(" ROM data: " + str(numbers[1]) + " bytes")
print(" RAM + STACK: " + str(numbers[2]) + " bytes")
#----------------------------------------------- Run ?
if GOAL == "run":
FLASH_TEENSY = [TEENSY_CLI_LOADER_PATH, "-w", "-v", "-mmcu=TEENSY36"]
print(makefile.BOLD_BLUE() + "Loading Teensy..." + makefile.ENDC())
runProcess(FLASH_TEENSY + [PRODUCT_INTERNAL_FLASH + ".hex"])
print(makefile.BOLD_GREEN() + "Success" + makefile.ENDC())
elif GOAL == "view-hex":
print(makefile.BOLD_GREEN() + "View hex..." + makefile.ENDC())
scriptDir = os.path.dirname(os.path.abspath(__file__))
runProcess([
"python", scriptDir + "/view-hex.py",
PRODUCT_INTERNAL_FLASH + ".hex"
])
def addCppSourceFileToMakeFile (sourcePath,
make,
BUILD_DIR,
allHeadersSecondaryDependenceFile,
COMPILER_TOOL_WITH_OPTIONS,
includeDirsInCompilerCommand,
usesLTO,
GROUP_SOURCES,
allHeaders_file,
ASBUILD_DIR,
AS_TOOL_WITH_OPTIONS) :
source = os.path.basename (sourcePath)
objectFile = BUILD_DIR + "/" + source + ".o"
objectFileForChecking = BUILD_DIR + "/" + source + ".check.o"
asObjectFile = BUILD_DIR + "/" + source + ".s"
#--- Checking source
rule1 = makefile.Rule ([objectFileForChecking], "Checking " + source)
rule1.mOpenSourceOnError = False
rule1.mDependences.append (allHeadersSecondaryDependenceFile)
# rule1.mDependences.append (precompiledHeader_file)
rule1.mDependences.append (sourcePath)
rule1.mDependences.append ("makefile.json")
rule1.enterSecondaryDependanceFile (objectFileForChecking + ".dep", make)
rule1.mCommand += COMPILER_TOOL_WITH_OPTIONS
rule1.mCommand += ["-x", "c++"]
rule1.mCommand += common_definitions.checkModeOptions ()
rule1.mCommand += common_definitions.C_Cpp_optimizationOptions ()
rule1.mCommand += common_definitions.Cpp_actualOptions (False)
rule1.mCommand += ["-c", sourcePath]
rule1.mCommand += ["-o", objectFileForChecking]
rule1.mCommand += ["-DSTATIC="]
rule1.mCommand += includeDirsInCompilerCommand
rule1.mCommand += ["-MD", "-MP", "-MF", objectFileForChecking + ".dep"]
make.addRule (rule1)
rule1.mPriority = -1
# allGoal.append (objectFileForChecking)
#--- Compile source
rule2 = makefile.Rule ([objectFile], "Compiling " + source)
rule2.mOpenSourceOnError = False
rule2.mCommand += COMPILER_TOOL_WITH_OPTIONS
rule2.mCommand += common_definitions.C_Cpp_optimizationOptions ()
rule2.mCommand += common_definitions.Cpp_actualOptions (usesLTO)
rule2.mCommand += ["-g"]
rule2.mCommand += ["-c", sourcePath]
rule2.mCommand += ["-o", objectFile]
rule2.mCommand += ["-DSTATIC=static __attribute__((unused))"] if GROUP_SOURCES else ["-DSTATIC="]
rule2.mCommand += includeDirsInCompilerCommand
rule2.mCommand += ["-MD", "-MP", "-MF", objectFile + ".dep"]
rule2.mDependences.append (allHeadersSecondaryDependenceFile)
## rule2.mDependences.append (precompiledHeader_file)
rule2.mDependences.append (sourcePath)
rule2.mDependences.append ("makefile.json")
rule2.enterSecondaryDependanceFile (objectFile + ".dep", make)
make.addRule (rule2)
# objectFileList.append (objectFile)
#--- AS rule
rule3 = makefile.Rule ([asObjectFile], "Compiling -> s " + source)
rule3.mOpenSourceOnError = False
rule3.mCommand += COMPILER_TOOL_WITH_OPTIONS
rule3.mCommand += common_definitions.C_Cpp_optimizationOptions ()
rule3.mCommand += common_definitions.Cpp_actualOptions (usesLTO)
rule3.mCommand += ["-S", sourcePath]
rule3.mCommand += ["-o", asObjectFile]
rule3.mCommand += ["-DSTATIC="]
rule3.mCommand += includeDirsInCompilerCommand
rule3.mCommand += ["-MD", "-MP", "-MF", asObjectFile + ".dep"]
rule3.mDependences.append (sourcePath)
rule3.mDependences.append (allHeaders_file)
rule3.mDependences.append ("makefile.json")
rule3.enterSecondaryDependanceFile (asObjectFile + ".dep", make)
make.addRule (rule3)
#--- AS rule, getting output assembler file
listingFile = ASBUILD_DIR + "/" + source + ".s.list"
rule4 = makefile.Rule ([listingFile], "Assembling -> listing " + source)
rule4.mOpenSourceOnError = False
rule4.mCommand += AS_TOOL_WITH_OPTIONS
rule4.mCommand += [asObjectFile]
rule4.mCommand += ["-o", "/dev/null"]
rule4.mCommand += ["-aln=" + listingFile]
rule4.mDependences.append (asObjectFile)
rule4.mDependences.append (allHeaders_file)
rule4.mDependences.append ("makefile.json")
make.addRule (rule4)
# asObjectFileList.append (listingFile)
#--- Return ([goal], [objectFile], [listingFile])
return ([objectFileForChecking], [objectFile], [listingFile])
def buildCode (GOAL, projectDir, maxConcurrentJobs, verbose):
DEV_FILES_DIR = os.path.dirname (os.path.realpath (__file__))
# print ("DEV_FILES_DIR: " + DEV_FILES_DIR)
#--------------------------------------------------------------------------- Prepare
os.chdir (projectDir)
make = makefile.Make (GOAL)
# make.mMacTextEditor = "BBEdit" # "Atom"
allGoal = []
#--------------------------------------------------------------------------- Analyze JSON file
print (makefile.BOLD_GREEN () + "--- Making " + projectDir + makefile.ENDC ())
dictionaire = dictionaryFromJsonFile (projectDir + "/makefile.json")
# print ("JSON DICTIONARY: ")
# print (dictionaire)
#--------------------------------------------------------------------------- Find target
targetNameSet = set ()
foundIRQSectionScheme = False
for name in os.listdir (DEV_FILES_DIR + "/targets") :
if not name.startswith ('.') :
targetNameSet.add (name)
if not "TARGET" in dictionaire:
s = "\"TARGET\" is not defined in the makefile.json file; possible values:\n"
for target in targetNameSet :
s += " - \"" + target + "\"\n"
print (makefile.BOLD_RED () + s + makefile.ENDC ())
sys.exit (1)
targetName = dictionaire ["TARGET"]
if not targetName in targetNameSet :
s = "In the makefile.json file, \"TARGET\" value \"" + targetName + "\" is invalid; "
s += "possible values:\n"
for target in targetNameSet :
s += " - \"" + target + "\"\n"
print (makefile.BOLD_RED () + s + makefile.ENDC ())
sys.exit (1)
TARGET_DIR = DEV_FILES_DIR + "/targets/" + targetName
sys.path.append (TARGET_DIR + "/deployment")
import deployment
#--------------------------------------------------------------------------- Install compiler ?
BASE_NAME = "arm-none-eabi"
TOOL_DIR = download_and_install_gccarm.installGCCARMandGetToolDirectory ()
#--------------------------------------------------------------------------- Target Dictionary
targetDictionary = dictionaryFromJsonFile (TARGET_DIR + "/helpers/target-parameters.json")
#--------------------------------------------------------------------------- Configure compiler
gccOptions = targetDictionary ["GCC-OPTIONS"]
AS_TOOL_WITH_OPTIONS = [TOOL_DIR + "/bin/" + BASE_NAME + "-as"]
AS_TOOL_WITH_OPTIONS += gccOptions
COMPILER_TOOL_WITH_OPTIONS = [TOOL_DIR + "/bin/" + BASE_NAME + "-gcc"]
COMPILER_TOOL_WITH_OPTIONS += gccOptions
# LD_TOOL_WITH_OPTIONS = [TOOL_DIR + "/bin/" + BASE_NAME + "-ld"]
LD_TOOL_WITH_OPTIONS = COMPILER_TOOL_WITH_OPTIONS
# OBJCOPY_TOOL_WITH_OPTIONS = [TOOL_DIR + "/bin/" + BASE_NAME + "-objcopy"]
DISPLAY_OBJ_SIZE_TOOL = [TOOL_DIR + "/bin/" + BASE_NAME + "-size"]
# OBJDUMP_TOOL = TOOL_DIR + "/bin/" + BASE_NAME + "-objdump"
#--------------------------------------------------------------------------- Parse JSON dictinary
#--- SCHEME
if "SCHEME" in dictionaire:
SCHEME = dictionaire ["SCHEME"]
schemeFilePath = TARGET_DIR + "/schemes/" + SCHEME + ".json"
if os.path.exists (schemeFilePath) :
schemeDictionary = dictionaryFromJsonFile (schemeFilePath)
dictionaire ["UNUSED-IRQ-SCHEME"] = schemeDictionary ["UNUSED-IRQ-SCHEME"]
dictionaire ["IRQ-SECTION-SCHEME"] = schemeDictionary ["IRQ-SECTION-SCHEME"]
dictionaire ["SERVICE-SCHEME"] = schemeDictionary ["SERVICE-SCHEME"]
dictionaire ["SECTION-SCHEME"] = schemeDictionary ["SECTION-SCHEME"]
dictionaire ["SOURCES-IN-DEV-DIR"] = schemeDictionary ["SOURCES-IN-DEV-DIR"]
else:
print (makefile.RED () + makefile.BOLD () + "Unknow scheme '" + SCHEME + "'" + makefile.ENDC ())
sys.exit (1)
#--- CPU_MHZ
CPU_MHZ = 0
if "CPU-MHZ" in dictionaire:
CPU_MHZ = dictionaire ["CPU-MHZ"]
#--- ASSERTION_GENERATION
ASSERTION_GENERATION = False
if "ASSERTION-GENERATION" in dictionaire :
ASSERTION_GENERATION = dictionaire ["ASSERTION-GENERATION"]
#--- USER SOURCE_FILE_DIRECTORIES
SOURCE_FILE_DIRECTORIES = []
if "SOURCE-DIR" in dictionaire :
SOURCE_FILE_DIRECTORIES = dictionaire ["SOURCE-DIR"]
#--- SYSTEM SOURCE_FILE_DIRECTORIES
if "SOURCES-IN-DEV-DIR" in dictionaire :
sourcesInDevDir = dictionaire ["SOURCES-IN-DEV-DIR"]
for d in sourcesInDevDir :
SOURCE_FILE_DIRECTORIES.append (TARGET_DIR + "/sources/" + d)
#--- GROUP_SOURCES
GROUP_SOURCES = False
if "GROUP-SOURCES" in dictionaire:
GROUP_SOURCES = dictionaire ["GROUP-SOURCES"]
#--- TASK_COUNT
TASK_COUNT = "0" # Means TASK_COUNT is not defined by JSON file
if "TASK-COUNT" in dictionaire :
TASK_COUNT = str (dictionaire ["TASK-COUNT"])
#--- LTO
usesLTO = False
if "LTO" in dictionaire :
usesLTO = dictionaire ["LTO"]
#--- SERVICE
serviceScheme = ""
if "SERVICE-SCHEME" in dictionaire :
serviceScheme = dictionaire ["SERVICE-SCHEME"]
#--- SECTION
sectionScheme = ""
if "SECTION-SCHEME" in dictionaire :
sectionScheme = dictionaire ["SECTION-SCHEME"]
#--- IRQ SECTION
irqSectionScheme = ""
if "IRQ-SECTION-SCHEME" in dictionaire :
irqSectionScheme = dictionaire ["IRQ-SECTION-SCHEME"]
#--- UNUSED IRQ
unusedIRQScheme = ""
if "UNUSED-IRQ-SCHEME" in dictionaire :
unusedIRQScheme = dictionaire ["UNUSED-IRQ-SCHEME"]
#--- DEPLOYMENT
selectedDeployments = []
if "DEPLOYMENT" in dictionaire :
selectedDeployments = dictionaire ["DEPLOYMENT"]
#--------------------------------------------------------------------------- Directories
BUILD_DIR = common_definitions.buildDirectory ()
GENERATED_SOURCE_DIR = common_definitions.generatedSourceDirectory ()
PRODUCT_DIR = common_definitions.productDirectory ()
ASBUILD_DIR = common_definitions.asDirectory ()
#--------------------------------------------------------------------------- Build source lists
includeDirsInCompilerCommand = ["-I", GENERATED_SOURCE_DIR]
H_SOURCE_SET = set ()
H_SOURCE_LIST = []
CPP_SOURCE_LIST = []
S_SOURCE_LIST = []
for f in SOURCE_FILE_DIRECTORIES :
for root, dirs, files in os.walk (f) :
includeDirsInCompilerCommand += ["-I", root]
for name in files:
sourcePath = os.path.join (root, name)
(b, extension) = os.path.splitext (sourcePath)
if extension == ".cpp" :
CPP_SOURCE_LIST.append (sourcePath)
elif extension == ".h" :
H_SOURCE_LIST.append (sourcePath)
if sourcePath in H_SOURCE_SET :
print (makefile.BOLD_RED () + "Duplicated header file \"" + sourcePath + "\"" + makefile.ENDC ())
H_SOURCE_SET.add (sourcePath)
elif extension == ".s" :
S_SOURCE_LIST.append (sourcePath)
elif extension == ".hs" :
pass # Ok
elif extension == ".ld" :
pass # Ok
elif extension != "" : # Ceci permet d'ignorer les fichés cachés (dont les noms commencent par un point)
print (makefile.MAGENTA () + makefile.BOLD () + "Note: unhandled file " + sourcePath + makefile.ENDC ())
#--------------------------------------------------------------------------- Build base header file
baseHeader_file = GENERATED_SOURCE_DIR + "/base.h"
H_SOURCE_LIST.insert (0, baseHeader_file)
rule = makefile.Rule ([baseHeader_file], "Build base header file")
rule.mOpenSourceOnError = False
rule.mDependences.append ("makefile.json")
rule.mCommand += [DEV_FILES_DIR + "/build_base_header_file.py", baseHeader_file, str (CPU_MHZ), TASK_COUNT, targetName, "1" if ASSERTION_GENERATION else "0"]
rule.mPriority = -1
make.addRule (rule)
#--------------------------------------------------------------------------- Build all header file
allHeadersSecondaryDependenceFile = BUILD_DIR + "/all-headers.dep"
allHeaders_file = GENERATED_SOURCE_DIR + "/all-headers.h"
rule = makefile.Rule ([allHeaders_file, allHeadersSecondaryDependenceFile], "Build all headers file")
rule.mOpenSourceOnError = False
rule.mDependences.append ("makefile.json")
rule.mDependences += H_SOURCE_LIST
rule.mCommand += [DEV_FILES_DIR + "/build_all_header_file.py", allHeaders_file, allHeadersSecondaryDependenceFile]
rule.mCommand += H_SOURCE_LIST
rule.enterSecondaryDependanceFile (allHeadersSecondaryDependenceFile, make)
rule.mPriority = -1
make.addRule (rule)
#--------------------------------------------------------------------------- Build precompiled header file
# allHeadersSecondaryDependenceFile = GENERATED_SOURCE_DIR + "/all-headers.h"
# precompiledHeader_file = GENERATED_SOURCE_DIR + "/all-headers.h.gch"
# rule = makefile.Rule ([precompiledHeader_file], "Build Precompiled header file")
# rule.mOpenSourceOnError = False
# rule.mDependences.append ("makefile.json")
# rule.mDependences.append (allHeadersSecondaryDependenceFile)
# rule.mCommand += COMPILER_TOOL_WITH_OPTIONS
# rule.mCommand += ["-DSTATIC=static __attribute__((unused))"] if GROUP_SOURCES else ["-DSTATIC="]
# rule.mCommand += common_definitions.checkModeOptions ()
# rule.mCommand += common_definitions.C_Cpp_optimizationOptions ()
# rule.mCommand += common_definitions.Cpp_actualOptions (False)
# rule.mCommand += includeDirsInCompilerCommand
# rule.mCommand += ["-x", "c++-header", allHeadersSecondaryDependenceFile]
# rule.mCommand += ["-o", precompiledHeader_file]
# rule.mPriority = -1
# make.addRule (rule)
# allGoal.append (precompiledHeader_file)
#-------------------------------------------------------------- --- Build interrupt handler files
interruptHandlerSFile = GENERATED_SOURCE_DIR + "/interrupt-handlers-assembly.s"
interruptHandlerCppFile = GENERATED_SOURCE_DIR + "/interrupt-handlers-cpp.cpp"
S_SOURCE_LIST.append (interruptHandlerSFile)
CPP_SOURCE_LIST.append (interruptHandlerCppFile)
rule = makefile.Rule ([interruptHandlerSFile, interruptHandlerCppFile], "Build interrupt files")
rule.mOpenSourceOnError = False
rule.mDependences += H_SOURCE_LIST
rule.mDependences.append ("makefile.json")
rule.mDependences.append (DEV_FILES_DIR + "/build_interrupt_handlers.py")
if serviceScheme != "" :
rule.mDependences.append (TARGET_DIR + "/generators-service/" + serviceScheme + "/service_generator.py")
if sectionScheme != "" :
rule.mDependences.append (TARGET_DIR + "/generators-section/" + sectionScheme + "/section_generator.py")
if irqSectionScheme != "" :
rule.mDependences.append (TARGET_DIR + "/generators-irq-section/" + irqSectionScheme + "/irq_section_generator.py")
if unusedIRQScheme != "" :
rule.mDependences.append (TARGET_DIR + "/generators-unused-irq/" + unusedIRQScheme + "/unused_irq_generator.py")
rule.mCommand += [DEV_FILES_DIR + "/build_interrupt_handlers.py"]
rule.mCommand += [TARGET_DIR]
rule.mCommand += [interruptHandlerCppFile]
rule.mCommand += [interruptHandlerSFile]
rule.mCommand += [serviceScheme]
rule.mCommand += [sectionScheme]
rule.mCommand += [irqSectionScheme]
rule.mCommand += [unusedIRQScheme]
rule.mCommand += H_SOURCE_LIST
rule.mPriority = -1
make.addRule (rule)
#--------------------------------------------------------------------------- Group sources ?
if GROUP_SOURCES :
allSourceFile = GENERATED_SOURCE_DIR + "/all-sources.cpp"
rule = makefile.Rule ([allSourceFile], "Group all sources")
rule.mOpenSourceOnError = False
rule.mDependences += CPP_SOURCE_LIST
rule.mDependences.append ("makefile.json")
rule.mCommand += [DEV_FILES_DIR + "/build_grouped_sources.py", allSourceFile]
rule.mCommand += CPP_SOURCE_LIST
rule.mPriority = -1
make.addRule (rule)
CPP_SOURCE_LIST = [allSourceFile]
#--------------------------------------------------------------------------- Build makefile rules
objectFileList = []
asObjectFileList = []
#--- CPP source files
for sourcePath in CPP_SOURCE_LIST :
(goals, objectFiles, listingFiles) = addCppSourceFileToMakeFile (
sourcePath,
make,
BUILD_DIR,
allHeadersSecondaryDependenceFile,
COMPILER_TOOL_WITH_OPTIONS,
includeDirsInCompilerCommand,
usesLTO,
GROUP_SOURCES,
allHeaders_file,
ASBUILD_DIR,
AS_TOOL_WITH_OPTIONS
)
allGoal += goals
objectFileList += objectFiles
asObjectFileList += listingFiles
#-- Add ARM S files
for sourcePath in S_SOURCE_LIST :
(objectFiles, listingFiles) = addAsSourceFileToMakeFile (
sourcePath,
make,
BUILD_DIR,
ASBUILD_DIR,
AS_TOOL_WITH_OPTIONS,
includeDirsInCompilerCommand
)
objectFileList += objectFiles
asObjectFileList += listingFiles
#--------------------------------------------------------------------------- Enumerate deployments
deploymentDictionary = deployment.deploymentDictionary ()
#--------------------------------------------------------------------- - Check selected deployments
objectFileListDictionary = dict ()
for selectedDeployment in selectedDeployments :
objectFileListDictionary [selectedDeployment] = list (objectFileList)
if not selectedDeployment in deploymentDictionary.keys () :
s = "Invalid deployment \"" + selectedDeployment + "\"; possible values:\n"
for dep in deploymentDictionary.keys () :
s += " - \"" + dep + "\"\n"
print (makefile.BOLD_RED () + s + makefile.ENDC ())
sys.exit (1)
#--------------------------------------------------------------- Additional source for deployement
for selectedDeployment in selectedDeployments :
additionalSourceDirectory = deployment.additionalSourceDirectoryForDeployment (selectedDeployment)
if additionalSourceDirectory != "" :
fullDirPath = TARGET_DIR + "/deployment/" + additionalSourceDirectory
for name in sorted (os.listdir (fullDirPath)) :
sourcePath = os.path.join (fullDirPath, name)
(b, extension) = os.path.splitext (sourcePath)
if extension == ".cpp" :
(goals, objectFiles, listingFiles) = addCppSourceFileToMakeFile (
sourcePath,
make,
BUILD_DIR,
allHeadersSecondaryDependenceFile,
COMPILER_TOOL_WITH_OPTIONS,
includeDirsInCompilerCommand,
usesLTO,
GROUP_SOURCES,
allHeaders_file,
ASBUILD_DIR,
AS_TOOL_WITH_OPTIONS
)
allGoal += goals
objectFileListDictionary [selectedDeployment] += objectFiles
asObjectFileList += listingFiles
elif extension == ".s" :
(objectFiles, listingFiles) = addAsSourceFileToMakeFile (
sourcePath,
make,
BUILD_DIR,
ASBUILD_DIR,
AS_TOOL_WITH_OPTIONS,
includeDirsInCompilerCommand
)
objectFileListDictionary [selectedDeployment] += objectFiles
asObjectFileList += listingFiles
elif extension != "" : # Ceci permet d'ignorer les fichés cachés (dont les noms commencent par un point)
print (makefile.MAGENTA () + makefile.BOLD () + "Note: unhandled file " + sourcePath + makefile.ENDC ())
#--------------------------------------------------------------------------- Build deployment files
runGoalDictionary = dict ()
for selectedDeployment in selectedDeployments :
runGoalDictionary ["run-" + selectedDeployment] = selectedDeployment
linkerScript = deploymentDictionary [selectedDeployment]
LINKER_SCRIPT = TARGET_DIR + "/deployment/" + linkerScript
PRODUCT = PRODUCT_DIR + "/deployment-" + selectedDeployment
allGoal.append (PRODUCT + ".elf")
#--- Add link rule
rule = makefile.Rule ([PRODUCT + ".elf"], "Linking " + PRODUCT + ".elf")
rule.mDependences += objectFileListDictionary [selectedDeployment]
rule.mDependences.append (LINKER_SCRIPT)
rule.mDependences.append ("makefile.json")
rule.mCommand += LD_TOOL_WITH_OPTIONS
rule.mCommand += objectFileListDictionary [selectedDeployment]
rule.mCommand += ["-T" + LINKER_SCRIPT]
rule.mCommand.append ("-Wl,-Map=" + PRODUCT + ".map")
rule.mCommand += common_definitions.commonLinkerFlags (usesLTO)
rule.mCommand += ["-o", PRODUCT + ".elf"]
make.addRule (rule)
make.addGoal ("run-" + selectedDeployment, allGoal, "Building " + selectedDeployment + " deployment and run")
#--- Add deployment rules
(goal, rule) = deployment.buildDeployment (PRODUCT, selectedDeployment, verbose)
allGoal.append (goal)
make.addRule (rule)
# sys.path.pop ()
#--- Write deployment script
pythonScriptFilePath = projectDir + "/2-run-" + selectedDeployment + "-via-usb.py"
if not os.path.exists (pythonScriptFilePath) :
f = open (DEV_FILES_DIR + "/deployment-script.py.txt", "r")
genericScript = f.read ()
f.close ()
pythonScriptContents = genericScript.replace ("DEPLOYMENT", "run-" + selectedDeployment)
f = open (pythonScriptFilePath, "wt")
f.write (pythonScriptContents)
f.close ()
#---
mode = os.stat (pythonScriptFilePath).st_mode
# print (mode)
mode += 0o0100 # Add execute permission
# print (mode)
os.chmod (pythonScriptFilePath, mode)
#--------------------------------------------------------------------------- Goals
make.addGoal ("all", allGoal, "Build all")
make.addGoal ("view-hex", allGoal, "Building all and show hex")
make.addGoal ("display-obj-size", allGoal, "Build binaries and display object sizes")
make.addGoal ("as", asObjectFileList, "Compile C and C++ to assembly")
#--------------------------------------------------------------------------- Run jobs
#make.printRules ()
#make.checkRules ()
# make.writeRuleDependancesInDotFile ("dependances.dot")
make.runGoal (maxConcurrentJobs, verbose)
#--------------------------------------------------------------------------- Ok ?
make.printErrorCountAndExitOnError ()
#---------------------------------------------------------------------------- "display-obj-size"
if GOAL == "display-obj-size" :
makefile.runCommand (DISPLAY_OBJ_SIZE_TOOL + objectFileList + ["-t"], "Display Object Size", False, verbose)
#---------------------------------------------------------------------------- "All" or "run"
if GOAL == "all" :
for selectedDeployment in selectedDeployments :
PRODUCT = PRODUCT_DIR + "/deployment-" + selectedDeployment
s = runProcessAndGetOutput (DISPLAY_OBJ_SIZE_TOOL + ["-t"] + [PRODUCT + ".elf"])
secondLine = s.split('\n')[1]
numbers = [int(s) for s in secondLine.split() if s.isdigit()]
print ("Deployment \"" + selectedDeployment + "\":")
print (" Code: " + str (numbers [0]) + " bytes")
print (" Initialized data: " + str (numbers [1]) + " bytes")
print (" RAM + STACK: " + str (numbers [2]) + " bytes")
#---------------------------------------------------------------------------- Run ?
if GOAL in runGoalDictionary.keys () :
selectedDeployment = runGoalDictionary [GOAL]
PRODUCT = PRODUCT_DIR + "/deployment-" + selectedDeployment
DEPLOYMENT_DIR = TARGET_DIR + "/deployment"
deployment.performDeployment (DEPLOYMENT_DIR, PRODUCT, selectedDeployment)
def __init__(self):
# free lines to be output.
self.__lines = []
# AUTOMAKE_OPTIONS.
self.__automake_options = makefile.Set(name='AUTOMAKE_OPTIONS',
values=[],
mitigate=False)
# SUBDIRS.
self.__subdirs = makefile.List(name='SUBDIRS',
values=[],
mitigate=True)
# "Makefile elements": Rule and List objects.
self.__elements = []
# sets of filenames that will come to rest in EXTRA_DIST,
# MOSTLYCLEANFILES, CLEANFILES, DISTCLEANFILES, and
# MAINTAINERCLEANFILES, respectively.
self.__extra_dist = makefile.Set(name='EXTRA_DIST',
values=[],
mitigate=True)
self.__mostlycleanfiles = makefile.Set(name='MOSTLYCLEANFILES',
values=[],
mitigate=True)
self.__cleanfiles = makefile.Set(name='CLEANFILES',
values=[],
mitigate=True)
self.__distcleanfiles = makefile.Set(name='DISTCLEANFILES',
values=[],
mitigate=True)
self.__maintainercleanfiles = makefile.Set(name='MAINTAINERCLEANFILES',
values=[],
mitigate=True)
# AM_CFLAGS, AM_CXXFLAGS, AM_LFLAGS, AM_YFLAGS. we collect
# them in a dictionary to keep them unique. (keys are the
# flags themselves, data is irrelevant.)
self.__am_cflags = makefile.Set(name='AM_CFLAGS',
values=[],
mitigate=True)
self.__am_cxxflags = makefile.Set(name='AM_CXXFLAGS',
values=[],
mitigate=True)
self.__am_lflags = makefile.Set(name='AM_LFLAGS',
values=[],
mitigate=True)
self.__am_yflags = makefile.Set(name='AM_YFLAGS',
values=[],
mitigate=True)
# source files (_SOURCES) of compound objects (i.e. libraries
# and executables).
self.__compound_sources = CompoundListManager(unique=True,
extension='SOURCES')
# _LDFLAGS specific to an executable or a library.
self.__compound_ldflags = CompoundListManager(unique=False,
extension='LDFLAGS')
# _LIBADD for compound objects.
self.__compound_libadd = CompoundListManager(unique=True,
extension='LIBADD')
# _LDADD for compound objects.
self.__compound_ldadd = CompoundListManager(unique=True,
extension='LDADD')
# _DEPENDENCIES for compound objects.
self.__compound_dependencies = CompoundListManager(
unique=True, extension='DEPENDENCIES')
# AM_CPPFLAGS. includepath and commandline macros make their
# way into AM_CPPFLAGS. we maintain them separately because
# they have different overriding semantics.
self.__includepath = []
self.__have_includedir = {}
self.__cmdlinemacros = {}
# generic way to register files (programs, libraries, etc.)
# that will be built, and eventually installed. for example,
# 'lib_LIBRARIES' is a list of library names that have to be
# built (ok, we only build one library in a module, but that's
# another story). other examples are 'bin_PROGRAMS', or
# 'check_PROGRAMS'.
# the structure is a dictionary, with the keys being the
# variables (such as 'lib_LIBRARIES'), and the data being
# dictionaries that have as keys the filenames that the
# variable holds. sounds complicated, see the
# add_dir_primary() method for more.
self.__dir_primary = {}
# directories where files will be installed to
# {symbolicname -> (dirname, {family -> filelist})}
# for example:
# {'publicheader_WXUtils': ('$(includedir)/WX/Utils',
# {'HEADERS': ['error.h',
# 'errortrace.h',
# 'error_impl.h',
# 'error_macros.h']})}
# note that we predefine the default directories (for
# include_HEADERS, or data_DATA, for example) -- these must
# not be explicitly defined in Makefile.am.
self.__install_directories = {
'': Makefile_am.DirectoryDefinition(dirname=None)
}
# TESTS_ENVIRONMENT. a dictionary (string->string) that
# contains the environment for test programs.
self.__tests_environment = {}
# BUILT_SOURCES. list of files that must be built before
# everything else is built.
self.__built_sources = makefile.Set(name='BUILT_SOURCES',
values=[],
mitigate=True)
# hook-targets to be made after the local (module) thing is
# over. see the "all-local:" and "clean-local:" hook target
# documentation in the automake manual.
self.__all_local = makefile.Rule(targets=['all-local'])
self.__clean_local = makefile.Rule(targets=['clean-local'])
self.__install_data_local = makefile.Rule(
targets=['install-data-local'])
self.__distclean_local = makefile.Rule(targets=['distclean-local'])
self.__mostlyclean_local = makefile.Rule(targets=['mostlyclean-local'])
self.__maintainer_clean_local = makefile.Rule(
targets=['maintainer-clean-local'])
pass
"dom.cpp",
"../../src/TrackSet.cpp",
"../../src/Track.cpp",
"../../src/PathSet.cpp",
"../../src/HeadedTrackSet.cpp",
"../../unix/Arduino.cpp",
"../../unix/HardwareSerial.cpp"
]
objectList = []
for source in sourceList:
#--- Add compile rules
src = os.path.basename(os.path.dirname(source)) + "/" + os.path.basename(source)
object = "objects/" + src + ".o"
depObject = object + ".dep"
objectList.append (object)
rule = makefile.Rule ([object], "Compiling " + source) # Release 2
rule.deleteTargetDirectoryOnClean ()
rule.mDependences.append (source)
rule.mCommand.append ("g++")
# rule.mCommand += ["-std=c++11"]
rule.mCommand += ["-I../../src"]
rule.mCommand += ["-I../../unix"]
rule.mCommand += ["-I../../examples/dom"]
rule.mCommand += ["-c", source]
rule.mCommand += ["-o", object]
rule.mCommand += ["-MD", "-MP", "-MF", depObject]
rule.enterSecondaryDependanceFile (depObject, make)
rule.mPriority = os.path.getsize (scriptDir + "/" + source)
# rule.mOpenSourceOnError = True
make.addRule (rule)
#--- Add linker rule
