Meta.VCCompilerHelper.GenerateCLCmdArgs C# (CSharp) Method

GenerateCLCmdArgs() public method

public GenerateCLCmdArgs ( ) : string
return string
        public string GenerateCLCmdArgs()
        {
            StringBuilder cmd = new StringBuilder();

            if(config.CharacterSet == charSet.charSetUnicode)
                cmd.Append( " /D _UNICODE /D UNICODE" );

            if( config.useOfMfc == useOfMfc.useMfcDynamic )
                cmd.Append( " /D _AFXDLL" );

            if( cltool.Optimization == optimizeOption.optimizeDisabled )
                cmd.Append( " /Od" );
            else if( cltool.Optimization == optimizeOption.optimizeFull )
                cmd.Append( " /Ox" );
            else if( cltool.Optimization == optimizeOption.optimizeMaxSpeed )
                cmd.Append( " /O2" );
            else if( cltool.Optimization == optimizeOption.optimizeMinSpace )
                cmd.Append( " /O1" );

            string [] includes = cltool.AdditionalIncludeDirectories.Split(';');
            foreach (string i in includes)
            {
                if( !String.IsNullOrWhiteSpace(i) )
                    cmd.Append(" \"/I " + i + "\"");
            }

            string [] forcedIncludes = cltool.ForcedIncludeFiles.Split(';');
            foreach (string i in forcedIncludes)
            {
                if (!String.IsNullOrWhiteSpace(i))
                    cmd.Append(" \"/FI " + i + "\"");
            }

            string [] preprocessorDefs = cltool.PreprocessorDefinitions.Split(';');
            foreach (string d in preprocessorDefs)
            {
                if (!String.IsNullOrWhiteSpace(d))
                    cmd.Append(" /D" + d);
            }

            string [] preprocessorUnDefs = cltool.UndefinePreprocessorDefinitions.Split(';');
            foreach (string d in preprocessorUnDefs)
            {
                if (!String.IsNullOrWhiteSpace(d))
                    cmd.Append(" /U" + d);
            }

            if( cltool.MinimalRebuild )
                cmd.Append(" /Gm");

            if( cltool.ExceptionHandling == cppExceptionHandling.cppExceptionHandlingYes )
                cmd.Append(" /EHsc");
            else if( cltool.ExceptionHandling == cppExceptionHandling.cppExceptionHandlingYesWithSEH )
                cmd.Append(" /EHa");

            if( cltool.BasicRuntimeChecks == basicRuntimeCheckOption.runtimeBasicCheckAll )
                cmd.Append( " /RTC1");
            else if( cltool.BasicRuntimeChecks == basicRuntimeCheckOption.runtimeCheckStackFrame )
                cmd.Append( " /RTCs");
            else if( cltool.BasicRuntimeChecks == basicRuntimeCheckOption.runtimeCheckUninitVariables )
                cmd.Append( " /RTCu");

            if( cltool.RuntimeLibrary == runtimeLibraryOption.rtMultiThreaded )
                cmd.Append( " /MT" );
            else if( cltool.RuntimeLibrary == runtimeLibraryOption.rtMultiThreadedDebug )
                cmd.Append( " /MTd" );
            else if( cltool.RuntimeLibrary == runtimeLibraryOption.rtMultiThreadedDebugDLL )
                cmd.Append( " /MDd" );
            else if( cltool.RuntimeLibrary == runtimeLibraryOption.rtMultiThreadedDLL )
                cmd.Append( " /MD" );

            if( cltool.RuntimeTypeInfo)
                cmd.Append(" /GR");

            if( cltool.BrowseInformation == browseInfoOption.brAllInfo )
                cmd.Append(" /FR" + cltool.BrowseInformationFile);
            else if( cltool.BrowseInformation == browseInfoOption.brNoLocalSymbols )
                cmd.Append(" /Fr " + cltool.BrowseInformationFile);

            if( cltool.BufferSecurityCheck )
                cmd.Append( " /GS");

            if( cltool.CallingConvention == callingConventionOption.callConventionCDecl )
                cmd.Append( " /Gd");
            else if( cltool.CallingConvention == callingConventionOption.callConventionFastCall )
                cmd.Append( " /Gr");
            else if( cltool.CallingConvention == callingConventionOption.callConventionStdCall )
                cmd.Append( " /Gz");

            if( cltool.CompileAs == CompileAsOptions.compileAsC )
                cmd.Append( " /TC");
            else if( cltool.CompileAs == CompileAsOptions.compileAsCPlusPlus )
                cmd.Append( " /TP");

            if( cltool.CompileAsManaged == compileAsManagedOptions.managedAssembly )
                cmd.Append( " /clr");
            else if( cltool.CompileAsManaged == compileAsManagedOptions.managedAssemblyPure )
                cmd.Append( " /clr:pure");
            else if( cltool.CompileAsManaged == compileAsManagedOptions.managedAssemblySafe )
                cmd.Append( " /clr:safe");
            else if( cltool.CompileAsManaged == compileAsManagedOptions.managedAssemblyOldSyntax )
                cmd.Append( " /clr:oldSyntax");
            //else if( cltool.CompileAsManaged == compileAsManagedOptions.managedNotSet )
            //    cmd.Append( " /clr:noAssembly");

            if( cltool.CompileOnly )
                cmd.Append( " /c");

            if( cltool.DebugInformationFormat == debugOption.debugDisabled )
                cmd.Append( " /Z7");
            else if( cltool.DebugInformationFormat == debugOption.debugEnabled )
                cmd.Append( " /Zi");
            else if( cltool.DebugInformationFormat == debugOption.debugEditAndContinue )
                cmd.Append( " /ZI");
            else if( cltool.DebugInformationFormat == debugOption.debugOldStyleInfo )
                cmd.Append( " /Zd");

            if( cltool.DefaultCharIsUnsigned )
                cmd.Append(" /J");

            if( cltool.DisableLanguageExtensions )
                cmd.Append(" /Za");

            if( cltool.EnableEnhancedInstructionSet == enhancedInstructionSetType.enhancedInstructionSetTypeSIMD )
                cmd.Append(" /ARCH:sse");
            else if( cltool.EnableEnhancedInstructionSet == enhancedInstructionSetType.enhancedInstructionSetTypeSIMD2 )
                cmd.Append(" /ARCH:sse2");

            if( cltool.EnableFiberSafeOptimizations )
                cmd.Append(" /GT");

            if( cltool.EnableFunctionLevelLinking )
                cmd.Append(" /Gy");

            if( cltool.EnableIntrinsicFunctions )
                cmd.Append(" /Oi");

            if( cltool.ExpandAttributedSource)
                cmd.Append(" /Fx");

            if( cltool.FavorSizeOrSpeed == favorSizeOrSpeedOption.favorSize )
                cmd.Append(" /Os");
            else if( cltool.FavorSizeOrSpeed == favorSizeOrSpeedOption.favorSpeed )
                cmd.Append(" /Ot");

            if( cltool.IgnoreStandardIncludePath )
                cmd.Append(" /X");

            if( cltool.InlineFunctionExpansion == inlineExpansionOption.expandOnlyInline )
                cmd.Append(" /Ob1");
            else if( cltool.InlineFunctionExpansion == inlineExpansionOption.expandAnySuitable )
                cmd.Append(" /Ob2");

            if( cltool.KeepComments )
                cmd.Append(" /C");

            if( !String.IsNullOrEmpty( cltool.ObjectFile ) )
                cmd.Append(" /Fo " + cltool.ObjectFile);

            if( cltool.OmitFramePointers )
                cmd.Append(" /Oy");

            if( cltool.UsePrecompiledHeader == pchOption.pchCreateUsingSpecific )
                cmd.Append( " /Yc \"" + cltool.PrecompiledHeaderThrough + "\"" );
            if( cltool.UsePrecompiledHeader == pchOption.pchUseUsingSpecific )
                cmd.Append( " /Yu \"" + cltool.PrecompiledHeaderThrough + "\"" );

            if( !String.IsNullOrEmpty(cltool.PrecompiledHeaderFile) )
                cmd.Append(" /Fp " + cltool.PrecompiledHeaderFile);

            if( !String.IsNullOrEmpty(cltool.ProgramDataBaseFileName) )
                cmd.Append(" /Fd " + cltool.ProgramDataBaseFileName);

            if( cltool.WholeProgramOptimization )
                cmd.Append(" /GL");

            if( cltool.RuntimeTypeInfo )
                cmd.Append( "/GR");

            if( cltool.StringPooling )
                cmd.Append(" /GF");

            if( cltool.SuppressStartupBanner )
                cmd.Append(" /nologo");

            if (!cltool.TreatWChar_tAsBuiltInType)
                cmd.Append(" /Zc:wchar_t-");

            if( !cltool.ForceConformanceInForLoopScope )
                cmd.Append(" /Zc:forScope-");

            if( cltool.WarningLevel == warningLevelOption.warningLevel_1 )
                cmd.Append( " /W1" );
            else if( cltool.WarningLevel == warningLevelOption.warningLevel_2 )
                cmd.Append( " /W2" );
            else if( cltool.WarningLevel == warningLevelOption.warningLevel_3 )
                cmd.Append( " /W3" );
            else if( cltool.WarningLevel == warningLevelOption.warningLevel_4 )
                cmd.Append( " /W4" );

            if( cltool.WarnAsError )
                cmd.Append(" /WX");

            string [] disableWarnings = cltool.DisableSpecificWarnings.Split(';');
            foreach (string d in disableWarnings)
            {
                if (!String.IsNullOrWhiteSpace(d))
                    cmd.Append(" /wd" + d);
            }

            if( cltool.ErrorReporting == compilerErrorReportingType.compilerErrorReportingPrompt )
                cmd.Append(" /errorReport:prompt");
            else if( cltool.ErrorReporting == compilerErrorReportingType.compilerErrorReportingQueue )
                cmd.Append(" /errorReport:queue");

            if (!String.IsNullOrWhiteSpace(cltool.AdditionalOptions))
                cmd.Append(" " + cltool.AdditionalOptions);

            string cmdLine = cmd.ToString();

            //! Replace macros
            foreach (string macro in ProjectMacros.Collection)
            {
                string result = config.Evaluate(macro);
                if (result != null)
                {
                    if (result.HasWhiteSpace())
                        result = result.Quote();//add quotes if there are spaces.
                    cmdLine = cmdLine.Replace(macro, result, StringComparison.CurrentCultureIgnoreCase);
                }
            }

            return cmdLine;
        }

Same methods

VCCompilerHelper::GenerateCLCmdArgs ( string filename, bool skipPrecompiledHeader = true, bool skipObjectFile = true, bool skipMinimalRebuild = true ) : string