Contents:

• http://www.gnu.org/software/bash/manual/bashref.html#Quotingoffsite

• The Exec Key
  https://specifications.freedesktop.org/desktop-entry-spec/1.0/exec-variables.htmloffsite
• The GOption commandline parser
  https://docs.gtk.org/glib/goption.htmloffsite

• 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

    I also wrote a short book on Unicode:

    • • Brief Introduction to Unicode

• ShowParams.cpp

  • It's difficult to get the Windows Console to display Unicode characters, so here's a C++ WinForms program that will display the arguments in a TextBox.

    // ShowParams.cpp : main project file.
    #include "stdafx.h"
    #include "Form1.h"
    using namespace ShowParams2;
    [STAThreadAttribute]
    int main(array<System::String ^> ^args)
    {
     // Enabling Windows XP visual effects before any controls are created
     Application::EnableVisualStyles();
     Application::SetCompatibleTextRenderingDefault(false); 
     // Create the main window and run it
     Application::Run(gcnew Form1(args));
     return 0;
    }
    // Form1.h
    #pragma once
    namespace ShowParams2 {
     using namespace System;
     using namespace System::Windows::Forms;
     public ref class Form1 : public System::Windows::Forms::Form
     {
     public:
     private:
      array<System::String ^> ^args;
     public:
      Form1(array<System::String ^> ^_args) : args(_args)
      {
       InitializeComponent();
      }
     protected:
      ~Form1()
      {
       if (components)
       {
        delete components;
       }
      }
     private: System::Windows::Forms::TextBox^ textBox1;
     protected: 
     private:
      System::ComponentModel::Container ^components;
    #pragma region Windows Form Designer generated code
      void InitializeComponent(void)
      {
       this->textBox1 = (gcnew System::Windows::Forms::TextBox());
       this->SuspendLayout();
       // 
       // textBox1
       // 
       this->textBox1->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Bottom) 
        | System::Windows::Forms::AnchorStyles::Left) 
        | System::Windows::Forms::AnchorStyles::Right));
       this->textBox1->Location = System::Drawing::Point(12, 12);
       this->textBox1->Multiline = true;
       this->textBox1->Name = L"textBox1";
       this->textBox1->Size = System::Drawing::Size(260, 238);
       this->textBox1->TabIndex = 0;
       // 
       // Form1
       // 
       this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
       this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
       this->ClientSize = System::Drawing::Size(284, 262);
       this->Controls->Add(this->textBox1);
       this->Name = L"Form1";
       this->Text = L"Form1";
       this->Load += gcnew System::EventHandler(this, &Form1::Form1_Load);
       this->ResumeLayout(false);
       this->PerformLayout();
      }
    #pragma endregion
     private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e) {
       int i = 0;
       for each(String^ arg in args)
       {
        textBox1->AppendText("arg[" + i + "]=" + arg + Environment::NewLine);
        i++;
       }
      }
     };
    }
    

• 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.
• The implementation changed in 2008, which isn't documented.
• 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.
   This includes any trailing double quote enclosing a parameter.
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. The missing undocumented rule has to do with how doubledouble quotes ("") are handled:
   • Prior to 2008:
     If a closing " is followed immediately by another ", the 2nd " is accepted literally and added to the parameter.
   • After 2008
     1. A double quote encountered outside a double quoted block starts a double quoted block.
     2. A double quote encountered inside a double quoted block:
        • not followed by another double quote ends the double quoted block.
        • followed immediately by another double quote (e.g. ""), a single double quote is added to the output, and the double quoted block continues.

1. Parameters are always separated by a space or tab (multiple spaces/tabs OK)
   
2. If the parameter does not contain any spaces, tabs, or double quotes, then all the characters in the parameter are accepted as is (there is no need to enclose the parameter in double quotes).
   
3. Enclose spaces and tabs in a double quoted part
   
4. A double quoted part can be anywhere within a parameter
   
5. 2n backslashes followed by a " produce n backslashes + start/end double quoted part
   
6. 2n+1 backslashes followed by a " produce n backslashes + a literal quotation mark
   
7. n backslashes not followed by a quotation mark produce n backslashes
   
8. undocumented rules regarding double quotes:
   
   Prior to 2008:

   • A " outside a double quoted block starts a double quoted block
   • A " inside a double quoted block ends the double quoted block
   • If a closing " is followed immediately by another ", the 2nd " is accepted literally and added to the parameter.
   Post 2008:
   • Outside a double quoted block a " starts a double quoted block.
   • Inside a double quoted block a " followed by a different character (not another ") ends the double quoted block.
   • Inside a double quoted block a " followed immediately by another " (i.e. "") causes a single " to be added to the output, and the double quoted block continues.

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

Note: The result is what gets passed as part of the lpCommandLine argument to the CreateProcess() API. The newly created process still needs to retrieve the lpCommandLine string and parse off the parameters using it's own parsing rules (e.g. if it's a C/C++ program, it will use the Microsoft C/C++ parameter parsing rules to create the argv[] vector. See Putting It Together below for more on this).

A command line passed to a C/C++ program passes through two parsers:

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

Here are some examples:

It gets harder when double quotes are not escaped with ^ as cmd.exe will now interpert them as “Start or end a double quoted part.”

A Simplified method: (new!2016) (updated 2019)

The trick is to enclose parameters with ^" instead of just "

e.g. instead of:

use

The command processor cmd.exe will strip off the ^ and won't start any double quoted parts.

Simplified method steps:

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

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