Contents:

• http://www.gnu.org/software/bash/manual/bashref.html#Quoting
• http://linux.about.com/library/cmd/blcmdl1_bash.htm

• The Exec Key
  http://library.gnome.org/devel/desktop-entry-spec/#exec-variables
• The GOption commandline parser
  http://library.gnome.org/devel/glib/stable/glib-Commandline-option-parser.html

• ShowParams.c
  • #include "stdafx.h"
    int main(int argc, char* argv[])
    {
      for (int i = 0; i < argc; ++i)
      {
        printf("param %d = ",i);
        puts(argv[i]);
        printf("\n");
      }
      return 0;
    }
    
    
    (Note: Avoid using printf when printing parameters, as the parameter may contain a % which would be interpreted by printf as a conversion specifier. The program may crash with a bizarre error, such as "runtime error R6002 - Floating point not loaded".)
    
    
    
    (Note: If we started this function with wmain or _tmain then argv[] would point to wide character (unicode) strings. [Technically I'm not sure if they are UTF-16LE or UCS-2. I have 2 old posts discussing the basics of Unicode:
    

    • • Overview of Unicode's five different standards:
         http://forums.multiedit.com/viewtopic.php?f=4&t=1717#p6178
      
    • • Unicode: The Programmer's Nightmare
         http://forums.multiedit.com/viewtopic.php?f=4&t=1717#p6270

• ShowParamsC#.cs
  • using System;
    
    namespace ShowParams
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("There are {0} program arguments", args.Length);
    
                foreach (string arg in args)
                {
                    Console.WriteLine(arg);
                }
            }
        }
    }

• ShowParams.bat
  • @echo off
    echo Param1 = %1
    echo Param2 = %2
    echo Param3 = %3

• ShowParams.vbs
  • If Wscript.Arguments.Count = 0 Then
            Wscript.echo "No parameters found"
    Else
        i=0
            Do until i = Wscript.Arguments.Count
            Parms = Parms & "Param " & i & " = " & Wscript.Arguments(i) & " " & vbcr
            i = i+1
            loop
            Wscript.echo parms
    End If

1. ShowParams.exe
   

   ShowParams.exe (written in c)
   >ShowParams.exe "c:\test a\" "c:\test b\" param 0 = ShowParams.exe param 1 = c:\test a" c:\test param 2 = b"

   ( \" is interpreted as meaning 'a literal double quote.')
   
   
2. C#ShowParams.exe
   

   C#ShowParams.exe (written in C#)
   >C#ShowParams.exe "c:\test a\" "c:\test b\" There are 2 program arguments c:\test a" c:\test b"

   ( \" is interpreted as meaning 'a literal double quote.')
   
   
3. ShowParams.bat
   

   ShowParams.bat (a batch file)
   >ShowParams.bat "c:\test a\" "c:\test b\" param 1 = "c:\test a\" param 2 = "c:\test b\"

   (the double quotes are included as part of the parameter)
   
   
4. ShowParams.vbs
   

   ShowParams.vbs (a Visual Basic script)
   >ShowParams.vbs "c:\test a\" "c:\test b\" param 0 = c:\test a\ param 1 = c:\test b\

   (The double quotes are removed from the parameter)

1. ShowParams.exe
   

   ShowParams.exe     and     C#ShowParams.exe cmdline = "ShowParams.exe Hello Goodbye Friday"            ↓           CreateProcess(cmdline)  →     → New Process running ShowParams.exe            ↓ call           GetCommandLine()            ↓ parse           argv[] = ShowParams.exe Hello Goodbye Friday

   
   The parameter parsing rules are determined by the C++ compiler that compiled ShowParams.exe
   
   
   
2. ShowParams.bat
   

   ShowParams.bat cmdline = "ShowParams.bat Hello Goodbye Friday"            ↓           CreateProcess(cmdline)  →     → New Process runs cmd.exe to process the batch file ShowParams.bat            ↓ call           GetCommandLine()            ↓ parse           %1 = Hello %2 = Goodbye %3 = Friday

   
   The parameter parsing rules are determined by cmd.exe which processes the batch file.
   
   
   
3. ShowParams.vbs
   

   ShowParams.vbs cmdline = "ShowParams.vbs Hello Goodbye Friday"            ↓           CreateProcess(cmdline)  →     → New Process runs WScript.exe to process the VBScript file ShowParams.vbs            ↓ call           GetCommandLine()            ↓ parse           Wscript.Arguments(0) = Hello Wscript.Arguments(1) = Goodbye Wscript.Arguments(2) = Friday

   
   The parameter parsing rules are determined by WScript.exe which processes the VBScript file.

1. Parameters passed to ShowParams.exe are parsed by ShowParams.exe . The parameter parsing rules are determined by the C++ compiler that compiled ShowParams.exe
2. Parameters passed to ShowParams.bat are parsed by cmd.exe which is the program that processes batch files.
3. Parameters passed to ShowParams.vbs are parsed by WScript.exe which is the program that processes VBScript files³

• There is separate documentation for each version of Microsoft's C/C++ compiler.
• Fortunately the documentation is identical for all of them.
• Unfortunately the documentation isn't complete.
• Fortunately you're reading this.

1. Arguments are delimited by white space, which is either a space or a tab.
2. The caret character (^) is not recognized as an escape character or delimiter. The character is handled completely by the command-line parser in the operating system before being passed to the argv array in the program.
   They are referring to the scenario discussed in sec. 6.2 below, where first the command line parser (cmd.exe) parses your command, handling such things as the escape character ^ , the redirection characters > & < , the pipe character | , the %  character which may identify environment variables that need to be expanded (e.g. %PROGRAMFILES%), etc. The rules here describe how your C/C++ executable will parse the lpCommandLine that was passed to CreateProcess() by cmd.exe or whoever calls CreateProcess().
3. A string surrounded by double quotation marks ("string") is interpreted as a single argument, regardless of white space contained within. A quoted string can be embedded in an argument.
   The double quotes don't have to be around the whole parameter. A double quoted part may occur anywhere in the parameter.
4. A double quotation mark preceded by a backslash (\") is interpreted as a literal double quotation mark character (").
5. Backslashes are interpreted literally, unless they immediately precede a double quotation mark.
6. If an even number of backslashes is followed by a double quotation mark, one backslash is placed in the argv array for every pair of backslashes, and the double quotation mark is interpreted as a string delimiter.
7. If an odd number of backslashes is followed by a double quotation mark, one backslash is placed in the argv array for every pair of backslashes, and the double quotation mark is "escaped" by the remaining backslash, causing a literal double quotation mark (") to be placed in argv.
8. And here's the missing undocumented rule:
   If a closing " is followed immediately by another ", the 2nd " is accepted literally and added to the parameter.

1. by the Command Prompt Window (cmd.exe)
2. by ShowParams.exe

1. The cmd.exe command line parser parses your command & parameters
2. The C/C++ program retrieves the resulting command line and parses off the parameters

1. Start with the parameter you want
2. Apply the Microsoft C/C++ parsing rules that ShowParams.exe will apply when parsing the command line it retrieves  [sec. 5]
3. Apply the command line parsing rules that cmd.exe will apply when you enter the command and parameters  [sec. 7]

• TestParams8_1.bat
  • REM both lines should produce the same result
    ShowParams.exe "&<>^|()@ !"
    ShowParams.exe ^&^<^>^^^|^(^)^@" "^!
    
    
    (Note: Since this is a batch file, if there were any % we would need to double them.)

• TestParams8_2.bat
  • REM both lines should produce the same result
    ShowParams.exe "&<>^|@()!\"^&^<^>^^^|@()!^"
    ShowParams.exe ^&^<^>^^^|@()!\^"^&^<^>^^^|@()!
    
    
    (Note: Since this is a batch file, if there were any % we would need to double them.)

• TestParams8_3.bat
  • REM all 4 lines should produce the same result
    ShowParams.exe "\"^&^<^>^^^|@() !\"&<>^|@() !\"^"
    ShowParams.exe ^"\^"^&^<^>^^^|@() !\^"^&^<^>^^^|@() !\^"^"
    ShowParams.exe \"&<>^|@()" "!\"^&^<^>^^^|@()" "!\^"
    ShowParams.exe \^"^&^<^>^^^|@()^" ^"!\^"^&^<^>^^^|@()^" ^"!\^"
    
    
    (Note: Since this is a batch file, if there were any % we would need to double them.)

• TestParams8_4.bat
  • REM all 4 lines should produce the same result
    ShowParams.exe "\"C:\TEST A\\\""
    ShowParams.exe ^"\^"C:\TEST A\\\^"^"
    ShowParams.exe \"C:\TEST" "A\\\"
    ShowParams.exe \^"C:\TEST^" ^"A\\\^"
    
    
    (Note: Since this is a batch file, if there were any % we would need to double them.)

• TestParams8_5.bat
  • REM all 4 lines should produce the same result
    ShowParams.exe "\"C:\TEST ^%%^&^^ A\\\""
    ShowParams.exe ^"\^"C:\TEST %%^&^^ A\\\^"^"
    ShowParams.exe "\"C:\TEST ^%%^&^^ A\\\""
    ShowParams.exe \^"C:\TEST^" ^"%%^&^^^" ^"A\\\^"

1. The cmd.exe command line parser parses your command line & parameters and then starts running the batch file
2. The batch file retrieves the parameters, but when you use them, they get parsed again. Here's an example:
   1. a batch file line contains %1
   2. %1 is replaced with your parameter
   3. that line is then sent to the command line parser for execution, where it gets parsed

1. Start with the parameter you want
2. Apply the command line parsing rules that cmd.exe will apply when you enter the command and parameters  [sec. 7]
3. Again, apply the command line parsing rules that cmd.exe will apply when you enter the command and parameters  [sec. 7]

1. Command line arguments can be separated by an unquoted semicolon or comma. This affects builtin commands like COPY and batch file parameters.
2. If the command is called by name (no path), the following slash is treated a separator, as in DIR/P. This affects both builtin commands and external commands. Note: If you want to use NT-style slash-separated paths with DOS utilities you have to quote them (as in TYPE "C:/BOOT.INI").¹⁶

     Example:
      > C:\WINDOWS\system32\wscript.exe ShowParams.vbs hello goodbye Friday

“If you want to get picky, the truth is that you can’t read command-line arguments using VBScript; that’s because VBScript doesn’t know anything about command-line arguments. But that’s all right; after all, VBScript doesn’t have to know anything about command-line arguments. That’s because Windows Script Host takes care of all that stuff. “Any time you supply a command-line argument to a script that runs under Windows Script Host (that includes JScript scripts as well as VBScript scripts) those arguments are automatically stored in the Wscript.Arguments collection.”      —Hey, Scripting Guy! 2008 Winter Scripting Games: Retrieving Command-Line Arguments           http://www.microsoft.com/technet/scriptcenter/funzone/games/tips08/gtip0104.mspx

Algorithm:

1. call Kernel32.dll!GetCommandLine() to get the command line
2. make a copy of the command line
3. call wscript!SplitCommandLine() dry run to determine the number of parameters
4. allocate space for argv[] array
5. call wscript!SplitCommandLine() to parse parameters and fill in argv[] array

loop
   parse off next parameter:
   skip over spaces, tabs
   clear " flag
   save starting address of this parameter
   LOOP
      process this character:
      If space or tab
         if " flag set
            accept this space or tab as part of the parameter
         else
            write a 0 here to terminate this parameter
            and goto parse off next parameter
      Else if "
         toggle " flag, strip " (shift rest of line left 1 char)
      move to next char
   ENDLOOP
endloop

1. First the cmd.exe command line parser parses your command & parameters, using its cmd.exe parsing rules. It builds a command line, and calls CreateProcess() passing it the command line it built.
2. Then the Windows Script Host retrieves that resulting command line and parses off the parameters, using its WSH parsing rules.

1. Start with the parameter you want
2. Apply the WSH parsing rules that Windows Script Host will apply when parsing the command line it retrieves
3. Then apply the command line parsing rules that cmd.exe will apply when you enter the command and parameters

• ShowParams.vbs
  • If Wscript.Arguments.Count = 0 Then
            Wscript.echo "No parameters found"
    Else
        i=0
            Do until i = Wscript.Arguments.Count
            Parms = Parms & "Param " & i & " = " & Wscript.Arguments(i) & " " & vbcr
            i = i+1
            loop
            Wscript.echo parms
    End If

• ShowParams.js
  • if (WScript.Arguments.Count() ==0) {
      WScript.Echo("No parameters found");
    }
    else {
      var objArgs = WScript.Arguments;
      var parms = ""
      for (i=0, n=objArgs.length; i<n; i++) {
        parms += '\nParam '+i+'='+objArgs(i);
      }
      WScript.Echo(parms);
    }

1. Start with the parameter you want
2. Apply the Microsoft C/C++ parsing rules that ShowParams.exe will apply when parsing the command line it retrieves  [sec. 5]
3. Apply the command line parsing rules that cmd.exe will apply when you enter the command and parameters  [sec. 7]

• ShowParams.pl
  • if ( $#ARGV < 0 ) {
      print "No parameters\n";
    }
    else {
      my $i = 0;
      my $Parms = "";
      while ( $i <= $#ARGV ) {
        $Parms .= "Param $i = $ARGV[$i]\n";
        $i ++;
      }
      print $Parms;
    }

1. Start with the parameter you want
2. Apply the Microsoft C/C++ parsing rules that ShowParams.exe will apply when parsing the command line it retrieves  [sec. 5]
3. Apply the command line parsing rules that cmd.exe will apply when you enter the command and parameters  [sec. 7]

• ShowParams2.py
  • #!/usr/bin/python
    # Filename: using_sys.py
    import sys
    print 'The command line arguments are:'
    for i in sys.argv:
            print i
    print '\n\nThe PYTHONPATH is', sys.path, '\n'

• ShowParams3.py
  • #!/usr/bin/python
    # Filename: using_sys.py
    import sys
    print( 'The command line arguments are:' )
    for i in sys.argv:
            print( i )
    print( '\n\nThe PYTHONPATH is', sys.path, '\n' )

• ShowParams.rex
  • NumParams = %0%
    Param1 = %1%
    Param2 = %2%
    Param3 = %3%
    MsgBox GetCommandLine=%string%`nNumParams = %0%`nParam1 = %1%`nParam2 = %2%`nParam3 = %3%
    ExitApp

• ShowParams.rb
  • ARGV.each do|a|
      puts "Argument: #{a}"
    end

1. Start with the parameter you want
2. Apply the Microsoft C/C++ parsing rules that ShowParams.exe will apply when parsing the command line it retrieves  [sec. 5]
3. Apply the command line parsing rules that cmd.exe will apply when you enter the command and parameters  [sec. 7]

• ShowParams.ahk
  • 
    NumParams = %0%
    Param1 = %1%
    Param2 = %2%
    Param3 = %3%
    result := DllCall("kernel32\GetCommandLineW")
    pointer := result
    string := DllCall("MulDiv","int",pointer,"int",1,"int",1,"str")
    MsgBox GetCommandLine=%string%`nNumParams = %0%`nParam1 = %1%`nParam2 = %2%`nParam3 = %3%
    ExitApp