/// <summary> /// Initializes a new instance of the <see cref="ServiceArguments"/> class, explicitly specifying the arguments. /// Typically used in tests. /// </summary> /// <param name="serviceStartupMode">Optional. The service startup mode to use.</param> /// <param name="consoleOutputMode">Optional. The console output mode to use.</param> /// <param name="basePortOverride">Optional. The base port override to use, or null to not override the base port.</param> public ServiceArguments(ServiceStartupMode serviceStartupMode = ServiceStartupMode.Unspecified, ConsoleOutputMode consoleOutputMode = ConsoleOutputMode.Unspecified, int?basePortOverride = null, string instanceName = null, int?shutdownWhenPidExits = null, int?slotNumber = null, int?shutdownWaitTimeSec = null, int?serviceDrainTimeSec = null) { ServiceStartupMode = serviceStartupMode; ConsoleOutputMode = consoleOutputMode; BasePortOverride = basePortOverride; InstanceName = instanceName; ShutdownWhenPidExits = shutdownWhenPidExits; SlotNumber = slotNumber; OnStopWaitTimeSec = shutdownWaitTimeSec; ApplyDefaults(); }
private static void Main(string[] args) { Console.WriteLine("Hello World!"); ConsoleOutputMode consoleOutputMode = new ConsoleOutputMode(); ConsoleInputMode consoleInputMode = new ConsoleInputMode(); DisplayObject("ConsoleOutputMode", consoleOutputMode); consoleOutputMode.IsEnableVirtualTerminalProcessing = false; consoleOutputMode.IsDisabledNewLineAutoReturn = true; string line = new string('=', 120); Console.WriteLine(line); Console.Write(line); DisplayObject("ConsoleOutputMode", consoleOutputMode); Pause.QuickDisplay(); }
public UsageException() { m_outputMode = ConsoleOutputMode.Console; }
public UsageException(string message, Exception innerException) : base(message, innerException) { m_outputMode = ConsoleOutputMode.Console; }
protected UsageException(SerializationInfo info, StreamingContext context) : base(info, context) { if (info == null) { throw new ArgumentException(StringMgr.GetString("InternalCompilerError")); } m_outputMode = ConsoleOutputMode.Console; }
public UsageException(ConsoleOutputMode outputMode, string format, params object[] args) : base(StringMgr.GetString(format, args)) { m_outputMode = outputMode; }
public UsageException(ConsoleOutputMode outputMode) : base(string.Empty) { m_outputMode = outputMode; }
private void ProcessArgs(string[] args) { List<string> inputFiles = new List<string>(); bool levelSpecified = false; bool renamingSpecified = false; for (int ndx = 0; ndx < args.Length; ++ndx) { // parameter switch string thisArg = args[ndx]; if (thisArg.Length > 1 && (thisArg.StartsWith("-", StringComparison.Ordinal) // this is a normal hyphen (minus character) || thisArg.StartsWith("–", StringComparison.Ordinal) // this character is what Word will convert a hyphen to || thisArg.StartsWith("/", StringComparison.Ordinal))) { // general switch syntax is -switch:param string[] parts = thisArg.Substring(1).Split(':'); string switchPart = parts[0].ToUpper(CultureInfo.InvariantCulture); string paramPart = (parts.Length == 1 ? null : parts[1].ToUpper(CultureInfo.InvariantCulture)); // switch off the switch part switch (switchPart) { case "ANALYZE": case "A": // <-- old-style // ignore any arguments m_analyze = true; break; case "ASPNET": BooleanSwitch(paramPart, switchPart, false, out m_allowAspNet); break; case "CC": BooleanSwitch(paramPart, switchPart, true, out m_ignoreConditionalCompilation); // actually, the flag is the opposite of the member -- turn CC ON and we DON'T // want to ignore them; turn CC OFF and we DO want to ignore them m_ignoreConditionalCompilation = !m_ignoreConditionalCompilation; JavaScriptOnly(); break; case "CLOBBER": // just putting the clobber switch on the command line without any arguments // is the same as putting -clobber:true and perfectly valid. BooleanSwitch(paramPart, switchPart, true, out m_clobber); break; case "COLORS": // two options: hex or names if (paramPart == "HEX") { m_colorNames = CssColor.Hex; } else if (paramPart == "STRICT") { m_colorNames = CssColor.Strict; } else if (paramPart == "MAJOR") { m_colorNames = CssColor.Major; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } CssOnly(); break; case "COMMENTS": // four options for css: none, all, important, or hacks // two options for js: none, important // (default is important) if (paramPart == "NONE") { m_cssComments = CssComment.None; m_preserveImportantComments = false; } else if (paramPart == "ALL") { m_cssComments = CssComment.All; CssOnly(); } else if (paramPart == "IMPORTANT") { m_cssComments = CssComment.Important; m_preserveImportantComments = true; } else if (paramPart == "HACKS") { m_cssComments = CssComment.Hacks; CssOnly(); } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } break; case "CSS": // if we've already declared JS, then error CssOnly(); break; case "DEBUG": // see if the param part is a comma-delimited list if (paramPart.IndexOf(',') >= 0) { // we have a comma-separated list. // the first item is the flag (if any), and the rest (if any) are the "debug" lookup names // use parts[1] rather than paramParts because paramParts has been forced to upper-case var items = parts[1].Split(','); // use the first value as the debug boolean switch BooleanSwitch(items[0], switchPart, true, out m_stripDebugStatements); // and the rest as names. // if we haven't created the list yet, do it now if (m_debugLookups == null) { m_debugLookups = new List<string>(); } // start with index 1, since index 0 was the flag for (var item = 1; item < items.Length; ++item) { // get the identifier that was specified var identifier = items[item]; // a blank identifier is okay -- we just ignore it if (!string.IsNullOrEmpty(identifier)) { // but if it's not blank, it better be a valid JavaScript identifier or member chain if (identifier.IndexOf('.') > 0) { // it's a member chain -- check that each part is a valid JS identifier var names = identifier.Split('.'); foreach (var name in names) { if (!JSScanner.IsValidIdentifier(name)) { throw new UsageException(m_outputMode, "InvalidSwitchArg", name, switchPart); } } } else { // no dot -- just an identifier if (!JSScanner.IsValidIdentifier(identifier)) { throw new UsageException(m_outputMode, "InvalidSwitchArg", identifier, switchPart); } } // don't add duplicates if (!m_debugLookups.Contains(identifier)) { m_debugLookups.Add(identifier); } } } } else { // no commas -- just use the entire param part as the boolean value. // just putting the debug switch on the command line without any arguments // is the same as putting -debug:true and perfectly valid. BooleanSwitch(paramPart, switchPart, true, out m_stripDebugStatements); } // actually the inverse - a TRUE on the -debug switch means we DON'T want to // strip debug statements, and a FALSE means we DO want to strip them m_stripDebugStatements = !m_stripDebugStatements; // this is a JS-only switch JavaScriptOnly(); break; case "DEFINE": // the parts can be a comma-separate list of identifiers if (string.IsNullOrEmpty(paramPart)) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } // use paramPart because it has been forced to upper-case and these identifiers are // supposed to be case-insensitive foreach (string upperCaseName in paramPart.Split(',')) { // better be a valid JavaScript identifier if (!JSScanner.IsValidIdentifier(upperCaseName)) { throw new UsageException(m_outputMode, "InvalidSwitchArg", upperCaseName, switchPart); } // if we haven't created the list yet, do it now if (m_defines == null) { m_defines = new List<string>(); } // don't add duplicates if (!m_defines.Contains(upperCaseName)) { m_defines.Add(upperCaseName); } } break; case "ECHO": case "I": // <-- old style // ignore any arguments m_echoInput = true; // -pretty and -echo are not compatible if (m_prettyPrint) { throw new UsageException(m_outputMode, "PrettyAndEchoArgs"); } break; case "ENC": // the encoding is the next argument if (ndx >= args.Length - 1) { // must be followed by an encoding throw new UsageException(m_outputMode, "EncodingArgMustHaveEncoding", switchPart); } string encoding = args[++ndx]; // whether this is an in or an out encoding if (paramPart == "IN") { // save the name -- we'll create the encoding later because we may // override it on a file-by-file basis in an XML file m_encodingInputName = encoding; } else if (paramPart == "OUT") { // just save the name -- we'll create the encoding later because we need // to know whether we are JS or CSS to pick the right encoding fallback m_encodingOutputName = encoding; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } break; case "EVALS": // three options: ignore, make immediate scope safe, or make all scopes safe if (paramPart == "IGNORE") { m_evalTreatment = EvalTreatment.Ignore; } else if (paramPart == "IMMEDIATE") { m_evalTreatment = EvalTreatment.MakeImmediateSafe; } else if (paramPart == "SAFEALL") { m_evalTreatment = EvalTreatment.MakeAllSafe; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } // this is a JS-only switch JavaScriptOnly(); break; case "EXPR": // two options: minify (default) or raw if (paramPart == "MINIFY") { m_minifyExpressions = true; } else if (paramPart == "RAW") { m_minifyExpressions = false; } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } CssOnly(); break; case "FNAMES": // three options: // LOCK -> keep all NFE names, don't allow renaming of function names // KEEP -> keep all NFE names, but allow function names to be renamed // ONLYREF -> remove unref'd NFE names, allow function named to be renamed (DEFAULT) if (paramPart == "LOCK") { // don't remove function expression names m_removeFunctionExpressionNames = false; // and preserve the names (don't allow renaming) m_preserveFunctionNames = true; } else if (paramPart == "KEEP") { // don't remove function expression names m_removeFunctionExpressionNames = false; // but it's okay to rename them m_preserveFunctionNames = false; } else if (paramPart == "ONLYREF") { // remove function expression names if they aren't referenced m_removeFunctionExpressionNames = true; // and rename them if we so desire m_preserveFunctionNames = false; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } // this is a JS-only switch JavaScriptOnly(); break; case "GLOBAL": case "G": // <-- old style // the parts can be a comma-separate list of identifiers if (string.IsNullOrEmpty(paramPart)) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } // use parts[1] rather than paramParts because paramParts has been forced to upper-case foreach (string global in parts[1].Split(',')) { // better be a valid JavaScript identifier if (!JSScanner.IsValidIdentifier(global)) { throw new UsageException(m_outputMode, "InvalidSwitchArg", global, switchPart); } // if we haven't created the list yet, do it now if (m_globals == null) { m_globals = new List<string>(); } // don't add duplicates if (!m_globals.Contains(global)) { m_globals.Add(global); } } // this is a JS-only switch JavaScriptOnly(); break; case "HELP": case "?": // just show usage throw new UsageException(m_outputMode); case "INLINE": // set safe for inline to the same boolean. // if no param part, will return false (indicating the default) // if invalid param part, will throw error if (!BooleanSwitch(paramPart, switchPart, true, out m_safeForInline)) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } // this is a JS-only switch JavaScriptOnly(); break; case "JS": // if we've already declared CSS, then error JavaScriptOnly(); break; case "KILL": // optional integer switch argument if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } // get the numeric portion if (paramPart.StartsWith("0X", StringComparison.OrdinalIgnoreCase)) { // it's hex -- convert the number after the "0x" if (!long.TryParse(paramPart.Substring(2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out m_killSwitch)) { throw new UsageException(m_outputMode, "InvalidKillSwitchArg", paramPart); } } else if (!long.TryParse(paramPart, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out m_killSwitch)) { throw new UsageException(m_outputMode, "InvalidKillSwitchArg", paramPart); } break; case "LITERALS": // two options: keep or combine if (paramPart == "KEEP") { m_combineDuplicateLiterals = false; } else if (paramPart == "COMBINE") { m_combineDuplicateLiterals = true; } else if (paramPart == "EVAL") { m_evalLiteralExpressions = true; } else if (paramPart == "NOEVAL") { m_evalLiteralExpressions = false; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } // this is a JS-only switch JavaScriptOnly(); break; case "MAC": // optional boolean switch // no arg is valid scenario (default is true) BooleanSwitch(paramPart, switchPart, true, out m_macSafariQuirks); // this is a JS-only switch JavaScriptOnly(); break; case "NEW": // two options: keep and collapse if (paramPart == "KEEP") { m_collapseToLiteral = false; } else if (paramPart == "COLLAPSE") { m_collapseToLiteral = true; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } // this is a JS-only switch JavaScriptOnly(); break; case "NFE": // <-- deprecate; use FNAMES option instead if (paramPart == "KEEPALL") { m_removeFunctionExpressionNames = false; } else if (paramPart == "ONLYREF") { m_removeFunctionExpressionNames = true; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } // this is a JS-only switch JavaScriptOnly(); break; case "NORENAME": // the parts can be a comma-separate list of identifiers if (string.IsNullOrEmpty(paramPart)) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } // use parts[1] rather than paramParts because paramParts has been forced to upper-case foreach (string ident in parts[1].Split(',')) { // better be a valid JavaScript identifier if (!JSScanner.IsValidIdentifier(ident)) { throw new UsageException(m_outputMode, "InvalidSwitchArg", ident, switchPart); } // if we haven't created the list yet, do it now if (m_noAutoRename == null) { m_noAutoRename = new List<string>(); } // don't add duplicates if (!m_noAutoRename.Contains(ident)) { m_noAutoRename.Add(ident); } } // this is a JS-only switch JavaScriptOnly(); break; case "OUT": case "O": // <-- old style // next argument is the output path // cannot have two out arguments if (!string.IsNullOrEmpty(m_outputFile)) { throw new UsageException(m_outputMode, "MultipleOutputArg"); } else if (ndx >= args.Length - 1) { throw new UsageException(m_outputMode, "OutputArgNeedsPath"); } m_outputFile = args[++ndx]; break; case "PPONLY": // just putting the pponly switch on the command line without any arguments // is the same as putting -pponly:true and perfectly valid. BooleanSwitch(paramPart, switchPart, true, out m_preprocessOnly); // this is a JS-only switch JavaScriptOnly(); break; case "PRETTY": case "P": // <-- old style m_prettyPrint = true; // pretty-print and echo-input not compatible if (m_echoInput) { throw new UsageException(m_outputMode, "PrettyAndEchoArgs"); } // if renaming hasn't been specified yet, turn it off for prety-print if (!renamingSpecified) { m_localRenaming = LocalRenaming.KeepAll; } // optional integer switch argument if (paramPart != null) { // get the numeric portion try { // must be an integer value int indentSize = int.Parse(paramPart, CultureInfo.InvariantCulture); if (indentSize >= 0) { m_indentSize = indentSize; } else { throw new UsageException(m_outputMode, "InvalidTabSizeArg", paramPart); } } catch (FormatException e) { Debug.WriteLine(e.ToString()); throw new UsageException(m_outputMode, "InvalidTabSizeArg", paramPart); } } break; case "RENAME": if (paramPart == null) { // there are no other parts after -rename // the next argument should be a filename from which we can pull the // variable renaming information if (ndx >= args.Length - 1) { // must be followed by an encoding throw new UsageException(m_outputMode, "RenameArgMissingParameterOrFilePath", switchPart); } // the renaming file is specified as the NEXT argument string renameFilePath = args[++ndx]; // and it needs to exist EnsureInputFileExists(renameFilePath); // process the renaming file ProcessRenamingFile(renameFilePath); } else if (paramPart.IndexOf('=') > 0) { // there is at least one equal sign -- treat this as a set of JS identifier // pairs. split on commas -- multiple pairs can be specified var paramPairs = parts[1].Split(','); foreach (var paramPair in paramPairs) { // split on the equal sign -- each pair needs to have an equal sige var pairParts = paramPair.Split('='); if (pairParts.Length == 2) { // there is an equal sign. The first part is the source name and the // second part is the new name to which to rename those entities. string fromIdentifier = pairParts[0]; string toIdentifier = pairParts[1]; // make sure both parts are valid JS identifiers var fromIsValid = JSScanner.IsValidIdentifier(fromIdentifier); var toIsValid = JSScanner.IsValidIdentifier(toIdentifier); if (fromIsValid && toIsValid) { // create the map if it hasn't been created yet. if (m_renameMap == null) { m_renameMap = new Dictionary<string, string>(); } m_renameMap.Add(fromIdentifier, toIdentifier); } else if (fromIsValid) { // the toIdentifier is invalid! throw new UsageException(m_outputMode, "InvalidRenameToIdentifier", toIdentifier); } else if (toIsValid) { // the fromIdentifier is invalid! throw new UsageException(m_outputMode, "InvalidRenameFromIdentifier", fromIdentifier); } else { // NEITHER of the rename parts are valid identifiers! BOTH are required to // be valid JS identifiers throw new UsageException(m_outputMode, "InvalidRenameIdentifiers", fromIdentifier, toIdentifier); } } else { // either zero or more than one equal sign. Invalid. throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } } } else { // no equal sign; just a plain option // three options: all, localization, none if (paramPart == "ALL") { m_localRenaming = LocalRenaming.CrunchAll; // automatic renaming strategy has been specified by this option renamingSpecified = true; } else if (paramPart == "LOCALIZATION") { m_localRenaming = LocalRenaming.KeepLocalizationVars; // automatic renaming strategy has been specified by this option renamingSpecified = true; } else if (paramPart == "NONE") { m_localRenaming = LocalRenaming.KeepAll; // automatic renaming strategy has been specified by this option renamingSpecified = true; } else if (paramPart == "NOPROPS") { // manual-renaming does not change property names m_renameProperties = false; } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } } // this is a JS-only switch JavaScriptOnly(); break; case "REORDER": // default is true BooleanSwitch(paramPart, switchPart, true, out m_reorderScopeDeclarations); // this is a JS-only switch JavaScriptOnly(); break; case "RES": case "R": // <-- old style // -res:id path // can't specify -R more than once if (!string.IsNullOrEmpty(m_resourceFile)) { throw new UsageException(m_outputMode, "MultipleResourceArgs"); } // must have resource file on next parameter if (ndx >= args.Length - 1) { throw new UsageException(m_outputMode, "ResourceArgNeedsPath"); } // the resource file name is the NEXT argument m_resourceFile = args[++ndx]; EnsureInputFileExists(m_resourceFile); // check the extension to see if the resource file is a supported file type. switch (Path.GetExtension(m_resourceFile).ToUpper(CultureInfo.InvariantCulture)) { case ".RESOURCES": case ".RESX": if (!string.IsNullOrEmpty(paramPart)) { // reset paramPart to not be the forced-to-upper version paramPart = parts[1]; // must be valid JS identifier if (JSScanner.IsValidIdentifier(paramPart)) { // save the name portion m_resourceObjectName = paramPart; } else { throw new UsageException(m_outputMode, "ResourceArgInvalidName", paramPart); } } else { // no name specified -- use Strings as the default // (not recommended) m_resourceObjectName = c_defaultResourceObjectName; } break; default: // not a supported resource file type throw new UsageException(m_outputMode, "ResourceArgInvalidType"); } break; case "SILENT": case "S": // <-- old style // ignore any argument part m_outputMode = ConsoleOutputMode.Silent; break; case "TERM": // optional boolean argument, defaults to true BooleanSwitch(paramPart, switchPart, true, out m_terminateWithSemicolon); break; case "UNUSED": // two options: keep and remove if (paramPart == "KEEP") { m_removeUnneededCode = false; } else if (paramPart == "REMOVE") { m_removeUnneededCode = true; } else if (paramPart == null) { throw new UsageException(m_outputMode, "SwitchRequiresArg", switchPart); } else { throw new UsageException(m_outputMode, "InvalidSwitchArg", paramPart, switchPart); } // this is a JS-only switch JavaScriptOnly(); break; case "WARN": case "W": // <-- old style if (string.IsNullOrEmpty(paramPart)) { // just "-warn" without anything else means all errors and warnings m_warningLevel = int.MaxValue; } else { try { // must be an unsigned integer value m_warningLevel = int.Parse(paramPart, NumberStyles.None, CultureInfo.InvariantCulture); } catch (FormatException e) { Debug.WriteLine(e.ToString()); throw new UsageException(m_outputMode, "InvalidWarningArg", paramPart); } } levelSpecified = true; break; case "XML": case "X": // <-- old style if (!string.IsNullOrEmpty(m_xmlInputFile)) { throw new UsageException(m_outputMode, "MultipleXmlArgs"); } // cannot have input files if (inputFiles.Count > 0) { throw new UsageException(m_outputMode, "XmlArgHasInputFiles"); } if (ndx >= args.Length - 1) { throw new UsageException(m_outputMode, "XmlArgNeedsPath"); } // the xml file name is the NEXT argument m_xmlInputFile = args[++ndx]; // and it must exist EnsureInputFileExists(m_xmlInputFile); break; // Backward-compatibility switches different from new switches case "D": // equivalent to -debug:true (default behavior) m_stripDebugStatements = true; JavaScriptOnly(); break; case "E": case "EO": // equivalent to -enc:out <encoding> if(parts.Length < 2) { // must be followed by an encoding throw new UsageException(m_outputMode, "EncodingArgMustHaveEncoding", switchPart); } // just save the name -- we'll create the encoding later because we need // to know whether we are JS or CSS to pick the right encoding fallback m_encodingOutputName = parts[1]; break; case "EI": // equivalent to -enc:in <encoding> if (parts.Length < 2) { // must be followed by an encoding throw new UsageException(m_outputMode, "EncodingArgMustHaveEncoding", switchPart); } // save the name m_encodingInputName = parts[1]; break; case "H": // equivalent to -rename:all -unused:remove (default behavior) m_localRenaming = LocalRenaming.CrunchAll; m_removeUnneededCode = true; JavaScriptOnly(); // renaming is specified by this option renamingSpecified = true; break; case "HL": // equivalent to -rename:localization -unused:remove m_localRenaming = LocalRenaming.KeepLocalizationVars; m_removeUnneededCode = true; JavaScriptOnly(); // renaming is specified by this option renamingSpecified = true; break; case "HC": // equivalent to -literals:combine -rename:all -unused:remove m_combineDuplicateLiterals = true; goto case "H"; case "HLC": case "HCL": // equivalent to -literals:combine -rename:localization -unused:remove m_combineDuplicateLiterals = true; goto case "HL"; case "J": // equivalent to -evals:ignore (default behavior) m_evalTreatment = EvalTreatment.Ignore; JavaScriptOnly(); break; case "K": // equivalent to -inline:true (default behavior) m_safeForInline = true; JavaScriptOnly(); break; case "L": // equivalent to -new:keep (default is collapse) m_collapseToLiteral = false; JavaScriptOnly(); break; case "M": // equivalent to -mac:true (default behavior) m_macSafariQuirks = true; JavaScriptOnly(); break; case "Z": // equivalent to -term:true (default is false) m_terminateWithSemicolon = true; break; case "CL": case "CS": case "V": case "3": // ignore -- we don't use these switches anymore. // but for backwards-compatibility, don't throw an error. break; // end backward-compatible section default: throw new UsageException(m_outputMode, "InvalidArgument", args[ndx]); } } else // must be an input file! { // cannot coexist with XML option if (!string.IsNullOrEmpty(m_xmlInputFile)) { throw new UsageException(m_outputMode, "XmlArgHasInputFiles"); } // shortcut string fileName = args[ndx]; // make sure it exists EnsureInputFileExists(fileName); // we don't want duplicates if (!inputFiles.Contains(fileName)) { inputFiles.Add(fileName); } } } // if we didn't specify the type (JS or CSS), then look at the extension of // the input files and see if we can divine what we are foreach (string path in inputFiles) { string extension = Path.GetExtension(path).ToUpperInvariant(); switch (m_inputType) { case InputType.Unknown: // we don't know yet. If the extension is JS or CSS set to the // appropriate input type if (extension == ".JS") { m_inputType = InputType.JavaScript; } else if (extension == ".CSS") { m_inputType = InputType.Css; } break; case InputType.JavaScript: // we know we are JS -- if we find a CSS file, throw an error if (extension == ".CSS") { throw new UsageException(m_outputMode, "ConflictingInputType"); } break; case InputType.Css: // we know we are CSS -- if we find a JS file, throw an error if (extension == ".JS") { throw new UsageException(m_outputMode, "ConflictingInputType"); } break; } } // if we have input files but we don't know the type by now, // then throw an exception if (inputFiles.Count > 0 && m_inputType == InputType.Unknown) { throw new UsageException(m_outputMode, "UnknownInputType"); } m_inputFiles = inputFiles.ToArray(); // if analyze was specified but no warning level, jack up the warning level // so everything is shown if (m_analyze && !levelSpecified) { // we want to analyze, and we didn't specify a particular warning level. // go ahead and report all errors m_warningLevel = int.MaxValue; } }
[DllImport("Kernel32.dll")] private static extern bool SetConsoleMode(IntPtr hConsoleOutput, ConsoleOutputMode mode);