Source code for which.cs

```
using System;
```
```
using System.Collections.Generic;
```
```
using System.Diagnostics;
```
```
using System.IO;
```
```
using System.Text;
```
```
using System.Text.RegularExpressions;
```
```
using System.Windows.Forms;
```
```
 
```
```
 
```
```
namespace RobvanderWoude
```
```
{
```
```
	class Which
```
```
	{
```

		public static string progver = "1.48";

```
 
```
```
		public static char switchchar = '/';
```
```
 
```
```
		[STAThread]
```
```
		static int Main( string[] args )
```
```
		{
```
```
			#region Initialize Variables
```
```
 
```

			string[] path = String.Format( "{0};{1}", Environment.CurrentDirectory, Environment.GetEnvironmentVariable( "PATH" ) ).Split( ";".ToCharArray( ), StringSplitOptions.RemoveEmptyEntries );

			string[] pathext = ( ";" + Environment.GetEnvironmentVariable( "PATHEXT" ).ToLower( ) ).Split( ';' ); // unlike PATH, do NOT remove empty entries, we REQUIRE the first one to be empty

```
			string prog = string.Empty;
```
```
			string result = String.Empty;
```
```
			bool all = false;
```
```
			bool copy = false;
```
```
			bool extonly = false;
```
```
			bool filever = false;
```
```
			bool openexp = false;
```
```
			bool prodver = false;
```
```
			bool set_all = false;
```
```
			bool set_copy = false;
```
```
			bool set_exp = false;
```
```
			bool set_ext = false;
```
```
			bool set_fver = false;
```
```
			bool set_prog = false;
```
```
			bool set_pver = false;
```
```
			bool found = false;
```
```
 
```
```
			#endregion Initialize Variables
```
```
 
```
```
			#region Command Line Parsing
```
```
 
```
```
			if ( args.Length == 0 )
```
```
			{
```
```
				return WriteError( );
```
```
			}
```
```
 
```
```
			int scd = 0;
```
```
			int scu = 0;
```
```
 
```
```
			foreach ( string arg in args )
```
```
			{
```
```
				if ( arg[0] == '-' )
```
```
				{
```
```
					scu += 1;
```
```
				}
```
```
				if ( arg[0] == '/' )
```
```
				{
```
```
					scd += 1;
```
```
				}
```
```
				if ( arg == "/?" )
```
```
				{
```
```
					return WriteError( );
```
```
				}
```

				if ( arg == "-?" || arg == "-h" || arg == "--help" )

```
				{
```
```
					switchchar = '-';
```
```
					return WriteError( );
```
```
				}
```
```
			}
```
```
 
```
```
			if ( scu > scd )
```
```
			{
```
```
				switchchar = '-';
```
```
			}
```
```
 
```
```
			foreach ( string arg in args )
```
```
			{
```

				if ( arg[0] == '/' || arg[0] == '-' )

```
				{
```
```
					if ( arg.Length != 2 )
```
```
					{
```

						return WriteError( "Invalid command line switch {0}", ( switchchar == '/' ? arg.ToUpper( ) : arg.ToLower( ) ) );

```
					}
```

					switch ( arg[1].ToString( ).ToUpper( ) )

```
					{
```
```
						case "A":
```
```
							if ( set_all )
```
```
							{
```

								return WriteError( "Duplicate command line switch {0}", SwitchString( arg[1] ) );

```
							}
```
```
							if ( set_exp )
```
```
							{
```

								return WriteError( "Command line switches {0} and {1} are mutually exclusive", SwitchString( arg[1] ), SwitchString( "E" ) );

```
							}
```
```
							all = true;
```
```
							set_all = true;
```
```
							break;
```
```
						case "C":
```
```
							if ( set_copy )
```
```
							{
```

								return WriteError( "Duplicate command line switch {0}", SwitchString( arg[1] ) );

```
							}
```
```
							copy = true;
```
```
							set_copy = true;
```
```
							break;
```
```
						case "E":
```
```
							if ( set_exp )
```
```
							{
```

								return WriteError( "Duplicate command line switch {0}", SwitchString( arg[1] ) );

```
							}
```
```
							if ( set_all )
```
```
							{
```

								return WriteError( "Command line switches {0} and {1} are mutually exclusive", SwitchString( "A" ), SwitchString( arg[1] ) );

```
							}
```
```
							openexp = true;
```
```
							set_exp = true;
```
```
							break;
```
```
						case "F":
```
```
							if ( set_fver )
```
```
							{
```

								return WriteError( "Duplicate command line switch {0}", SwitchString( arg[1] ) );

```
							}
```
```
							if ( set_pver )
```
```
							{
```

								return WriteError( "Command line switches {0} and {1} are mutually exclusive", SwitchString( arg[1] ), SwitchString( "P" ) );

```
							}
```
```
							filever = true;
```
```
							set_fver = true;
```
```
							break;
```
```
						case "P":
```
```
							if ( set_pver )
```
```
							{
```

								return WriteError( "Duplicate command line switch {0}", SwitchString( "P" ) );

```
							}
```
```
							if ( set_fver )
```
```
							{
```

								return WriteError( "Command line switches {0} and {1} are mutually exclusive", SwitchString( "F" ), SwitchString( arg[1] ) );

```
							}
```
```
							prodver = true;
```
```
							set_pver = true;
```
```
							break;
```
```
						case "X":
```
```
							if ( set_ext )
```
```
							{
```

								return WriteError( "Duplicate command line switch {0}", SwitchString( arg[1] ) );

```
							}
```
```
							extonly = true;
```
```
							set_ext = true;
```
```
							break;
```
```
						case "?":
```
```
							return WriteError( );
```
```
						default:
```

							return WriteError( "Invalid command line switch {0}", ( switchchar == '/' ? arg.ToUpper( ) : arg.ToLower( ) ) );

```
					}
```
```
				}
```
```
				else
```
```
				{
```
```
					if ( set_prog )
```
```
					{
```

						return WriteError( "Invalid or duplicate command line argument: \"{0}\"", arg );

```
					}
```
```
					else
```
```
					{
```

						char[] forbidden = { '\\', '?', '*', ':', ';', '/' };

						if ( arg.IndexOfAny( forbidden ) == -1 )

```
						{
```
```
							prog = arg;
```
```
							set_prog = true;
```
```
						}
```
```
						else
```
```
						{
```

							return WriteError( "Invalid characters in specified program name: \"{0}\"", arg );

```
						}
```
```
					}
```
```
				}
```
```
			}
```
```
 
```
```
			#endregion Command Line Parsing
```
```
 
```
```
			try
```
```
			{
```
```
				if ( !extonly )
```
```
				{
```
```
					#region DOSKEY macros
```
```
 
```
```
					// Try DOSKEY macros first
```
```
					Process doskey = new Process( );
```

					doskey.StartInfo.Arguments = "/macros";

					doskey.StartInfo.CreateNoWindow = false;

					doskey.StartInfo.FileName = Environment.GetFolderPath( Environment.SpecialFolder.System ) + "\\doskey.exe";

					doskey.StartInfo.LoadUserProfile = false;

					doskey.StartInfo.RedirectStandardError = false;

					doskey.StartInfo.RedirectStandardInput = false;

					doskey.StartInfo.RedirectStandardOutput = true;

					doskey.StartInfo.UseShellExecute = false;

```
					doskey.Start( );
```
```
					doskey.WaitForExit( 1000 );
```
```
					do
```
```
					{
```

						string line = doskey.StandardOutput.ReadLine( );

```
						if ( !found || all )
```
```
						{
```

							if ( !String.IsNullOrEmpty( line ) )

```
							{
```
```
								if ( line.IndexOf( '=' ) > 0 )
```
```
								{
```

									string pattern = "^" + prog.ToUpper( ).Replace( ".", "\\." ) + "=";

									if ( Regex.IsMatch( line.ToUpper( ), pattern ) )

```
									{
```

										Console.ForegroundColor = ConsoleColor.White;

										Console.Write( "[{0}]::", doskey.StartInfo.FileName.ToUpper( ) );

```
										Console.ResetColor( );
```
```
										Console.WriteLine( line );
```

										result += String.Format( "[{0}]::{1}\n", doskey.StartInfo.FileName.ToUpper( ), line );

```
										found = true;
```
```
									}
```
```
								}
```
```
							}
```
```
						}
```

					} while ( doskey.StandardOutput.Peek( ) != -1 );

```
					doskey.Close( );
```
```
 
```
```
					#endregion DOSKEY macros
```
```
 
```
```
					#region Internal commands
```
```
 
```
```
					// Next try internal commands
```
```
					if ( !found || all )
```
```
					{
```
```
						if ( prog.IndexOf( '.' ) == -1 )
```
```
						{
```

							if ( ListInternalCommands( ).Contains( prog.ToUpper( ) ) )

```
							{
```

								Console.ForegroundColor = ConsoleColor.White;

								Console.Write( "[{0}]::", Environment.GetEnvironmentVariable( "COMSPEC" ).ToUpper( ) );

```
								Console.ResetColor( );
```

								Console.WriteLine( prog.ToUpper( ) );

								result += String.Format( "[{0}]::{1}\n", Environment.GetEnvironmentVariable( "COMSPEC" ).ToUpper( ), prog.ToUpper( ) );

```
								found = true;
```
```
							}
```
```
						}
```
```
					}
```
```
 
```
```
					#endregion Internal commands
```
```
				}
```
```
 
```
```
				#region External commands
```
```
 
```
```
				// Finally try external commands
```
```
				if ( !found || all )
```
```
				{
```
```
					foreach ( string folder in path )
```
```
					{
```
```
						if ( !found || all )
```
```
						{
```

							string dir = ( folder + @"\" ).Replace( @"\\", @"\" );

							foreach ( string ext in pathext )

```
							{
```
```
								if ( !found || all )
```
```
								{
```

									// The EXTERNAL program FILE to be searched MUST have an extension, either

									// specified on the command line or one of the extensions listed in PATHEXT.

									if ( ( prog + ext ).IndexOf( '.' ) > -1 )

```
									{
```

										if ( File.Exists( dir + prog + ext ) )

```
										{
```
```
											string ver = String.Empty;
```
```
											if ( filever )
```
```
											{
```

												string fileversion = FileVersionInfo.GetVersionInfo( dir + prog + ext ).FileVersion;

												if ( String.IsNullOrEmpty( fileversion ) )

```
												{
```
```
													ver = String.Empty;
```
```
												}
```
```
												else
```
```
												{
```

													ver = String.Format( " (file version {0})", fileversion );

```
												}
```
```
											}
```
```
											else if ( prodver )
```
```
											{
```

												string productversion = FileVersionInfo.GetVersionInfo( dir + prog + ext ).ProductVersion;

												if ( String.IsNullOrEmpty( productversion ) )

```
												{
```
```
													ver = String.Empty;
```
```
												}
```
```
												else
```
```
												{
```

													ver = String.Format( " (product version {0})", productversion );

```
												}
```
```
											}
```

											Console.WriteLine( dir + prog + ext + ver );

											result += String.Format( "{0}{1}{2}{3}\n", dir, prog, ext, ver );

```
											found = true;
```
```
										}
```
```
									}
```
```
								}
```
```
							}
```
```
						}
```
```
					}
```
```
				}
```
```
 
```
```
				#endregion External commands
```
```
 
```
```
				if ( found )
```
```
				{
```
```
					#region Copy to clipboard
```
```
 
```
```
					if ( copy )
```
```
					{
```
```
						if ( !all )
```
```
						{
```

							result = result.TrimEnd( "\n".ToCharArray( ) );

```
						}
```
```
						Clipboard.SetText( result );
```
```
					}
```
```
 
```
```
					#endregion Copy to clipboard
```
```
 
```
```
					#region Open In Explorer
```
```
 
```
```
					if ( openexp )
```
```
					{
```

						string file = result.TrimEnd( "\n".ToCharArray( ) );

						string sel = String.Format( "/Select, {0}", file );

						ProcessStartInfo expl = new ProcessStartInfo( "Explorer.exe", sel );

						System.Diagnostics.Process.Start( expl );

```
					}
```
```
 
```
```
					#endregion Open In Explorer
```
```
 
```
```
					return 0;
```
```
				}
```
```
				else
```
```
				{
```
```
					return 1;
```
```
				}
```
```
			}
```
```
			catch ( Exception e )
```
```
			{
```
```
				return WriteError( e.Message );
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		public static List<string> ListInternalCommands( )

```
		{
```

			string comspec = Environment.GetEnvironmentVariable( "COMSPEC" );

			StreamReader file = new StreamReader( comspec, Encoding.ASCII );

```
			string content = file.ReadToEnd( );
```
```
			file.Close( );
```
```
 
```
```
			bool include = false;
```

			List<string> intcmds = new List<string>( );

			string excludestr = "ABOVENORMAL,AFFINITY,ANSI,APPICON,ASCII,AZ,BAT,BELOWNORMAL,BOTH,CMD,CMDCMDLINE,CMDEXTVERSION,COM,COMSPEC,CONFIG,COPYCMD,COPYRIGHT,CRLF,CSVFS,CTRL,CURRENT,DEFINED,DIRCMD,DISABLEDELAYEDEXPANSION,DISABLEEXTENSIONS,DLL,DO,DOC,DOS,DWORD,ENABLEDELAYEDEXPANSION,ENABLEEXTENSIONS,ELSE,ENTER,EOF,EQU,ERROR,ERRORLEVEL,EXE,EXIST,EXISTS,EXPAND,FALSE,FAT,FH,GEQ,GTR,GUI,HIGH,HIGHESTNUMANODENUMBER,HH,HKEY,HSM,IDI,IDLE,IN,INFO,IS,JS,KERNEL,LEQ,LIST,LNK,LOCAL,LOW,LSS,MACHINE,MAX,MIN,MM,MSC,MUI,NEQ,NODE,NORMAL,NOT,NT,NTDLL,NTFS,NY,NYA,OFF,ON,OTHER,PATHEXT,PROCESSING,RANDOM,REALTIME,REFS,REG,REGEDT,SCRIPT,SEPARATE,SHARED,STACK,SYS,SZ,TEMP,TWO,UNC,UNCC,UNKNOWN,US,USER,VAR,VBS,VERSION,VS,WAIT,WA,WC,WD,WINDOWS,WKERNEL,WORD,WP,WS,WV,XCOPY,XP";

			string[] excludearr = excludestr.Split( ",".ToCharArray( ) );

			List<string> exclude = new List<string>( excludearr ); // Optimized for .NET Framework 2.0; in .NET Framework 3.5+ we might have used List<string> exclude = excludestr.Split( ",".ToCharArray( ) ).ToList<string>( );

```
 
```
```
			string pattern = @"([A-Z]\0){2,}";
```
```
			Regex regex = new Regex( pattern );
```
```
			if ( regex.IsMatch( content ) )
```
```
			{
```

				foreach ( Match match in regex.Matches( content ) )

```
				{
```

					string intcmd = match.ToString( ).Replace( "\0", String.Empty );

					if ( intcmd == "CD" ) // The start of the commands list, as found in Windows 7 SP1, EN-GB

```
					{
```
```
						include = true;
```
```
					}
```

					if ( intcmd == "ERRORLEVEL" ) // The end of the commands list, as found in Windows 7 SP1, EN-GB

```
					{
```
```
						include = false;
```
```
					}
```

					if ( include && !exclude.Contains( intcmd ) && !intcmds.Contains( intcmd ) )

```
					{
```
```
						intcmds.Add( intcmd );
```
```
					}
```
```
				}
```
```
				intcmds.Sort( );
```
```
			}
```
```
			if ( intcmds.Count == 0 )
```
```
			{
```

				// Return a default list if we could not find the internal commands in %COMSPEC%

				string defaultinternalcommands = @"ASSOC,BREAK,CALL,CD,CHDIR,CLS,COLOR,COPY,DATE,DEL,DIR,DPATH,ECHO,ENDLOCAL,ERASE,EXIT,FOR,FTYPE,GOTO,IF,KEYS,MD,MKDIR,MKLINK,MOVE,PATH,PAUSE,POPD,PROMPT,PUSHD,RD,REM,REN,RENAME,RMDIR,SET,SETLOCAL,SHIFT,START,TIME,TITLE,TYPE,VER,VERIFY,VOL";

				string[] defaultintcmdarr = defaultinternalcommands.Split( ",".ToCharArray( ), StringSplitOptions.RemoveEmptyEntries );

				intcmds = new List<string>( defaultintcmdarr );

```
			}
```
```
			return intcmds;
```
```
		}
```
```
 
```
```
 
```

		public static string SwitchString( char sw )

```
		{
```

			return SwitchString( sw.ToString( ) );

```
		}
```
```
 
```
```
 
```

		public static string SwitchString( string sw )

```
		{
```
```
			if ( switchchar == '-' )
```
```
			{
```

				return String.Format( "{0}{1}", switchchar, sw.ToLower( ) );

```
			}
```
```
			else
```
```
			{
```

				return String.Format( "{0}{1}", switchchar, sw.ToUpper( ) );

```
			}
```
```
		}
```
```
 
```
```
 
```

		public static int WriteError( params string[] errmsg )

```
		{
```
```
			/*
```
```
			Which,  Version 1.47
```
```
			Port of the UNIX command to Windows
```
```
 
```

			Usage:   WHICH  progname  [ /A | /E ]  [ /C ]  [ /F | /P ]  [ /X ]

```
 
```

			Where:   progname   the program name or internal command to be searched for

			         /A         returns All matches (default: stop at first match)

			         /C         Copies result to clipboard

			         /E         opens Explorer with result selected, if it is a file

			         /F         returns name and File version for external commands

			         /P         returns name and Product version for external commands

			         /X         returns eXternal commands only, no DOSKEY macros or

			                    internal commands   (default: all types)

```
 
```

			Note:    By default, this program first compares the specified name against

			         a list of active DOSKEY macros, next against a list of CMD's

			         internal commands, and finally it tries to find a matching program

			         file in the current directory and the PATH, using the extensions

```
			         listed in PATHEXT.
```
```
 
```
```
			Written by Rob van der Woude
```
```
			http://www.robvanderwoude.com
```
```
			*/
```
```
 
```
```
			if ( errmsg.Length > 0 )
```
```
			{
```

				List<string> errargs = new List<string>( errmsg );

```
				errargs.RemoveAt( 0 );
```
```
				Console.Error.WriteLine( );
```

				Console.ForegroundColor = ConsoleColor.Red;

```
				Console.Error.Write( "ERROR: " );
```

				Console.ForegroundColor = ConsoleColor.White;

				Console.Error.WriteLine( errmsg[0], errargs.ToArray( ) );

```
				Console.ResetColor( );
```
```
			}
```
```
 
```
```
			Console.Error.WriteLine( );
```

			Console.Error.WriteLine( "Which,  Version {0}", progver );

			Console.Error.WriteLine( "Port of the UNIX command to Windows" );

```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Usage:   " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			if ( switchchar == '/' )
```
```
			{
```

				Console.Error.WriteLine( "WHICH  progname  [ /A | /E ]  [ /C ]  [ /F | /P ]  [ /X ]" );

```
			}
```
```
			else
```
```
			{
```

				Console.Error.WriteLine( "which  progname  [ -a | -e ]  [ -c ]  [ -f | -p ]  [ -x ]" );

```
			}
```
```
			Console.ResetColor( );
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Where:   " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "progname" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "   the program name or internal command to be searched for" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         {0}", SwitchString( "A" ) );

```
			Console.ResetColor( );
```

			Console.Error.Write( "         returns " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "A" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "ll matches (default: stop at first match)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         {0}         C", SwitchString( "C" ) );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "opies result to clipboard" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         {0}", SwitchString( "E" ) );

```
			Console.ResetColor( );
```

			Console.Error.Write( "         opens " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "E" );
```
```
			Console.ResetColor( );
```

			Console.Error.Write( "xplorer with result selected, " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "if" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " it is a file" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         {0}", SwitchString( "F" ) );

```
			Console.ResetColor( );
```

			Console.Error.Write( "         returns name and " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "F" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "ile version for external commands" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         {0}", SwitchString( "P" ) );

```
			Console.ResetColor( );
```

			Console.Error.Write( "         returns name and " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "P" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "roduct version for external commands" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         {0}", SwitchString( "X" ) );

```
			Console.ResetColor( );
```

			Console.Error.Write( "         returns e" );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "X" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "ternal commands only, no DOSKEY macros or" );

```
 
```

			Console.Error.WriteLine( "                    internal commands   (default: all types)" );

```
 
```
```
			Console.Error.WriteLine( );
```

			Console.Error.WriteLine( "Note:    By default, this program first compares the specified name against" );

			Console.Error.WriteLine( "         a list of active DOSKEY macros, next against a list of CMD's" );

			Console.Error.WriteLine( "         internal commands, and finally it tries to find a matching program" );

			Console.Error.WriteLine( "         file in the current directory and the PATH, using the extensions" );

			Console.Error.WriteLine( "         listed in PATHEXT." );

```
			Console.Error.WriteLine( );
```

			Console.Error.WriteLine( "Written by Rob van der Woude" );

			Console.Error.WriteLine( "http://www.robvanderwoude.com" );

```
			return 1;
```
```
		}
```
```
	}
```
```
}
```
```
 
```