Removed dependency on builder ctx in GCCPreprocRunner

Author: cmaglie

legacy/builder/container_add_prototypes.go

@@ -34,8 +34,11 @@ func PreprocessSketchWithCtags(ctx *types.Context) error {
 
 	// Run preprocessor
 	sourceFile := ctx.SketchBuildPath.Join(ctx.Sketch.MainFile.Base() + ".cpp")
-	stderr, err := GCCPreprocRunner(ctx, sourceFile, targetFilePath, ctx.IncludeFolders)
-	ctx.WriteStderr(stderr)
+	gccStdout, gccStderr, err := GCCPreprocRunner(sourceFile, targetFilePath, ctx.IncludeFolders, ctx.BuildProperties)
+	if ctx.Verbose {
+		ctx.WriteStdout(gccStdout)
+		ctx.WriteStderr(gccStderr)
+	}
 	if err != nil {
 		if !ctx.OnlyUpdateCompilationDatabase {
 			return errors.WithStack(err)

legacy/builder/container_find_includes.go

@@ -369,7 +369,12 @@ func findIncludesUntilDone(ctx *types.Context, cache *includeCache, sourceFileQu
 				ctx.Info(tr("Using cached library dependencies for file: %[1]s", sourcePath))
 			}
 		} else {
-			preproc_stderr, preproc_err = GCCPreprocRunner(ctx, sourcePath, targetFilePath, includes)
+			var preproc_stdout []byte
+			preproc_stdout, preproc_stderr, preproc_err = GCCPreprocRunner(sourcePath, targetFilePath, includes, ctx.BuildProperties)
+			if ctx.Verbose {
+				ctx.WriteStdout(preproc_stdout)
+				ctx.WriteStdout(preproc_stderr)
+			}
 			// Unwrap error and see if it is an ExitError.
 			_, is_exit_error := errors.Cause(preproc_err).(*exec.ExitError)
 			if preproc_err == nil {
@@ -397,11 +402,13 @@ func findIncludesUntilDone(ctx *types.Context, cache *includeCache, sourceFileQu
 		library := ResolveLibrary(ctx, include)
 		if library == nil {
 			// Library could not be resolved, show error
-			// err := runCommand(ctx, &GCCPreprocRunner{SourceFilePath: sourcePath, TargetFileName: paths.New(constants.FILE_CTAGS_TARGET_FOR_GCC_MINUS_E), Includes: includes})
-			// return errors.WithStack(err)
 			if preproc_err == nil || preproc_stderr == nil {
 				// Filename came from cache, so run preprocessor to obtain error to show
-				preproc_stderr, preproc_err = GCCPreprocRunner(ctx, sourcePath, targetFilePath, includes)
+				var preproc_stdout []byte
+				preproc_stdout, preproc_stderr, preproc_err = GCCPreprocRunner(sourcePath, targetFilePath, includes, ctx.BuildProperties)
+				if ctx.Verbose {
+					ctx.WriteStdout(preproc_stdout)
+				}
 				if preproc_err == nil {
 					// If there is a missing #include in the cache, but running
 					// gcc does not reproduce that, there is something wrong.

legacy/builder/gcc_preproc_runner.go

@@ -16,47 +16,64 @@
 package builder
 
 import (
+	"context"
+	"fmt"
 	"strings"
 
+	"github.com/arduino/arduino-cli/executils"
 	f "github.com/arduino/arduino-cli/internal/algorithms"
-	"github.com/arduino/arduino-cli/legacy/builder/builder_utils"
-	"github.com/arduino/arduino-cli/legacy/builder/types"
 	"github.com/arduino/arduino-cli/legacy/builder/utils"
 	"github.com/arduino/go-paths-helper"
 	properties "github.com/arduino/go-properties-orderedmap"
+	"github.com/pkg/errors"
 )
 
-func GCCPreprocRunner(ctx *types.Context, sourceFilePath *paths.Path, targetFilePath *paths.Path, includes paths.PathList) ([]byte, error) {
-	buildProperties := properties.NewMap()
-	buildProperties.Set("preproc.macros.flags", "-w -x c++ -E -CC")
-	buildProperties.Merge(ctx.BuildProperties)
-	buildProperties.Set("build.library_discovery_phase", "1")
-	buildProperties.SetPath("source_file", sourceFilePath)
-	buildProperties.SetPath("preprocessed_file_path", targetFilePath)
+func GCCPreprocRunner(sourceFilePath *paths.Path, targetFilePath *paths.Path, includes paths.PathList, buildProperties *properties.Map) ([]byte, []byte, error) {
+	gccBuildProperties := properties.NewMap()
+	gccBuildProperties.Set("preproc.macros.flags", "-w -x c++ -E -CC")
+	gccBuildProperties.Merge(buildProperties)
+	gccBuildProperties.Set("build.library_discovery_phase", "1")
+	gccBuildProperties.SetPath("source_file", sourceFilePath)
+	gccBuildProperties.SetPath("preprocessed_file_path", targetFilePath)
 
 	includesStrings := f.Map(includes.AsStrings(), utils.WrapWithHyphenI)
-	buildProperties.Set("includes", strings.Join(includesStrings, " "))
+	gccBuildProperties.Set("includes", strings.Join(includesStrings, " "))
 
-	if buildProperties.Get("recipe.preproc.macros") == "" {
+	const GCC_PATTERN_PROPERTY = "recipe.preproc.macros"
+	if gccBuildProperties.Get(GCC_PATTERN_PROPERTY) == "" {
 		// autogenerate preprocess macros recipe from compile recipe
-		preprocPattern := buildProperties.Get("recipe.cpp.o.pattern")
+		preprocPattern := gccBuildProperties.Get("recipe.cpp.o.pattern")
 		// add {preproc.macros.flags} to {compiler.cpp.flags}
 		preprocPattern = strings.Replace(preprocPattern, "{compiler.cpp.flags}", "{compiler.cpp.flags} {preproc.macros.flags}", 1)
 		// replace "{object_file}" with "{preprocessed_file_path}"
 		preprocPattern = strings.Replace(preprocPattern, "{object_file}", "{preprocessed_file_path}", 1)
 
-		buildProperties.Set("recipe.preproc.macros", preprocPattern)
+		gccBuildProperties.Set(GCC_PATTERN_PROPERTY, preprocPattern)
 	}
 
-	cmd, err := builder_utils.PrepareCommandForRecipe(buildProperties, "recipe.preproc.macros", true, ctx.PackageManager.GetEnvVarsForSpawnedProcess())
+	pattern := gccBuildProperties.Get(GCC_PATTERN_PROPERTY)
+	if pattern == "" {
+		return nil, nil, errors.Errorf(tr("%s pattern is missing"), GCC_PATTERN_PROPERTY)
+	}
+
+	commandLine := gccBuildProperties.ExpandPropsInString(pattern)
+	args, err := properties.SplitQuotedString(commandLine, `"'`, false)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	// Remove -MMD argument if present. Leaving it will make gcc try
 	// to create a /dev/null.d dependency file, which won't work.
-	cmd.Args = f.Filter(cmd.Args, f.NotEquals("-MMD"))
+	args = f.Filter(args, f.NotEquals("-MMD"))
+
+	proc, err := executils.NewProcess(nil, args...)
+	if err != nil {
+		return nil, nil, err
+	}
+	stdout, stderr, err := proc.RunAndCaptureOutput(context.Background())
+
+	// Append gcc arguments to stdout
+	stdout = append([]byte(fmt.Sprintln(strings.Join(args, " "))), stdout...)
 
-	_, stderr, err := utils.ExecCommand(ctx, cmd, utils.ShowIfVerbose /* stdout */, utils.Capture /* stderr */)
-	return stderr, err
+	return stdout, stderr, err
 }

legacy/builder/preprocess_sketch.go

@@ -36,11 +36,15 @@ func PreprocessSketchWithArduinoPreprocessor(ctx *types.Context) error {
 
 	sourceFile := ctx.SketchBuildPath.Join(ctx.Sketch.MainFile.Base() + ".cpp")
 	targetFile := ctx.PreprocPath.Join("sketch_merged.cpp")
-	stderr, err := GCCPreprocRunner(ctx, sourceFile, targetFile, ctx.IncludeFolders)
-	ctx.WriteStderr(stderr)
+	gccStdout, gccStderr, err := GCCPreprocRunner(sourceFile, targetFile, ctx.IncludeFolders, ctx.BuildProperties)
+	if ctx.Verbose {
+		ctx.WriteStdout(gccStdout)
+		ctx.WriteStderr(gccStderr)
+	}
 	if err != nil {
 		return err
 	}
+
 	buildProperties := properties.NewMap()
 	buildProperties.Set("tools.arduino-preprocessor.path", "{runtime.tools.arduino-preprocessor.path}")
 	buildProperties.Set("tools.arduino-preprocessor.cmd.path", "{path}/arduino-preprocessor")