AvalonStudio.Toolchains.Clang.ClangGCCToolchain.GetCompilerArguments C# (CSharp) Method

		public override string GetCompilerArguments(IStandardProject superProject, IStandardProject project, ISourceFile file)
		{
			var result = string.Empty;

			//var settings = GetSettings(project).CompileSettings;
			var settings = GetSettings(superProject);

			result += "-Wall -c ";

			if (settings.CompileSettings.DebugInformation)
			{
				result += "-g ";
			}

			if (file == null || file.Language == Language.Cpp)
			{
				switch (settings.CompileSettings.CppLanguageStandard)
				{
					case CppLanguageStandard.Cpp98:
						result += "-std=c++98 ";
						break;

					case CppLanguageStandard.Cpp03:
						result += "-std=c++03 ";
						break;

					case CppLanguageStandard.Cpp11:
						result += "-std=c++11 ";
						break;

					case CppLanguageStandard.Cpp14:
						result += "-std=c++14 ";
						break;

					case CppLanguageStandard.Cpp17:
						result += "-std=c++17 ";
						break;

					default:
						break;
				}
			}

			if (file == null || file.Language == Language.C)
			{
				switch (settings.CompileSettings.CLanguageStandard)
				{
					case CLanguageStandard.C89:
						result += "-std=c89 ";
						break;

					case CLanguageStandard.C99:
						result += "-std=c99 ";
						break;

					case CLanguageStandard.C11:
						result += "-std=c11 ";
						break;
				}
			}


			switch (settings.CompileSettings.Fpu)
			{
				case FPUSupport.Soft:
					result += "-mfpu=fpv4-sp-d16 -mfloat-abi=soft ";
					break;

				case FPUSupport.Hard:
					result += "-mfpu=fpv4-sp-d16 -mfloat-abi=hard ";
					break;
			}


			// TODO remove dependency on file?
			if (file != null)
			{
				if (file.Language == Language.Cpp)
				{
					if (!settings.CompileSettings.Rtti)
					{
						result += "-fno-rtti ";
					}

					if (!settings.CompileSettings.Exceptions)
					{
						result += "-fno-exceptions ";
					}
				}
			}

			switch (settings.CompileSettings.Fpu)
			{
				case FPUSupport.Soft:
				{
					result += "-mfpu=fpv4-sp-d16 -mfloat-abi=soft ";
				}
					break;

				case FPUSupport.Hard:
				{
					result += "-mfpu=fpv4-sp-d16 -mfloat-abi=hard ";
				}
					break;
			}

			// TODO make this an option.
			result += "-ffunction-sections -fdata-sections ";

			switch (settings.CompileSettings.Optimization)
			{
				case OptimizationLevel.None:
				{
					result += "-O0 ";
				}
					break;

				case OptimizationLevel.Debug:
				{
					result += "-Og ";
				}
					break;

				case OptimizationLevel.Level1:
				{
					result += "-O1 ";
				}
					break;

				case OptimizationLevel.Level2:
				{
					result += "-O2 ";
				}
					break;

				case OptimizationLevel.Level3:
				{
					result += "-O3 ";
				}
					break;
			}

			switch (settings.CompileSettings.OptimizationPreference)
			{
				case OptimizationPreference.Size:
				{
					result += "-Os ";
				}
					break;

				case OptimizationPreference.Speed:
				{
					result += "-Ofast ";
				}
					break;
			}

			result += settings.CompileSettings.CustomFlags + " ";

			// toolchain includes

			// Referenced includes
			var referencedIncludes = project.GetReferencedIncludes();

			foreach (var include in referencedIncludes)
			{
				result += string.Format("-I\"{0}\" ", Path.Combine(project.CurrentDirectory, include));
			}

			// global includes
			var globalIncludes = superProject.GetGlobalIncludes();

			foreach (var include in globalIncludes)
			{
				result += string.Format("-I\"{0}\" ", include);
			}

			// public includes
			foreach (var include in project.PublicIncludes)
			{
				result += string.Format("-I\"{0}\" ", Path.Combine(project.CurrentDirectory, include));
			}

			// includes
			foreach (var include in project.Includes)
			{
				result += string.Format("-I\"{0}\" ", Path.Combine(project.CurrentDirectory, include.Value));
			}

			var referencedDefines = project.GetReferencedDefines();
			foreach (var define in referencedDefines)
			{
				result += string.Format("-D{0} ", define);
			}

			// global includes
			var globalDefines = superProject.GetGlobalDefines();

			foreach (var define in globalDefines)
			{
				result += string.Format("-D{0} ", define);
			}

			foreach (var define in project.Defines)
			{
				result += string.Format("-D{0} ", define.Value);
			}

			foreach (var arg in superProject.ToolChainArguments)
			{
				result += string.Format(" {0}", arg);
			}

			foreach (var arg in superProject.CompilerArguments)
			{
				result += string.Format(" {0}", arg);
			}

			// TODO factor out this code from here!
			if (file != null)
			{
				switch (file.Language)
				{
					case Language.C:
					{
						foreach (var arg in superProject.CCompilerArguments)
						{
							result += string.Format(" {0}", arg);
						}
					}
						break;

					case Language.Cpp:
					{
						foreach (var arg in superProject.CppCompilerArguments)
						{
							result += string.Format(" {0}", arg);
						}
					}
						break;
				}
			}

			return result;
		}