static void AddPath(FileCompilationInfo entry, string prefix, string path)
{
if (string.IsNullOrWhiteSpace(path))
{
return;
}
foreach (var s in path?.Split(Path.PathSeparator))
{
entry.AddArg(prefix + QuatePath(s));
}
}
static FileCompilationInfo ProcessVCFile(ProgramOptions options, FileCompilationInfo entry, VCFile file, VCFileConfiguration fileConfig, string arch, bool isWin64)
{
//WriteLine($"{file.RelativePath}: {file.FileType},{file.Kind},{file.SubType},{file.ItemName},{file.UnexpandedRelativePath}");
if (fileConfig.ExcludedFromBuild)
{
Console.Error.WriteLine($"warning: `{file.Name}` Excluded FromBuild.");
return(null);
}
switch (file.FileType)
{
case eFileType.eFileTypeCppClass:
case eFileType.eFileTypeCppCode:
case eFileType.eFileTypeCppControl:
case eFileType.eFileTypeCppForm:
case eFileType.eFileTypeCppHeader:
case eFileType.eFileTypeCppWebService:
break;
default:
return(null);
}
var isHeader = (file.FileType == eFileType.eFileTypeCppHeader);
WriteLine(file.RelativePath);
if (options.OnlyConvertToUtf8 || options.ConvertToUtf8OnTheFly)
{
ConverToUtf8(file.FullPath);
if (options.OnlyConvertToUtf8)
{
return(null);
}
}
entry.file = StripCurrentDir(file.RelativePath);
VCConfiguration projectConfig = fileConfig.ProjectConfiguration;
var projectTool = projectConfig.Tools.Item(VCCLCompilerToolName) is WCE.VCCLWCECompilerToolBase ?
new WCECompilerToolWrapper(projectConfig.Tools.Item(VCCLCompilerToolName)) :
projectConfig.Tools.Item(VCCLCompilerToolName) as VCCLCompilerTool;
var fileTool = fileConfig.Tool is WCE.VCCLWCECompilerToolBase ?
new WCECompilerToolWrapper(fileConfig.Tool) :
fileConfig.Tool as VCCLCompilerTool;
// if file is header, filetool is null.
var tool = fileTool ?? projectTool;
if (isHeader && !options.IncludesHeaderFiles)
{
return(null);
}
var createPch = tool.UsePrecompiledHeader == pchOption.pchCreateUsingSpecific;
var pchFilePath = fileConfig.Evaluate(tool.PrecompiledHeaderFile);
entry.AddArg(isWin64 ? "-m64" : "-m32");
entry.AddArg("--target=" + arch + "-pc-windows-msvc");
entry.AddArg("-fshort-wchar");
AddPath(entry, "-D ", fileConfig.Evaluate(projectTool.PreprocessorDefinitions + fileTool?.PreprocessorDefinitions) ?? "");
AddPath(entry, "-U ", fileConfig.Evaluate(projectTool.UndefinePreprocessorDefinitions + fileTool?.UndefinePreprocessorDefinitions) ?? "");
AddPath(entry, "-I ", tool.FullIncludePath);
AddPath(entry, "-include ", fileConfig.Evaluate(tool.ForcedIncludeFiles ?? projectTool.ForcedIncludeFiles));
if (createPch)
{
entry.output = pchFilePath;
entry.AddArg("-o");
entry.AddArg(QuatePath(entry.output));
}
else if (isHeader)
{
entry.AddArg("-S"); // Only run preprocess and compilation steps
// fsyntax-only
}
else
{
entry.AddArg("-c"); // Only run preprocess, compile, and assemble steps
entry.output = Path.Combine(fileConfig.Evaluate(tool.ObjectFile), Path.ChangeExtension(file.Name, ".obj"));
entry.AddArg("-o");
entry.AddArg(QuatePath(entry.output));
}
if (tool.UsePrecompiledHeader == pchOption.pchUseUsingSpecific)
{
entry.AddArg("-include-pch");
entry.AddArg(QuatePath(pchFilePath));
}
switch (tool.WarningLevel)
{
case warningLevelOption.warningLevel_4:
entry.AddArg("-Wall");
entry.AddArg("-Wextra");
entry.AddArg("-Wno-undef");
entry.AddArg("-Wno-c++11-extensions");
entry.AddArg("-Wno-unknown-pragmas");
//entry.AddArg("-Wno-old-style-cast");
//entry.AddArg("-Wno-gnu-anonymous-struct");
//entry.AddArg("-Wno-gnu-zero-variadic-macro-arguments");
//entry.AddArg("-Wno-reserved-id-macro");
//entry.AddArg("-Wno-c++11-long-long");
//entry.AddArg("-Wno-language-extension-token");
//entry.AddArg("-Wno-non-virtual-dtor");
//entry.AddArg("-Wno-dollar-in-identifier-extension");
//entry.AddArg("-Wno-zero-length-array");
break;
case warningLevelOption.warningLevel_3:
case warningLevelOption.warningLevel_2:
case warningLevelOption.warningLevel_1:
entry.AddArg("-Wall");
break;
}
if (!options.NowWarnAsError && tool.WarnAsError)
{
entry.AddArg("-Werror");
}
switch (tool.Optimization)
{
case optimizeOption.optimizeFull:
entry.AddArg("-O3");
break;
case optimizeOption.optimizeMaxSpeed:
entry.AddArg("-O2");
break;
case optimizeOption.optimizeMinSpace:
entry.AddArg("-O1");
break;
}
if (tool.DebugInformationFormat != debugOption.debugDisabled)
{
entry.AddArg("-g");
}
entry.AddArg(tool.RuntimeTypeInfo ? "-frtti" : "-fno-rtti");
switch (tool.ExceptionHandling)
{
case cppExceptionHandling.cppExceptionHandlingYesWithSEH:
entry.AddArg("-fseh-exceptions");
if (tool.CompileAs == CompileAsOptions.compileAsCPlusPlus)
{
entry.AddArg("-fcxx-exceptions");
}
break;
case cppExceptionHandling.cppExceptionHandlingYes:
entry.AddArg("-fcxx-exceptions");
break;
case cppExceptionHandling.cppExceptionHandlingNo:
entry.AddArg("-fno-cxx-exceptions");
break;
}
switch (tool.InlineFunctionExpansion)
{
case inlineExpansionOption.expandDisable:
entry.AddArg("-fno-inline-functions");
break;
case inlineExpansionOption.expandOnlyInline:
entry.AddArg("-finline-hint-functions");
break;
case inlineExpansionOption.expandAnySuitable:
entry.AddArg("-finline-functions");
break;
}
if (tool.EnableIntrinsicFunctions)
{
entry.AddArg("-fbuiltin");
}
switch (tool.CompileAs)
{
case CompileAsOptions.compileAsC:
entry.AddArg("-x c" + (createPch ? "-header" : ""));
entry.AddArg("-std=c99");
break;
case CompileAsOptions.compileAsCPlusPlus:
entry.AddArg("-x c++" + (createPch ? "-header" : ""));
entry.AddArg("-std=c++03");
break;
}
{
string msvcVer = default;
(file.project as VCProject).Version(out var major, out var minor);
switch ($"{ major}.{minor}")
{
case "8.0":
msvcVer = "14.00";
break;
case "7.1":
msvcVer = "13.10";
break;
case "7.0":
msvcVer = "13.00";
break;
default:
case "9.0":
msvcVer = "15.00";
break;
}
entry.AddArg("-fms-compatibility-version=" + msvcVer);
}
switch (tool.CallingConvention)
{
case callingConventionOption.callConventionCDecl:
//entry.AddArg("-fdefault-calling-conv=cdecl");
break;
case callingConventionOption.callConventionStdCall:
entry.AddArg("-mrtd");
//entry.AddArg("-fdefault-calling-conv=stdcall");
break;
case callingConventionOption.callConventionFastCall:
Console.Error.WriteLine($"warning: Not supported CallingConvention: {tool.CallingConvention}.");
//entry.AddArg("-fdefault-calling-conv=fastcall");
break;
}
string crt = default;
switch (tool.RuntimeLibrary)
{
case runtimeLibraryOption.rtMultiThreaded:
entry.AddArg("-D_MT");
crt = "--dependent-lib=libcmt";
break;
case runtimeLibraryOption.rtMultiThreadedDebug:
entry.AddArg("-D_MT");
crt = "--dependent-lib=libcmtd";
break;
case runtimeLibraryOption.rtMultiThreadedDLL:
entry.AddArg("-D_MT");
entry.AddArg("-D_DLL");
crt = "--dependent-lib=msvcrt";
break;
case runtimeLibraryOption.rtMultiThreadedDebugDLL:
entry.AddArg("-D_MT");
entry.AddArg("-D_DLL");
crt = "--dependent-lib=msvcrtd";
break;
}
if (tool.OmitDefaultLibName)
{
entry.AddArg("-D_VC_NODEFAULTLIB");
}
else
{
//TODO entry.AddArg(crt);
}
if (!tool.DisableLanguageExtensions)
{
entry.AddArg("-fms-extensions");
entry.AddArg("-Wno-microsoft-goto");
entry.AddArg("-Wno-microsoft-exception-spec");
entry.AddArg("-Wno-microsoft-enum-value");
entry.AddArg("-Wno-microsoft-comment-paste");
entry.AddArg("-Wno-microsoft-cast");
entry.AddArg("-Wno-microsoft-anon-tag");
}
if (tool.BufferSecurityCheck)
{
entry.AddArg("-fstack-protector");
}
if (tool.ShowIncludes)
{
entry.AddArg("--trace-includes");
}
if (tool.UndefineAllPreprocessorDefinitions)
{
entry.AddArg("-undef");
}
if (!tool.StringPooling)
{
entry.AddArg("-fwritable-strings");
}
if (tool.DefaultCharIsUnsigned)
{
entry.AddArg("-fno-signed-char");
}
switch (tool.StructMemberAlignment)
{
case structMemberAlignOption.alignSingleByte:
entry.AddArg("-fpack-struct=1");
break;
case structMemberAlignOption.alignTwoBytes:
entry.AddArg("-fpack-struct=2");
break;
case structMemberAlignOption.alignFourBytes:
entry.AddArg("-fpack-struct=4");
break;
case structMemberAlignOption.alignEightBytes:
entry.AddArg("-fpack-struct=8");
break;
case structMemberAlignOption.alignSixteenBytes:
entry.AddArg("-fpack-struct=16");
break;
case structMemberAlignOption.alignNotSet:
break;
}
if (tool.OmitFramePointers)
{
entry.AddArg("-momit-leaf-frame-pointer");
}
switch (tool.floatingPointModel)
{
case floatingPointModel.FloatingPointFast:
entry.AddArg("-ffast-math");
break;
}
if (tool.EnablePREfast)
{
entry.AddArg("--analyze");
}
entry.AddArg(QuatePath(entry.file));
if (options.PrintClangCommand)
{
Console.Error.WriteLine(entry.ToString());
}
return(entry);
}
