cc/cmakelists.go - SHIFTPHONES/android_build_soong - Gitiles

 package cc

 import (
 	"fmt"

 	"android/soong/android"
 	"android/soong/cc/config"
 	"github.com/google/blueprint"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 )

 // This singleton generates CMakeLists.txt files. It does so for each blueprint Android.bp resulting in a cc.Module
 // when either make, mm, mma, mmm or mmma is called. CMakeLists.txt files are generated in a separate folder
 // structure (see variable CLionOutputProjectsDirectory for root).

 func init() {
 	android.RegisterSingletonType("cmakelists_generator", cMakeListsGeneratorSingleton)
 }

 func cMakeListsGeneratorSingleton() blueprint.Singleton {
 	return &cmakelistsGeneratorSingleton{}
 }

 type cmakelistsGeneratorSingleton struct{}

 const (
 	cMakeListsFilename              = "CMakeLists.txt"
 	cLionAggregateProjectsDirectory = "development" + string(os.PathSeparator) + "ide" + string(os.PathSeparator) + "clion"
 	cLionOutputProjectsDirectory    = "out" + string(os.PathSeparator) + cLionAggregateProjectsDirectory
 	minimumCMakeVersionSupported    = "3.5"

 	// Environment variables used to modify behavior of this singleton.
 	envVariableGenerateCMakeLists = "SOONG_GEN_CMAKEFILES"
 	envVariableGenerateDebugInfo  = "SOONG_GEN_CMAKEFILES_DEBUG"
 	envVariableTrue               = "1"
 )

 // Instruct generator to trace how header include path and flags were generated.
 // This is done to ease investigating bug reports.
 var outputDebugInfo = false

 func (c *cmakelistsGeneratorSingleton) GenerateBuildActions(ctx blueprint.SingletonContext) {
 	if getEnvVariable(envVariableGenerateCMakeLists, ctx) != envVariableTrue {
 		return
 	}

 	outputDebugInfo = (getEnvVariable(envVariableGenerateDebugInfo, ctx) == envVariableTrue)

 	ctx.VisitAllModules(func(module blueprint.Module) {
 		if ccModule, ok := module.(*Module); ok {
 			if compiledModule, ok := ccModule.compiler.(CompiledInterface); ok {
 				generateCLionProject(compiledModule, ctx, ccModule)
 			}
 		}
 	})

 	// Link all handmade CMakeLists.txt aggregate from
 	//     BASE/development/ide/clion to
 	// BASE/out/development/ide/clion.
 	dir := filepath.Join(getAndroidSrcRootDirectory(ctx), cLionAggregateProjectsDirectory)
 	filepath.Walk(dir, linkAggregateCMakeListsFiles)

 	return
 }

 func getEnvVariable(name string, ctx blueprint.SingletonContext) string {
 	// Using android.Config.Getenv instead of os.getEnv to guarantee soong will
 	// re-run in case this environment variable changes.
 	return ctx.Config().(android.Config).Getenv(name)
 }

 func exists(path string) bool {
 	_, err := os.Stat(path)
 	if err == nil {
 		return true
 	}
 	if os.IsNotExist(err) {
 		return false
 	}
 	return true
 }

 func linkAggregateCMakeListsFiles(path string, info os.FileInfo, err error) error {

 	if info == nil {
 		return nil
 	}

 	dst := strings.Replace(path, cLionAggregateProjectsDirectory, cLionOutputProjectsDirectory, 1)
 	if info.IsDir() {
 		// This is a directory to create
 		os.MkdirAll(dst, os.ModePerm)
 	} else {
 		// This is a file to link
 		os.Remove(dst)
 		os.Symlink(path, dst)
 	}
 	return nil
 }

 func generateCLionProject(compiledModule CompiledInterface, ctx blueprint.SingletonContext, ccModule *Module) {
 	srcs := compiledModule.Srcs()
 	if len(srcs) == 0 {
 		return
 	}

 	// Ensure the directory hosting the cmakelists.txt exists
 	clionproject_location := getCMakeListsForModule(ccModule, ctx)
 	projectDir := path.Dir(clionproject_location)
 	os.MkdirAll(projectDir, os.ModePerm)

 	// Create cmakelists.txt
 	f, _ := os.Create(filepath.Join(projectDir, cMakeListsFilename))
 	defer f.Close()

 	// Header.
 	f.WriteString("# THIS FILE WAS AUTOMATICALY GENERATED!\n")
 	f.WriteString("# ANY MODIFICATION WILL BE OVERWRITTEN!\n\n")
 	f.WriteString("# To improve project view in Clion    :\n")
 	f.WriteString("# Tools > CMake > Change Project Root  \n\n")
 	f.WriteString(fmt.Sprintf("cmake_minimum_required(VERSION %s)\n", minimumCMakeVersionSupported))
 	f.WriteString(fmt.Sprintf("project(%s)\n", ccModule.ModuleBase.Name()))
 	f.WriteString(fmt.Sprintf("set(ANDROID_ROOT %s)\n\n", getAndroidSrcRootDirectory(ctx)))

 	if ccModule.flags.Clang {
 		pathToCC, _ := evalVariable(ctx, "${config.ClangBin}/")
 		f.WriteString(fmt.Sprintf("set(CMAKE_C_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "clang"))
 		f.WriteString(fmt.Sprintf("set(CMAKE_CXX_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "clang++"))
 	} else {
 		toolchain := config.FindToolchain(ccModule.Os(), ccModule.Arch())
 		root, _ := evalVariable(ctx, toolchain.GccRoot())
 		triple, _ := evalVariable(ctx, toolchain.GccTriple())
 		pathToCC := filepath.Join(root, "bin", triple+"-")
 		f.WriteString(fmt.Sprintf("set(CMAKE_C_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "gcc"))
 		f.WriteString(fmt.Sprintf("set(CMAKE_CXX_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "g++"))
 	}
 	// Add all sources to the project.
 	f.WriteString("list(APPEND\n")
 	f.WriteString("     SOURCE_FILES\n")
 	for _, src := range srcs {
 		f.WriteString(fmt.Sprintf("    ${ANDROID_ROOT}/%s\n", src.String()))
 	}
 	f.WriteString(")\n")

 	// Add all header search path and compiler parameters (-D, -W, -f, -XXXX)
 	f.WriteString("\n# GLOBAL FLAGS:\n")
 	globalParameters := parseCompilerParameters(ccModule.flags.GlobalFlags, ctx, f)
 	translateToCMake(globalParameters, f, true, true)

 	f.WriteString("\n# CFLAGS:\n")
 	cParameters := parseCompilerParameters(ccModule.flags.CFlags, ctx, f)
 	translateToCMake(cParameters, f, true, true)

 	f.WriteString("\n# C ONLY FLAGS:\n")
 	cOnlyParameters := parseCompilerParameters(ccModule.flags.ConlyFlags, ctx, f)
 	translateToCMake(cOnlyParameters, f, true, false)

 	f.WriteString("\n# CPP FLAGS:\n")
 	cppParameters := parseCompilerParameters(ccModule.flags.CppFlags, ctx, f)
 	translateToCMake(cppParameters, f, false, true)

 	// Add project executable.
 	f.WriteString(fmt.Sprintf("\nadd_executable(%s ${SOURCE_FILES})\n", ccModule.ModuleBase.Name()))
 }

 func translateToCMake(c compilerParameters, f *os.File, cflags bool, cppflags bool) {
 	writeAllSystemDirectories(c.systemHeaderSearchPath, f)
 	writeAllIncludeDirectories(c.headerSearchPath, f)
 	if cflags {
 		writeAllFlags(c.flags, f, "CMAKE_C_FLAGS")
 	}

 	if cppflags {
 		writeAllFlags(c.flags, f, "CMAKE_CXX_FLAGS")
 	}
 	if c.sysroot != "" {
 		f.WriteString(fmt.Sprintf("include_directories(SYSTEM \"%s\")\n", buildCMakePath(path.Join(c.sysroot, "usr", "include"))))
 	}

 }

 func buildCMakePath(p string) string {
 	if path.IsAbs(p) {
 		return p
 	}
 	return fmt.Sprintf("${ANDROID_ROOT}/%s", p)
 }

 func writeAllIncludeDirectories(includes map[string]bool, f *os.File) {
 	for include := range includes {
 		f.WriteString(fmt.Sprintf("include_directories(\"%s\")\n", buildCMakePath(include)))
 	}
 }

 func writeAllSystemDirectories(includes map[string]bool, f *os.File) {
 	for include := range includes {
 		f.WriteString(fmt.Sprintf("include_directories(SYSTEM \"%s\")\n", buildCMakePath(include)))
 	}
 }

 func writeAllFlags(flags []string, f *os.File, tag string) {
 	for _, flag := range flags {
 		f.WriteString(fmt.Sprintf("set(%s \"${%s} %s\")\n", tag, tag, flag))
 	}
 }

 type parameterType int

 const (
 	headerSearchPath parameterType = iota
 	variable
 	systemHeaderSearchPath
 	flag
 	systemRoot
 )

 type compilerParameters struct {
 	headerSearchPath       map[string]bool
 	systemHeaderSearchPath map[string]bool
 	flags                  []string
 	sysroot                string
 }

 func makeCompilerParameters() compilerParameters {
 	return compilerParameters{
 		headerSearchPath:       make(map[string]bool),
 		systemHeaderSearchPath: make(map[string]bool),
 		flags:   make([]string, 0),
 		sysroot: "",
 	}
 }

 func categorizeParameter(parameter string) parameterType {
 	if strings.HasPrefix(parameter, "-I") {
 		return headerSearchPath
 	}
 	if strings.HasPrefix(parameter, "$") {
 		return variable
 	}
 	if strings.HasPrefix(parameter, "-isystem") {
 		return systemHeaderSearchPath
 	}
 	if strings.HasPrefix(parameter, "-isysroot") {
 		return systemRoot
 	}
 	if strings.HasPrefix(parameter, "--sysroot") {
 		return systemRoot
 	}
 	return flag
 }

 func parseCompilerParameters(params []string, ctx blueprint.SingletonContext, f *os.File) compilerParameters {
 	var compilerParameters = makeCompilerParameters()

 	for i, str := range params {
 		f.WriteString(fmt.Sprintf("# Raw param [%d] = '%s'\n", i, str))
 	}

 	for i := 0; i < len(params); i++ {
 		param := params[i]
 		if param == "" {
 			continue
 		}

 		switch categorizeParameter(param) {
 		case headerSearchPath:
 			compilerParameters.headerSearchPath[strings.TrimPrefix(param, "-I")] = true
 		case variable:
 			if evaluated, error := evalVariable(ctx, param); error == nil {
 				if outputDebugInfo {
 					f.WriteString(fmt.Sprintf("# variable %s = '%s'\n", param, evaluated))
 				}

 				paramsFromVar := parseCompilerParameters(strings.Split(evaluated, " "), ctx, f)
 				concatenateParams(&compilerParameters, paramsFromVar)

 			} else {
 				if outputDebugInfo {
 					f.WriteString(fmt.Sprintf("# variable %s could NOT BE RESOLVED\n", param))
 				}
 			}
 		case systemHeaderSearchPath:
 			if i < len(params)-1 {
 				compilerParameters.systemHeaderSearchPath[params[i+1]] = true
 			} else if outputDebugInfo {
 				f.WriteString("# Found a header search path marker with no path")
 			}
 			i = i + 1
 		case flag:
 			c := cleanupParameter(param)
 			f.WriteString(fmt.Sprintf("# FLAG '%s' became %s\n", param, c))
 			compilerParameters.flags = append(compilerParameters.flags, c)
 		case systemRoot:
 			if i < len(params)-1 {
 				compilerParameters.sysroot = params[i+1]
 			} else if outputDebugInfo {
 				f.WriteString("# Found a system root path marker with no path")
 			}
 			i = i + 1
 		}
 	}
 	return compilerParameters
 }

 func cleanupParameter(p string) string {
 	// In the blueprint, c flags can be passed as:
 	//  cflags: [ "-DLOG_TAG=\"libEGL\"", ]
 	// which becomes:
 	// '-DLOG_TAG="libEGL"' in soong.
 	// In order to be injected in CMakelists.txt we need to:
 	// - Remove the wrapping ' character
 	// - Double escape all special \ and " characters.
 	// For a end result like:
 	// -DLOG_TAG=\\\"libEGL\\\"
 	if !strings.HasPrefix(p, "'") || !strings.HasSuffix(p, "'") || len(p) < 3 {
 		return p
 	}

 	// Reverse wrapper quotes and escaping that may have happened in NinjaAndShellEscape
 	// TODO:  It is ok to reverse here for now but if NinjaAndShellEscape becomes more complex,
 	// we should create a method NinjaAndShellUnescape in escape.go and use that instead.
 	p = p[1 : len(p)-1]
 	p = strings.Replace(p, `'\''`, `'`, -1)
 	p = strings.Replace(p, `$$`, `$`, -1)

 	p = doubleEscape(p)
 	return p
 }

 func escape(s string) string {
 	s = strings.Replace(s, `\`, `\\`, -1)
 	s = strings.Replace(s, `"`, `\"`, -1)
 	return s
 }

 func doubleEscape(s string) string {
 	s = escape(s)
 	s = escape(s)
 	return s
 }

 func concatenateParams(c1 *compilerParameters, c2 compilerParameters) {
 	concatenateMaps(c1.headerSearchPath, c2.headerSearchPath)
 	concatenateMaps(c1.systemHeaderSearchPath, c2.systemHeaderSearchPath)
 	if c2.sysroot != "" {
 		c1.sysroot = c2.sysroot
 	}
 	c1.flags = append(c1.flags, c2.flags...)
 }

 func evalVariable(ctx blueprint.SingletonContext, str string) (string, error) {
 	evaluated, err := ctx.Eval(pctx, str)
 	if err == nil {
 		return evaluated, nil
 	}
 	return "", err
 }

 // Concatenate two maps into one. Results are stored in first operand.
 func concatenateMaps(map1 map[string]bool, map2 map[string]bool) {
 	for key, value := range map2 {
 		map1[key] = value
 	}
 }

 func getCMakeListsForModule(module *Module, ctx blueprint.SingletonContext) string {
 	return filepath.Join(getAndroidSrcRootDirectory(ctx),
 		cLionOutputProjectsDirectory,
 		path.Dir(ctx.BlueprintFile(module)),
 		module.ModuleBase.Name()+"-"+
 			module.ModuleBase.Arch().ArchType.Name+"-"+
 			module.ModuleBase.Os().Name,
 		cMakeListsFilename)
 }

 func getAndroidSrcRootDirectory(ctx blueprint.SingletonContext) string {
 	srcPath, _ := filepath.Abs(android.PathForSource(ctx).String())
 	return srcPath
 }
	package cc

	import (
	"fmt"

	"android/soong/android"
	"android/soong/cc/config"
	"github.com/google/blueprint"
	"os"
	"path"
	"path/filepath"
	"strings"
	)

	// This singleton generates CMakeLists.txt files. It does so for each blueprint Android.bp resulting in a cc.Module
	// when either make, mm, mma, mmm or mmma is called. CMakeLists.txt files are generated in a separate folder
	// structure (see variable CLionOutputProjectsDirectory for root).

	func init() {
	android.RegisterSingletonType("cmakelists_generator", cMakeListsGeneratorSingleton)
	}

	func cMakeListsGeneratorSingleton() blueprint.Singleton {
	return &cmakelistsGeneratorSingleton{}
	}

	type cmakelistsGeneratorSingleton struct{}

	const (
	cMakeListsFilename = "CMakeLists.txt"
	cLionAggregateProjectsDirectory = "development" + string(os.PathSeparator) + "ide" + string(os.PathSeparator) + "clion"
	cLionOutputProjectsDirectory = "out" + string(os.PathSeparator) + cLionAggregateProjectsDirectory
	minimumCMakeVersionSupported = "3.5"

	// Environment variables used to modify behavior of this singleton.
	envVariableGenerateCMakeLists = "SOONG_GEN_CMAKEFILES"
	envVariableGenerateDebugInfo = "SOONG_GEN_CMAKEFILES_DEBUG"
	envVariableTrue = "1"
	)

	// Instruct generator to trace how header include path and flags were generated.
	// This is done to ease investigating bug reports.
	var outputDebugInfo = false

	func (c *cmakelistsGeneratorSingleton) GenerateBuildActions(ctx blueprint.SingletonContext) {
	if getEnvVariable(envVariableGenerateCMakeLists, ctx) != envVariableTrue {
	return
	}

	outputDebugInfo = (getEnvVariable(envVariableGenerateDebugInfo, ctx) == envVariableTrue)

	ctx.VisitAllModules(func(module blueprint.Module) {
	if ccModule, ok := module.(*Module); ok {
	if compiledModule, ok := ccModule.compiler.(CompiledInterface); ok {
	generateCLionProject(compiledModule, ctx, ccModule)
	}
	}
	})

	// Link all handmade CMakeLists.txt aggregate from
	// BASE/development/ide/clion to
	// BASE/out/development/ide/clion.
	dir := filepath.Join(getAndroidSrcRootDirectory(ctx), cLionAggregateProjectsDirectory)
	filepath.Walk(dir, linkAggregateCMakeListsFiles)

	return
	}

	func getEnvVariable(name string, ctx blueprint.SingletonContext) string {
	// Using android.Config.Getenv instead of os.getEnv to guarantee soong will
	// re-run in case this environment variable changes.
	return ctx.Config().(android.Config).Getenv(name)
	}

	func exists(path string) bool {
	_, err := os.Stat(path)
	if err == nil {
	return true
	}
	if os.IsNotExist(err) {
	return false
	}
	return true
	}

	func linkAggregateCMakeListsFiles(path string, info os.FileInfo, err error) error {

	if info == nil {
	return nil
	}

	dst := strings.Replace(path, cLionAggregateProjectsDirectory, cLionOutputProjectsDirectory, 1)
	if info.IsDir() {
	// This is a directory to create
	os.MkdirAll(dst, os.ModePerm)
	} else {
	// This is a file to link
	os.Remove(dst)
	os.Symlink(path, dst)
	}
	return nil
	}

	func generateCLionProject(compiledModule CompiledInterface, ctx blueprint.SingletonContext, ccModule *Module) {
	srcs := compiledModule.Srcs()
	if len(srcs) == 0 {
	return
	}

	// Ensure the directory hosting the cmakelists.txt exists
	clionproject_location := getCMakeListsForModule(ccModule, ctx)
	projectDir := path.Dir(clionproject_location)
	os.MkdirAll(projectDir, os.ModePerm)

	// Create cmakelists.txt
	f, _ := os.Create(filepath.Join(projectDir, cMakeListsFilename))
	defer f.Close()

	// Header.
	f.WriteString("# THIS FILE WAS AUTOMATICALY GENERATED!\n")
	f.WriteString("# ANY MODIFICATION WILL BE OVERWRITTEN!\n\n")
	f.WriteString("# To improve project view in Clion :\n")
	f.WriteString("# Tools > CMake > Change Project Root \n\n")
	f.WriteString(fmt.Sprintf("cmake_minimum_required(VERSION %s)\n", minimumCMakeVersionSupported))
	f.WriteString(fmt.Sprintf("project(%s)\n", ccModule.ModuleBase.Name()))
	f.WriteString(fmt.Sprintf("set(ANDROID_ROOT %s)\n\n", getAndroidSrcRootDirectory(ctx)))

	if ccModule.flags.Clang {
	pathToCC, _ := evalVariable(ctx, "${config.ClangBin}/")
	f.WriteString(fmt.Sprintf("set(CMAKE_C_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "clang"))
	f.WriteString(fmt.Sprintf("set(CMAKE_CXX_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "clang++"))
	} else {
	toolchain := config.FindToolchain(ccModule.Os(), ccModule.Arch())
	root, _ := evalVariable(ctx, toolchain.GccRoot())
	triple, _ := evalVariable(ctx, toolchain.GccTriple())
	pathToCC := filepath.Join(root, "bin", triple+"-")
	f.WriteString(fmt.Sprintf("set(CMAKE_C_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "gcc"))
	f.WriteString(fmt.Sprintf("set(CMAKE_CXX_COMPILER \"%s%s\")\n", buildCMakePath(pathToCC), "g++"))
	}
	// Add all sources to the project.
	f.WriteString("list(APPEND\n")
	f.WriteString(" SOURCE_FILES\n")
	for _, src := range srcs {
	f.WriteString(fmt.Sprintf(" ${ANDROID_ROOT}/%s\n", src.String()))
	}
	f.WriteString(")\n")

	// Add all header search path and compiler parameters (-D, -W, -f, -XXXX)
	f.WriteString("\n# GLOBAL FLAGS:\n")
	globalParameters := parseCompilerParameters(ccModule.flags.GlobalFlags, ctx, f)
	translateToCMake(globalParameters, f, true, true)

	f.WriteString("\n# CFLAGS:\n")
	cParameters := parseCompilerParameters(ccModule.flags.CFlags, ctx, f)
	translateToCMake(cParameters, f, true, true)

	f.WriteString("\n# C ONLY FLAGS:\n")
	cOnlyParameters := parseCompilerParameters(ccModule.flags.ConlyFlags, ctx, f)
	translateToCMake(cOnlyParameters, f, true, false)

	f.WriteString("\n# CPP FLAGS:\n")
	cppParameters := parseCompilerParameters(ccModule.flags.CppFlags, ctx, f)
	translateToCMake(cppParameters, f, false, true)

	// Add project executable.
	f.WriteString(fmt.Sprintf("\nadd_executable(%s ${SOURCE_FILES})\n", ccModule.ModuleBase.Name()))
	}

	func translateToCMake(c compilerParameters, f *os.File, cflags bool, cppflags bool) {
	writeAllSystemDirectories(c.systemHeaderSearchPath, f)
	writeAllIncludeDirectories(c.headerSearchPath, f)
	if cflags {
	writeAllFlags(c.flags, f, "CMAKE_C_FLAGS")
	}

	if cppflags {
	writeAllFlags(c.flags, f, "CMAKE_CXX_FLAGS")
	}
	if c.sysroot != "" {
	f.WriteString(fmt.Sprintf("include_directories(SYSTEM \"%s\")\n", buildCMakePath(path.Join(c.sysroot, "usr", "include"))))
	}

	}

	func buildCMakePath(p string) string {
	if path.IsAbs(p) {
	return p
	}
	return fmt.Sprintf("${ANDROID_ROOT}/%s", p)
	}

	func writeAllIncludeDirectories(includes map[string]bool, f *os.File) {
	for include := range includes {
	f.WriteString(fmt.Sprintf("include_directories(\"%s\")\n", buildCMakePath(include)))
	}
	}

	func writeAllSystemDirectories(includes map[string]bool, f *os.File) {
	for include := range includes {
	f.WriteString(fmt.Sprintf("include_directories(SYSTEM \"%s\")\n", buildCMakePath(include)))
	}
	}

	func writeAllFlags(flags []string, f *os.File, tag string) {
	for _, flag := range flags {
	f.WriteString(fmt.Sprintf("set(%s \"${%s} %s\")\n", tag, tag, flag))
	}
	}

	type parameterType int

	const (
	headerSearchPath parameterType = iota
	variable
	systemHeaderSearchPath
	flag
	systemRoot
	)

	type compilerParameters struct {
	headerSearchPath map[string]bool
	systemHeaderSearchPath map[string]bool
	flags []string
	sysroot string
	}

	func makeCompilerParameters() compilerParameters {
	return compilerParameters{
	headerSearchPath: make(map[string]bool),
	systemHeaderSearchPath: make(map[string]bool),
	flags: make([]string, 0),
	sysroot: "",
	}
	}

	func categorizeParameter(parameter string) parameterType {
	if strings.HasPrefix(parameter, "-I") {
	return headerSearchPath
	}
	if strings.HasPrefix(parameter, "$") {
	return variable
	}
	if strings.HasPrefix(parameter, "-isystem") {
	return systemHeaderSearchPath
	}
	if strings.HasPrefix(parameter, "-isysroot") {
	return systemRoot
	}
	if strings.HasPrefix(parameter, "--sysroot") {
	return systemRoot
	}
	return flag
	}

	func parseCompilerParameters(params []string, ctx blueprint.SingletonContext, f *os.File) compilerParameters {
	var compilerParameters = makeCompilerParameters()

	for i, str := range params {
	f.WriteString(fmt.Sprintf("# Raw param [%d] = '%s'\n", i, str))
	}

	for i := 0; i < len(params); i++ {
	param := params[i]
	if param == "" {
	continue
	}

	switch categorizeParameter(param) {
	case headerSearchPath:
	compilerParameters.headerSearchPath[strings.TrimPrefix(param, "-I")] = true
	case variable:
	if evaluated, error := evalVariable(ctx, param); error == nil {
	if outputDebugInfo {
	f.WriteString(fmt.Sprintf("# variable %s = '%s'\n", param, evaluated))
	}

	paramsFromVar := parseCompilerParameters(strings.Split(evaluated, " "), ctx, f)
	concatenateParams(&compilerParameters, paramsFromVar)

	} else {
	if outputDebugInfo {
	f.WriteString(fmt.Sprintf("# variable %s could NOT BE RESOLVED\n", param))
	}
	}
	case systemHeaderSearchPath:
	if i < len(params)-1 {
	compilerParameters.systemHeaderSearchPath[params[i+1]] = true
	} else if outputDebugInfo {
	f.WriteString("# Found a header search path marker with no path")
	}
	i = i + 1
	case flag:
	c := cleanupParameter(param)
	f.WriteString(fmt.Sprintf("# FLAG '%s' became %s\n", param, c))
	compilerParameters.flags = append(compilerParameters.flags, c)
	case systemRoot:
	if i < len(params)-1 {
	compilerParameters.sysroot = params[i+1]
	} else if outputDebugInfo {
	f.WriteString("# Found a system root path marker with no path")
	}
	i = i + 1
	}
	}
	return compilerParameters
	}

	func cleanupParameter(p string) string {
	// In the blueprint, c flags can be passed as:
	// cflags: [ "-DLOG_TAG=\"libEGL\"", ]
	// which becomes:
	// '-DLOG_TAG="libEGL"' in soong.
	// In order to be injected in CMakelists.txt we need to:
	// - Remove the wrapping ' character
	// - Double escape all special \ and " characters.
	// For a end result like:
	// -DLOG_TAG=\\\"libEGL\\\"
	if !strings.HasPrefix(p, "'") \|\| !strings.HasSuffix(p, "'") \|\| len(p) < 3 {
	return p
	}

	// Reverse wrapper quotes and escaping that may have happened in NinjaAndShellEscape
	// TODO: It is ok to reverse here for now but if NinjaAndShellEscape becomes more complex,
	// we should create a method NinjaAndShellUnescape in escape.go and use that instead.
	p = p[1 : len(p)-1]
	p = strings.Replace(p, `'\''`, `'`, -1)
	p = strings.Replace(p, `$$`, `$`, -1)

	p = doubleEscape(p)
	return p
	}

	func escape(s string) string {
	s = strings.Replace(s, `\`, `\\`, -1)
	s = strings.Replace(s, `"`, `\"`, -1)
	return s
	}

	func doubleEscape(s string) string {
	s = escape(s)
	s = escape(s)
	return s
	}

	func concatenateParams(c1 *compilerParameters, c2 compilerParameters) {
	concatenateMaps(c1.headerSearchPath, c2.headerSearchPath)
	concatenateMaps(c1.systemHeaderSearchPath, c2.systemHeaderSearchPath)
	if c2.sysroot != "" {
	c1.sysroot = c2.sysroot
	}
	c1.flags = append(c1.flags, c2.flags...)
	}

	func evalVariable(ctx blueprint.SingletonContext, str string) (string, error) {
	evaluated, err := ctx.Eval(pctx, str)
	if err == nil {
	return evaluated, nil
	}
	return "", err
	}

	// Concatenate two maps into one. Results are stored in first operand.
	func concatenateMaps(map1 map[string]bool, map2 map[string]bool) {
	for key, value := range map2 {
	map1[key] = value
	}
	}

	func getCMakeListsForModule(module *Module, ctx blueprint.SingletonContext) string {
	return filepath.Join(getAndroidSrcRootDirectory(ctx),
	cLionOutputProjectsDirectory,
	path.Dir(ctx.BlueprintFile(module)),
	module.ModuleBase.Name()+"-"+
	module.ModuleBase.Arch().ArchType.Name+"-"+
	module.ModuleBase.Os().Name,
	cMakeListsFilename)
	}

	func getAndroidSrcRootDirectory(ctx blueprint.SingletonContext) string {
	srcPath, _ := filepath.Abs(android.PathForSource(ctx).String())
	return srcPath
	}