Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
| Comment: | Remove unnecessary nesting of 'if' blocks in the command line argument processing. Add comments and fixup some whitespace. |
|---|---|
| Downloads: | Tarball | ZIP archive | SQL archive |
| Timelines: | family | ancestors | descendants | both | trunk |
| Files: | files | file ages | folders |
| SHA1: |
f909e1b7b15407de6a7ad30a9c3657cc |
| User & Date: | mistachkin 2012-01-04 07:15:51 |
Context
|
2012-01-05
| ||
| 06:37 | Merge the VS installer integration fixes and changes to the trunk. check-in: 2db8c0b5a5 user: mistachkin tags: trunk | |
|
2012-01-04
| ||
| 09:41 | Add the VS designer components and the rewritten installer for them to the setup package. check-in: bcdca9ada5 user: mistachkin tags: VsSetupIntegration | |
| 07:15 | Remove unnecessary nesting of 'if' blocks in the command line argument processing. Add comments and fixup some whitespace. check-in: f909e1b7b1 user: mistachkin tags: trunk | |
| 05:55 | Fix an incorrect comment. check-in: 8887a9f786 user: mistachkin tags: trunk | |
Changes
Changes to tools/install/Installer.cs.
95 95 Lowest = 0x1, 96 96 Lower = 0x2, 97 97 Low = 0x4, 98 98 Medium = 0x8, 99 99 High = 0x10, 100 100 Higher = 0x20, 101 101 Highest = 0x40, 102 - Debug = Medium, 103 - Trace = Medium 102 + Debug = Medium, /* NOTE: Default for debug messages. */ 103 + Trace = Medium /* NOTE: Default for trace messages. */ 104 104 } 105 105 #endregion 106 106 107 107 /////////////////////////////////////////////////////////////////////////// 108 108 109 109 #region Installer Class 110 110 internal static class Installer ................................................................................ 386 386 public static void DebugCore( 387 387 string message, 388 388 string category 389 389 ) 390 390 { 391 391 lock (syncRoot) 392 392 { 393 +#if DEBUG 394 + // 395 + // NOTE: Write the message to all the active debug 396 + // listeners. 397 + // 398 + Debug.WriteLine(message, category); 399 + Debug.Flush(); 400 +#else 393 401 // 394 402 // NOTE: For a build without "DEBUG" defined, we cannot 395 403 // simply use the Debug class (i.e. it will do 396 404 // nothing); therefore, use the console directly 397 405 // instead. 398 406 // 399 -#if DEBUG 400 - Debug.WriteLine(message, category); 401 - Debug.Flush(); 402 -#else 403 407 Console.WriteLine(String.Format("{1}: {0}", message, 404 408 category)); 405 409 #endif 406 410 } 407 411 } 408 412 409 413 /////////////////////////////////////////////////////////////////// ................................................................................ 411 415 public static void TraceCore( 412 416 string message, 413 417 string category 414 418 ) 415 419 { 416 420 lock (syncRoot) 417 421 { 422 + // 423 + // NOTE: Write the message to all the active trace 424 + // listeners. 425 + // 418 426 Trace.WriteLine(message, category); 419 427 Trace.Flush(); 420 428 } 421 429 } 422 430 423 431 /////////////////////////////////////////////////////////////////// 424 432 ................................................................................ 490 498 // 491 499 // NOTE: If not specified, use the default debug callback. 492 500 // 493 501 if (debugCallback == null) 494 502 debugCallback = DebugCore; 495 503 496 504 // 497 - // NOTE: Write the formatted message to all the active 498 - // debug listeners. 505 + // NOTE: Invoke the debug callback with the formatted 506 + // message and the category specified by the 507 + // caller. 499 508 // 500 509 debugCallback(formatted, category); 501 510 } 502 511 503 512 // 504 513 // NOTE: If the trace priority of this message is less than 505 514 // what we currently want to trace, skip it. ................................................................................ 509 518 // 510 519 // NOTE: If not specified, use the default trace callback. 511 520 // 512 521 if (traceCallback == null) 513 522 traceCallback = TraceCore; 514 523 515 524 // 516 - // NOTE: Write the formatted message to all the active 517 - // trace listeners. 525 + // NOTE: Invoke the trace callback with the formatted 526 + // message and the category specified by the 527 + // caller. 518 528 // 519 529 traceCallback(formatted, category); 520 530 } 521 531 522 532 return message; 523 533 } 524 534 #endregion ................................................................................ 942 952 #region IDisposable "Pattern" Members 943 953 private bool disposed; 944 954 private void CheckDisposed() /* throw */ 945 955 { 946 956 if (!disposed) 947 957 return; 948 958 949 - throw new ObjectDisposedException(typeof(MockRegistryKey).Name); 959 + throw new ObjectDisposedException( 960 + typeof(MockRegistryKey).Name); 950 961 } 951 962 952 963 /////////////////////////////////////////////////////////////////// 953 964 954 965 private /* protected virtual */ void Dispose( 955 966 bool disposing 956 967 ) ................................................................................ 1088 1099 bool verbose 1089 1100 ) 1090 1101 { 1091 1102 if (rootKey == null) 1092 1103 return null; 1093 1104 1094 1105 if (verbose) 1095 - TraceOps.DebugAndTrace( 1096 - writable ? TracePriority.Highest : TracePriority.Higher, 1106 + TraceOps.DebugAndTrace(writable ? 1107 + TracePriority.Highest : TracePriority.Higher, 1097 1108 debugCallback, traceCallback, String.Format( 1098 1109 "rootKey = {0}, subKeyName = {1}, writable = {2}", 1099 1110 ForDisplay(rootKey), ForDisplay(subKeyName), 1100 1111 ForDisplay(writable)), traceCategory); 1101 1112 1102 1113 // 1103 1114 // HACK: Always forbid writable access when operating in ................................................................................ 1121 1132 { 1122 1133 if (rootKey == null) 1123 1134 return null; 1124 1135 1125 1136 if (verbose) 1126 1137 TraceOps.DebugAndTrace(TracePriority.Highest, 1127 1138 debugCallback, traceCallback, String.Format( 1128 - "rootKey = {0}, subKeyName = {1}", ForDisplay(rootKey), 1129 - ForDisplay(subKeyName)), traceCategory); 1139 + "rootKey = {0}, subKeyName = {1}", 1140 + ForDisplay(rootKey), ForDisplay(subKeyName)), 1141 + traceCategory); 1130 1142 1131 1143 try 1132 1144 { 1133 1145 // 1134 1146 // HACK: Always open a key, rather than creating one when 1135 1147 // operating in 'what-if' mode. 1136 1148 // 1137 1149 if (whatIf) 1138 1150 { 1139 1151 // 1140 1152 // HACK: Attempt to open the specified sub-key. If 1141 - // this fails, we will simply return the root key 1142 - // itself since no writes are allowed in 1153 + // this fails, we will simply return the root 1154 + // key itself since no writes are allowed in 1143 1155 // 'what-if' mode anyhow. 1144 1156 // 1145 1157 MockRegistryKey key = rootKey.OpenSubKey(subKeyName); 1146 1158 1147 1159 return (key != null) ? 1148 1160 key : new MockRegistryKey( 1149 1161 rootKey, subKeyName, true, false, false); ................................................................................ 1172 1184 { 1173 1185 if (rootKey == null) 1174 1186 return; 1175 1187 1176 1188 if (verbose) 1177 1189 TraceOps.DebugAndTrace(TracePriority.Highest, 1178 1190 debugCallback, traceCallback, String.Format( 1179 - "rootKey = {0}, subKeyName = {1}", ForDisplay(rootKey), 1180 - ForDisplay(subKeyName)), traceCategory); 1191 + "rootKey = {0}, subKeyName = {1}", 1192 + ForDisplay(rootKey), ForDisplay(subKeyName)), 1193 + traceCategory); 1181 1194 1182 1195 if (!whatIf) 1183 1196 rootKey.DeleteSubKey(subKeyName); 1184 1197 1185 1198 subKeysDeleted++; 1186 1199 } 1187 1200 ................................................................................ 1196 1209 { 1197 1210 if (rootKey == null) 1198 1211 return; 1199 1212 1200 1213 if (verbose) 1201 1214 TraceOps.DebugAndTrace(TracePriority.Highest, 1202 1215 debugCallback, traceCallback, String.Format( 1203 - "rootKey = {0}, subKeyName = {1}", ForDisplay(rootKey), 1204 - ForDisplay(subKeyName)), traceCategory); 1216 + "rootKey = {0}, subKeyName = {1}", 1217 + ForDisplay(rootKey), ForDisplay(subKeyName)), 1218 + traceCategory); 1205 1219 1206 1220 if (!whatIf) 1207 1221 rootKey.DeleteSubKeyTree(subKeyName); 1208 1222 1209 1223 subKeysDeleted++; 1210 1224 } 1211 1225 ................................................................................ 1263 1277 { 1264 1278 if (key == null) 1265 1279 return; 1266 1280 1267 1281 if (verbose) 1268 1282 TraceOps.DebugAndTrace(TracePriority.Highest, 1269 1283 debugCallback, traceCallback, String.Format( 1270 - "key = {0}, name = {1}, value = {2}", ForDisplay(key), 1271 - ForDisplay(name), ForDisplay(value)), traceCategory); 1284 + "key = {0}, name = {1}, value = {2}", 1285 + ForDisplay(key), ForDisplay(name), ForDisplay(value)), 1286 + traceCategory); 1272 1287 1273 1288 if (!whatIf) 1274 1289 key.SetValue(name, value); 1275 1290 1276 1291 keyValuesSet++; 1277 1292 } 1278 1293 ................................................................................ 1686 1701 1687 1702 int length = args.Length; 1688 1703 1689 1704 for (int index = 0; index < length; index++) 1690 1705 { 1691 1706 string arg = args[index]; 1692 1707 1708 + // 1709 + // NOTE: Skip any argument that is null (?) or an empty 1710 + // string. 1711 + // 1693 1712 if (String.IsNullOrEmpty(arg)) 1694 1713 continue; 1695 1714 1715 + // 1716 + // NOTE: We are going to modify the original argument 1717 + // by removing any leading option characters; 1718 + // therefore, we use a new string to hold the 1719 + // modified argument. 1720 + // 1696 1721 string newArg = arg; 1697 1722 1698 - if (CheckOption(ref newArg)) 1723 + // 1724 + // NOTE: All the supported command line options must 1725 + // begin with an option character (e.g. a minus 1726 + // or forward slash); attempt to validate that 1727 + // now. If we fail in strict mode, we are done; 1728 + // otherwise, just skip this argument and advance 1729 + // to the next one. 1730 + // 1731 + if (!CheckOption(ref newArg)) 1699 1732 { 1733 + error = TraceOps.DebugAndTrace( 1734 + TracePriority.Lowest, debugCallback, 1735 + traceCallback, String.Format( 1736 + "Unsupported command line argument: {0}", 1737 + ForDisplay(arg)), traceCategory); 1738 + 1739 + if (strict) 1740 + return false; 1741 + 1742 + continue; 1743 + } 1744 + 1745 + // 1746 + // NOTE: All the supported command line options must 1747 + // have a value; therefore, attempt to advance 1748 + // to it now. If we fail, we are done. 1749 + // 1750 + index++; 1751 + 1752 + if (index >= length) 1753 + { 1754 + error = TraceOps.DebugAndTrace( 1755 + TracePriority.Lowest, debugCallback, 1756 + traceCallback, String.Format( 1757 + "Missing value for option: {0}", 1758 + ForDisplay(arg)), traceCategory); 1759 + 1760 + if (strict) 1761 + return false; 1762 + 1763 + break; 1764 + } 1765 + 1766 + // 1767 + // NOTE: Grab the textual value of this command line 1768 + // option. 1769 + // 1770 + string text = args[index]; 1771 + 1772 + // 1773 + // NOTE: Figure out which command line option this is 1774 + // (based on a partial name match) and then try 1775 + // to interpret the textual value as the correct 1776 + // type. 1777 + // 1778 + if (MatchOption(newArg, "strict")) 1779 + { 1780 + bool? value = ParseBoolean(text); 1781 + 1782 + if (value == null) 1783 + { 1784 + error = TraceOps.DebugAndTrace( 1785 + TracePriority.Lowest, debugCallback, 1786 + traceCallback, String.Format( 1787 + "Invalid {0} boolean value: {1}", 1788 + ForDisplay(arg), ForDisplay(text)), 1789 + traceCategory); 1790 + 1791 + if (strict) 1792 + return false; 1793 + 1794 + continue; 1795 + } 1796 + 1797 + // 1798 + // NOTE: Allow the command line arguments to 1799 + // override the "strictness" setting 1800 + // provided by our caller. 1801 + // 1802 + strict = (bool)value; 1803 + } 1804 + else if (MatchOption(newArg, "logFileName")) 1805 + { 1806 + configuration.logFileName = text; 1807 + } 1808 + else if (MatchOption(newArg, "directory")) 1809 + { 1810 + configuration.directory = text; 1811 + 1700 1812 // 1701 - // NOTE: All the supported command line options must 1702 - // have a value; therefore, attempt to advance 1703 - // to it now. If we fail, we are done. 1813 + // NOTE: *SPECIAL* Must refresh the file names 1814 + // here because the underlying directory 1815 + // has changed. 1704 1816 // 1705 - index++; 1706 - 1707 - if (index >= length) 1817 + string coreFileName = configuration.coreFileName; 1818 + 1819 + if (!String.IsNullOrEmpty(coreFileName)) 1820 + coreFileName = Path.GetFileName(coreFileName); 1821 + 1822 + if (String.IsNullOrEmpty(coreFileName)) 1823 + coreFileName = Installer.CoreFileName; 1824 + 1825 + configuration.coreFileName = Path.Combine( 1826 + configuration.directory, coreFileName); 1827 + 1828 + string linqFileName = configuration.linqFileName; 1829 + 1830 + if (!String.IsNullOrEmpty(linqFileName)) 1831 + linqFileName = Path.GetFileName(linqFileName); 1832 + 1833 + if (String.IsNullOrEmpty(linqFileName)) 1834 + linqFileName = Installer.LinqFileName; 1835 + 1836 + configuration.linqFileName = Path.Combine( 1837 + configuration.directory, linqFileName); 1838 + 1839 + string designerFileName = configuration.designerFileName; 1840 + 1841 + if (!String.IsNullOrEmpty(designerFileName)) 1842 + designerFileName = Path.GetFileName(designerFileName); 1843 + 1844 + if (String.IsNullOrEmpty(designerFileName)) 1845 + designerFileName = Installer.DesignerFileName; 1846 + 1847 + configuration.designerFileName = Path.Combine( 1848 + configuration.directory, designerFileName); 1849 + } 1850 + else if (MatchOption(newArg, "coreFileName")) 1851 + { 1852 + configuration.coreFileName = text; 1853 + } 1854 + else if (MatchOption(newArg, "linqFileName")) 1855 + { 1856 + configuration.linqFileName = text; 1857 + } 1858 + else if (MatchOption(newArg, "designerFileName")) 1859 + { 1860 + configuration.designerFileName = text; 1861 + } 1862 + else if (MatchOption(newArg, "debugFormat")) 1863 + { 1864 + configuration.debugFormat = text; 1865 + TraceOps.DebugFormat = configuration.debugFormat; 1866 + } 1867 + else if (MatchOption(newArg, "traceFormat")) 1868 + { 1869 + configuration.traceFormat = text; 1870 + TraceOps.TraceFormat = configuration.traceFormat; 1871 + } 1872 + else if (MatchOption(newArg, "debugPriority")) 1873 + { 1874 + object value = ParseEnum( 1875 + typeof(TracePriority), text, true); 1876 + 1877 + if (value == null) 1878 + { 1879 + error = TraceOps.DebugAndTrace( 1880 + TracePriority.Lowest, debugCallback, 1881 + traceCallback, String.Format( 1882 + "Invalid {0} value: {1}", 1883 + ForDisplay(arg), ForDisplay(text)), 1884 + traceCategory); 1885 + 1886 + if (strict) 1887 + return false; 1888 + 1889 + continue; 1890 + } 1891 + 1892 + configuration.debugPriority = (TracePriority)value; 1893 + TraceOps.DebugPriority = configuration.debugPriority; 1894 + } 1895 + else if (MatchOption(newArg, "tracePriority")) 1896 + { 1897 + object value = ParseEnum( 1898 + typeof(TracePriority), text, true); 1899 + 1900 + if (value == null) 1901 + { 1902 + error = TraceOps.DebugAndTrace( 1903 + TracePriority.Lowest, debugCallback, 1904 + traceCallback, String.Format( 1905 + "Invalid {0} value: {1}", 1906 + ForDisplay(arg), ForDisplay(text)), 1907 + traceCategory); 1908 + 1909 + if (strict) 1910 + return false; 1911 + 1912 + continue; 1913 + } 1914 + 1915 + configuration.tracePriority = (TracePriority)value; 1916 + TraceOps.TracePriority = configuration.tracePriority; 1917 + } 1918 + else if (MatchOption(newArg, "install")) 1919 + { 1920 + bool? value = ParseBoolean(text); 1921 + 1922 + if (value == null) 1923 + { 1924 + error = TraceOps.DebugAndTrace( 1925 + TracePriority.Lowest, debugCallback, 1926 + traceCallback, String.Format( 1927 + "Invalid {0} boolean value: {1}", 1928 + ForDisplay(arg), ForDisplay(text)), 1929 + traceCategory); 1930 + 1931 + if (strict) 1932 + return false; 1933 + 1934 + continue; 1935 + } 1936 + 1937 + configuration.install = (bool)value; 1938 + } 1939 + else if (MatchOption(newArg, "installFlags")) 1940 + { 1941 + object value = ParseEnum( 1942 + typeof(InstallFlags), text, true); 1943 + 1944 + if (value == null) 1945 + { 1946 + error = TraceOps.DebugAndTrace( 1947 + TracePriority.Lowest, debugCallback, 1948 + traceCallback, String.Format( 1949 + "Invalid install flags value: {0}", 1950 + ForDisplay(text)), traceCategory); 1951 + 1952 + if (strict) 1953 + return false; 1954 + 1955 + continue; 1956 + } 1957 + 1958 + configuration.installFlags = (InstallFlags)value; 1959 + } 1960 + else if (MatchOption(newArg, "noRuntimeVersion")) 1961 + { 1962 + bool? value = ParseBoolean(text); 1963 + 1964 + if (value == null) 1965 + { 1966 + error = TraceOps.DebugAndTrace( 1967 + TracePriority.Lowest, debugCallback, 1968 + traceCallback, String.Format( 1969 + "Invalid {0} boolean value: {1}", 1970 + ForDisplay(arg), ForDisplay(text)), 1971 + traceCategory); 1972 + 1973 + if (strict) 1974 + return false; 1975 + 1976 + continue; 1977 + } 1978 + 1979 + configuration.noRuntimeVersion = (bool)value; 1980 + } 1981 + else if (MatchOption(newArg, "whatIf")) 1982 + { 1983 + bool? value = ParseBoolean(text); 1984 + 1985 + if (value == null) 1986 + { 1987 + error = TraceOps.DebugAndTrace( 1988 + TracePriority.Lowest, debugCallback, 1989 + traceCallback, String.Format( 1990 + "Invalid {0} boolean value: {1}", 1991 + ForDisplay(arg), ForDisplay(text)), 1992 + traceCategory); 1993 + 1994 + if (strict) 1995 + return false; 1996 + 1997 + continue; 1998 + } 1999 + 2000 + configuration.whatIf = (bool)value; 2001 + } 2002 + else if (MatchOption(newArg, "verbose")) 2003 + { 2004 + bool? value = ParseBoolean(text); 2005 + 2006 + if (value == null) 2007 + { 2008 + error = TraceOps.DebugAndTrace( 2009 + TracePriority.Lowest, debugCallback, 2010 + traceCallback, String.Format( 2011 + "Invalid {0} boolean value: {1}", 2012 + ForDisplay(arg), ForDisplay(text)), 2013 + traceCategory); 2014 + 2015 + if (strict) 2016 + return false; 2017 + 2018 + continue; 2019 + } 2020 + 2021 + configuration.verbose = (bool)value; 2022 + } 2023 + else if (MatchOption(newArg, "confirm")) 2024 + { 2025 + bool? value = ParseBoolean(text); 2026 + 2027 + if (value == null) 2028 + { 2029 + error = TraceOps.DebugAndTrace( 2030 + TracePriority.Lowest, debugCallback, 2031 + traceCallback, String.Format( 2032 + "Invalid {0} boolean value: {1}", 2033 + ForDisplay(arg), ForDisplay(text)), 2034 + traceCategory); 2035 + 2036 + if (strict) 2037 + return false; 2038 + 2039 + continue; 2040 + } 2041 + 2042 + configuration.confirm = (bool)value; 2043 + } 2044 + else if (MatchOption(newArg, "noDesktop")) 2045 + { 2046 + bool? value = ParseBoolean(text); 2047 + 2048 + if (value == null) 2049 + { 2050 + error = TraceOps.DebugAndTrace( 2051 + TracePriority.Lowest, debugCallback, 2052 + traceCallback, String.Format( 2053 + "Invalid {0} boolean value: {1}", 2054 + ForDisplay(arg), ForDisplay(text)), 2055 + traceCategory); 2056 + 2057 + if (strict) 2058 + return false; 2059 + 2060 + continue; 2061 + } 2062 + 2063 + configuration.noDesktop = (bool)value; 2064 + } 2065 + else if (MatchOption(newArg, "noCompact")) 2066 + { 2067 + bool? value = ParseBoolean(text); 2068 + 2069 + if (value == null) 2070 + { 2071 + error = TraceOps.DebugAndTrace( 2072 + TracePriority.Lowest, debugCallback, 2073 + traceCallback, String.Format( 2074 + "Invalid {0} boolean value: {1}", 2075 + ForDisplay(arg), ForDisplay(text)), 2076 + traceCategory); 2077 + 2078 + if (strict) 2079 + return false; 2080 + 2081 + continue; 2082 + } 2083 + 2084 + configuration.noCompact = (bool)value; 2085 + } 2086 + else if (MatchOption(newArg, "noNetFx20")) 2087 + { 2088 + bool? value = ParseBoolean(text); 2089 + 2090 + if (value == null) 2091 + { 2092 + error = TraceOps.DebugAndTrace( 2093 + TracePriority.Lowest, debugCallback, 2094 + traceCallback, String.Format( 2095 + "Invalid {0} boolean value: {1}", 2096 + ForDisplay(arg), ForDisplay(text)), 2097 + traceCategory); 2098 + 2099 + if (strict) 2100 + return false; 2101 + 2102 + continue; 2103 + } 2104 + 2105 + configuration.noNetFx20 = (bool)value; 2106 + } 2107 + else if (MatchOption(newArg, "noNetFx40")) 2108 + { 2109 + bool? value = ParseBoolean(text); 2110 + 2111 + if (value == null) 2112 + { 2113 + error = TraceOps.DebugAndTrace( 2114 + TracePriority.Lowest, debugCallback, 2115 + traceCallback, String.Format( 2116 + "Invalid {0} boolean value: {1}", 2117 + ForDisplay(arg), ForDisplay(text)), 2118 + traceCategory); 2119 + 2120 + if (strict) 2121 + return false; 2122 + 2123 + continue; 2124 + } 2125 + 2126 + configuration.noNetFx40 = (bool)value; 2127 + } 2128 + else if (MatchOption(newArg, "noVs2008")) 2129 + { 2130 + bool? value = ParseBoolean(text); 2131 + 2132 + if (value == null) 2133 + { 2134 + error = TraceOps.DebugAndTrace( 2135 + TracePriority.Lowest, debugCallback, 2136 + traceCallback, String.Format( 2137 + "Invalid {0} boolean value: {1}", 2138 + ForDisplay(arg), ForDisplay(text)), 2139 + traceCategory); 2140 + 2141 + if (strict) 2142 + return false; 2143 + 2144 + continue; 2145 + } 2146 + 2147 + configuration.noVs2008 = (bool)value; 2148 + } 2149 + else if (MatchOption(newArg, "noVs2010")) 2150 + { 2151 + bool? value = ParseBoolean(text); 2152 + 2153 + if (value == null) 2154 + { 2155 + error = TraceOps.DebugAndTrace( 2156 + TracePriority.Lowest, debugCallback, 2157 + traceCallback, String.Format( 2158 + "Invalid {0} boolean value: {1}", 2159 + ForDisplay(arg), ForDisplay(text)), 2160 + traceCategory); 2161 + 2162 + if (strict) 2163 + return false; 2164 + 2165 + continue; 2166 + } 2167 + 2168 + configuration.noVs2010 = (bool)value; 2169 + } 2170 + else if (MatchOption(newArg, "noTrace")) 2171 + { 2172 + bool? value = ParseBoolean(text); 2173 + 2174 + if (value == null) 2175 + { 2176 + error = TraceOps.DebugAndTrace( 2177 + TracePriority.Lowest, debugCallback, 2178 + traceCallback, String.Format( 2179 + "Invalid {0} boolean value: {1}", 2180 + ForDisplay(arg), ForDisplay(text)), 2181 + traceCategory); 2182 + 2183 + if (strict) 2184 + return false; 2185 + 2186 + continue; 2187 + } 2188 + 2189 + configuration.noTrace = (bool)value; 2190 + } 2191 + else if (MatchOption(newArg, "noConsole")) 2192 + { 2193 + bool? value = ParseBoolean(text); 2194 + 2195 + if (value == null) 1708 2196 { 1709 2197 error = TraceOps.DebugAndTrace( 1710 2198 TracePriority.Lowest, debugCallback, 1711 2199 traceCallback, String.Format( 1712 - "Missing value for option: {0}", 1713 - ForDisplay(arg)), traceCategory); 2200 + "Invalid {0} boolean value: {1}", 2201 + ForDisplay(arg), ForDisplay(text)), 2202 + traceCategory); 1714 2203 1715 2204 if (strict) 1716 2205 return false; 1717 2206 1718 - break; 2207 + continue; 1719 2208 } 1720 2209 1721 - // 1722 - // NOTE: Grab the textual value of this command line 1723 - // option. 1724 - // 1725 - string text = args[index]; 1726 - 1727 - // 1728 - // NOTE: Figure out which command line option this is 1729 - // (based on a partial name match) and then try 1730 - // to interpret the textual value as the correct 1731 - // type. 1732 - // 1733 - if (MatchOption(newArg, "strict")) 1734 - { 1735 - bool? value = ParseBoolean(text); 1736 - 1737 - if (value == null) 1738 - { 1739 - error = TraceOps.DebugAndTrace( 1740 - TracePriority.Lowest, debugCallback, 1741 - traceCallback, String.Format( 1742 - "Invalid {0} boolean value: {1}", 1743 - ForDisplay(arg), ForDisplay(text)), 1744 - traceCategory); 1745 - 1746 - if (strict) 1747 - return false; 1748 - 1749 - continue; 1750 - } 1751 - 1752 - // 1753 - // NOTE: Allow the command line arguments to override 1754 - // the "strictness" setting provided by our caller. 1755 - // 1756 - strict = (bool)value; 1757 - } 1758 - else if (MatchOption(newArg, "logFileName")) 1759 - { 1760 - configuration.logFileName = text; 1761 - } 1762 - else if (MatchOption(newArg, "directory")) 1763 - { 1764 - configuration.directory = text; 1765 - 1766 - // 1767 - // NOTE: *SPECIAL* Must refresh the file names 1768 - // here because the underlying directory 1769 - // has changed. 1770 - // 1771 - string coreFileName = configuration.coreFileName; 1772 - 1773 - if (!String.IsNullOrEmpty(coreFileName)) 1774 - coreFileName = Path.GetFileName(coreFileName); 1775 - 1776 - if (String.IsNullOrEmpty(coreFileName)) 1777 - coreFileName = Installer.CoreFileName; 1778 - 1779 - configuration.coreFileName = Path.Combine( 1780 - configuration.directory, coreFileName); 1781 - 1782 - string linqFileName = configuration.linqFileName; 1783 - 1784 - if (!String.IsNullOrEmpty(linqFileName)) 1785 - linqFileName = Path.GetFileName(linqFileName); 1786 - 1787 - if (String.IsNullOrEmpty(linqFileName)) 1788 - linqFileName = Installer.LinqFileName; 1789 - 1790 - configuration.linqFileName = Path.Combine( 1791 - configuration.directory, linqFileName); 1792 - 1793 - string designerFileName = configuration.designerFileName; 1794 - 1795 - if (!String.IsNullOrEmpty(designerFileName)) 1796 - designerFileName = Path.GetFileName(designerFileName); 1797 - 1798 - if (String.IsNullOrEmpty(designerFileName)) 1799 - designerFileName = Installer.DesignerFileName; 1800 - 1801 - configuration.designerFileName = Path.Combine( 1802 - configuration.directory, designerFileName); 1803 - } 1804 - else if (MatchOption(newArg, "coreFileName")) 1805 - { 1806 - configuration.coreFileName = text; 1807 - } 1808 - else if (MatchOption(newArg, "linqFileName")) 1809 - { 1810 - configuration.linqFileName = text; 1811 - } 1812 - else if (MatchOption(newArg, "designerFileName")) 1813 - { 1814 - configuration.designerFileName = text; 1815 - } 1816 - else if (MatchOption(newArg, "debugFormat")) 1817 - { 1818 - configuration.debugFormat = text; 1819 - TraceOps.DebugFormat = configuration.debugFormat; 1820 - } 1821 - else if (MatchOption(newArg, "traceFormat")) 1822 - { 1823 - configuration.traceFormat = text; 1824 - TraceOps.TraceFormat = configuration.traceFormat; 1825 - } 1826 - else if (MatchOption(newArg, "debugPriority")) 1827 - { 1828 - object value = ParseEnum( 1829 - typeof(TracePriority), text, true); 1830 - 1831 - if (value == null) 1832 - { 1833 - error = TraceOps.DebugAndTrace( 1834 - TracePriority.Lowest, debugCallback, 1835 - traceCallback, String.Format( 1836 - "Invalid {0} value: {1}", 1837 - ForDisplay(arg), ForDisplay(text)), 1838 - traceCategory); 1839 - 1840 - if (strict) 1841 - return false; 1842 - 1843 - continue; 1844 - } 1845 - 1846 - configuration.debugPriority = (TracePriority)value; 1847 - TraceOps.DebugPriority = configuration.debugPriority; 1848 - } 1849 - else if (MatchOption(newArg, "tracePriority")) 1850 - { 1851 - object value = ParseEnum( 1852 - typeof(TracePriority), text, true); 1853 - 1854 - if (value == null) 1855 - { 1856 - error = TraceOps.DebugAndTrace( 1857 - TracePriority.Lowest, debugCallback, 1858 - traceCallback, String.Format( 1859 - "Invalid {0} value: {1}", 1860 - ForDisplay(arg), ForDisplay(text)), 1861 - traceCategory); 1862 - 1863 - if (strict) 1864 - return false; 1865 - 1866 - continue; 1867 - } 1868 - 1869 - configuration.tracePriority = (TracePriority)value; 1870 - TraceOps.TracePriority = configuration.tracePriority; 1871 - } 1872 - else if (MatchOption(newArg, "install")) 1873 - { 1874 - bool? value = ParseBoolean(text); 1875 - 1876 - if (value == null) 1877 - { 1878 - error = TraceOps.DebugAndTrace( 1879 - TracePriority.Lowest, debugCallback, 1880 - traceCallback, String.Format( 1881 - "Invalid {0} boolean value: {1}", 1882 - ForDisplay(arg), ForDisplay(text)), 1883 - traceCategory); 1884 - 1885 - if (strict) 1886 - return false; 1887 - 1888 - continue; 1889 - } 1890 - 1891 - configuration.install = (bool)value; 1892 - } 1893 - else if (MatchOption(newArg, "installFlags")) 1894 - { 1895 - object value = ParseEnum( 1896 - typeof(InstallFlags), text, true); 1897 - 1898 - if (value == null) 1899 - { 1900 - error = TraceOps.DebugAndTrace( 1901 - TracePriority.Lowest, debugCallback, 1902 - traceCallback, String.Format( 1903 - "Invalid install flags value: {0}", 1904 - ForDisplay(text)), traceCategory); 1905 - 1906 - if (strict) 1907 - return false; 1908 - 1909 - continue; 1910 - } 1911 - 1912 - configuration.installFlags = (InstallFlags)value; 1913 - } 1914 - else if (MatchOption(newArg, "noRuntimeVersion")) 1915 - { 1916 - bool? value = ParseBoolean(text); 1917 - 1918 - if (value == null) 1919 - { 1920 - error = TraceOps.DebugAndTrace( 1921 - TracePriority.Lowest, debugCallback, 1922 - traceCallback, String.Format( 1923 - "Invalid {0} boolean value: {1}", 1924 - ForDisplay(arg), ForDisplay(text)), 1925 - traceCategory); 1926 - 1927 - if (strict) 1928 - return false; 1929 - 1930 - continue; 1931 - } 1932 - 1933 - configuration.noRuntimeVersion = (bool)value; 1934 - } 1935 - else if (MatchOption(newArg, "whatIf")) 1936 - { 1937 - bool? value = ParseBoolean(text); 1938 - 1939 - if (value == null) 1940 - { 1941 - error = TraceOps.DebugAndTrace( 1942 - TracePriority.Lowest, debugCallback, 1943 - traceCallback, String.Format( 1944 - "Invalid {0} boolean value: {1}", 1945 - ForDisplay(arg), ForDisplay(text)), 1946 - traceCategory); 1947 - 1948 - if (strict) 1949 - return false; 1950 - 1951 - continue; 1952 - } 1953 - 1954 - configuration.whatIf = (bool)value; 1955 - } 1956 - else if (MatchOption(newArg, "verbose")) 1957 - { 1958 - bool? value = ParseBoolean(text); 1959 - 1960 - if (value == null) 1961 - { 1962 - error = TraceOps.DebugAndTrace( 1963 - TracePriority.Lowest, debugCallback, 1964 - traceCallback, String.Format( 1965 - "Invalid {0} boolean value: {1}", 1966 - ForDisplay(arg), ForDisplay(text)), 1967 - traceCategory); 1968 - 1969 - if (strict) 1970 - return false; 1971 - 1972 - continue; 1973 - } 1974 - 1975 - configuration.verbose = (bool)value; 1976 - } 1977 - else if (MatchOption(newArg, "confirm")) 1978 - { 1979 - bool? value = ParseBoolean(text); 1980 - 1981 - if (value == null) 1982 - { 1983 - error = TraceOps.DebugAndTrace( 1984 - TracePriority.Lowest, debugCallback, 1985 - traceCallback, String.Format( 1986 - "Invalid {0} boolean value: {1}", 1987 - ForDisplay(arg), ForDisplay(text)), 1988 - traceCategory); 1989 - 1990 - if (strict) 1991 - return false; 1992 - 1993 - continue; 1994 - } 1995 - 1996 - configuration.confirm = (bool)value; 1997 - } 1998 - else if (MatchOption(newArg, "noDesktop")) 1999 - { 2000 - bool? value = ParseBoolean(text); 2001 - 2002 - if (value == null) 2003 - { 2004 - error = TraceOps.DebugAndTrace( 2005 - TracePriority.Lowest, debugCallback, 2006 - traceCallback, String.Format( 2007 - "Invalid {0} boolean value: {1}", 2008 - ForDisplay(arg), ForDisplay(text)), 2009 - traceCategory); 2010 - 2011 - if (strict) 2012 - return false; 2013 - 2014 - continue; 2015 - } 2016 - 2017 - configuration.noDesktop = (bool)value; 2018 - } 2019 - else if (MatchOption(newArg, "noCompact")) 2020 - { 2021 - bool? value = ParseBoolean(text); 2022 - 2023 - if (value == null) 2024 - { 2025 - error = TraceOps.DebugAndTrace( 2026 - TracePriority.Lowest, debugCallback, 2027 - traceCallback, String.Format( 2028 - "Invalid {0} boolean value: {1}", 2029 - ForDisplay(arg), ForDisplay(text)), 2030 - traceCategory); 2031 - 2032 - if (strict) 2033 - return false; 2034 - 2035 - continue; 2036 - } 2037 - 2038 - configuration.noCompact = (bool)value; 2039 - } 2040 - else if (MatchOption(newArg, "noNetFx20")) 2041 - { 2042 - bool? value = ParseBoolean(text); 2043 - 2044 - if (value == null) 2045 - { 2046 - error = TraceOps.DebugAndTrace( 2047 - TracePriority.Lowest, debugCallback, 2048 - traceCallback, String.Format( 2049 - "Invalid {0} boolean value: {1}", 2050 - ForDisplay(arg), ForDisplay(text)), 2051 - traceCategory); 2052 - 2053 - if (strict) 2054 - return false; 2055 - 2056 - continue; 2057 - } 2058 - 2059 - configuration.noNetFx20 = (bool)value; 2060 - } 2061 - else if (MatchOption(newArg, "noNetFx40")) 2062 - { 2063 - bool? value = ParseBoolean(text); 2064 - 2065 - if (value == null) 2066 - { 2067 - error = TraceOps.DebugAndTrace( 2068 - TracePriority.Lowest, debugCallback, 2069 - traceCallback, String.Format( 2070 - "Invalid {0} boolean value: {1}", 2071 - ForDisplay(arg), ForDisplay(text)), 2072 - traceCategory); 2073 - 2074 - if (strict) 2075 - return false; 2076 - 2077 - continue; 2078 - } 2079 - 2080 - configuration.noNetFx40 = (bool)value; 2081 - } 2082 - else if (MatchOption(newArg, "noVs2008")) 2083 - { 2084 - bool? value = ParseBoolean(text); 2085 - 2086 - if (value == null) 2087 - { 2088 - error = TraceOps.DebugAndTrace( 2089 - TracePriority.Lowest, debugCallback, 2090 - traceCallback, String.Format( 2091 - "Invalid {0} boolean value: {1}", 2092 - ForDisplay(arg), ForDisplay(text)), 2093 - traceCategory); 2094 - 2095 - if (strict) 2096 - return false; 2097 - 2098 - continue; 2099 - } 2100 - 2101 - configuration.noVs2008 = (bool)value; 2102 - } 2103 - else if (MatchOption(newArg, "noVs2010")) 2104 - { 2105 - bool? value = ParseBoolean(text); 2106 - 2107 - if (value == null) 2108 - { 2109 - error = TraceOps.DebugAndTrace( 2110 - TracePriority.Lowest, debugCallback, 2111 - traceCallback, String.Format( 2112 - "Invalid {0} boolean value: {1}", 2113 - ForDisplay(arg), ForDisplay(text)), 2114 - traceCategory); 2115 - 2116 - if (strict) 2117 - return false; 2118 - 2119 - continue; 2120 - } 2121 - 2122 - configuration.noVs2010 = (bool)value; 2123 - } 2124 - else if (MatchOption(newArg, "noTrace")) 2125 - { 2126 - bool? value = ParseBoolean(text); 2127 - 2128 - if (value == null) 2129 - { 2130 - error = TraceOps.DebugAndTrace( 2131 - TracePriority.Lowest, debugCallback, 2132 - traceCallback, String.Format( 2133 - "Invalid {0} boolean value: {1}", 2134 - ForDisplay(arg), ForDisplay(text)), 2135 - traceCategory); 2136 - 2137 - if (strict) 2138 - return false; 2139 - 2140 - continue; 2141 - } 2142 - 2143 - configuration.noTrace = (bool)value; 2144 - } 2145 - else if (MatchOption(newArg, "noConsole")) 2146 - { 2147 - bool? value = ParseBoolean(text); 2148 - 2149 - if (value == null) 2150 - { 2151 - error = TraceOps.DebugAndTrace( 2152 - TracePriority.Lowest, debugCallback, 2153 - traceCallback, String.Format( 2154 - "Invalid {0} boolean value: {1}", 2155 - ForDisplay(arg), ForDisplay(text)), 2156 - traceCategory); 2157 - 2158 - if (strict) 2159 - return false; 2160 - 2161 - continue; 2162 - } 2163 - 2164 - configuration.noConsole = (bool)value; 2165 - } 2166 - else if (MatchOption(newArg, "noLog")) 2167 - { 2168 - bool? value = ParseBoolean(text); 2169 - 2170 - if (value == null) 2171 - { 2172 - error = TraceOps.DebugAndTrace( 2173 - TracePriority.Lowest, debugCallback, 2174 - traceCallback, String.Format( 2175 - "Invalid {0} boolean value: {1}", 2176 - ForDisplay(arg), ForDisplay(text)), 2177 - traceCategory); 2178 - 2179 - if (strict) 2180 - return false; 2181 - 2182 - continue; 2183 - } 2184 - 2185 - configuration.noLog = (bool)value; 2186 - } 2187 - else 2210 + configuration.noConsole = (bool)value; 2211 + } 2212 + else if (MatchOption(newArg, "noLog")) 2213 + { 2214 + bool? value = ParseBoolean(text); 2215 + 2216 + if (value == null) 2188 2217 { 2189 2218 error = TraceOps.DebugAndTrace( 2190 2219 TracePriority.Lowest, debugCallback, 2191 2220 traceCallback, String.Format( 2192 - "Unsupported command line option: {0}", 2193 - ForDisplay(arg)), traceCategory); 2221 + "Invalid {0} boolean value: {1}", 2222 + ForDisplay(arg), ForDisplay(text)), 2223 + traceCategory); 2194 2224 2195 2225 if (strict) 2196 2226 return false; 2227 + 2228 + continue; 2197 2229 } 2230 + 2231 + configuration.noLog = (bool)value; 2198 2232 } 2199 2233 else 2200 2234 { 2201 2235 error = TraceOps.DebugAndTrace( 2202 2236 TracePriority.Lowest, debugCallback, 2203 2237 traceCallback, String.Format( 2204 - "Unsupported command line argument: {0}", 2238 + "Unsupported command line option: {0}", 2205 2239 ForDisplay(arg)), traceCategory); 2206 2240 2207 2241 if (strict) 2208 2242 return false; 2209 2243 } 2210 2244 } 2211 2245 ................................................................................ 4943 4977 if (!Configuration.FromArgs( 4944 4978 args, true, ref configuration, ref error) || 4945 4979 !Configuration.Process( 4946 4980 args, configuration, true, ref error) || 4947 4981 !Configuration.CheckRuntimeVersion( 4948 4982 configuration, true, ref error)) 4949 4983 { 4950 - TraceOps.ShowMessage( 4951 - TracePriority.Highest, debugCallback, traceCallback, 4952 - thisAssembly, error, traceCategory, 4953 - MessageBoxButtons.OK, MessageBoxIcon.Error); 4984 + TraceOps.ShowMessage(TracePriority.Highest, 4985 + debugCallback, traceCallback, thisAssembly, 4986 + error, traceCategory, MessageBoxButtons.OK, 4987 + MessageBoxIcon.Error); 4954 4988 4955 4989 return 1; /* FAILURE */ 4956 4990 } 4957 4991 #endregion 4958 4992 4959 4993 /////////////////////////////////////////////////////////////////// 4960 4994