void cmd_run(void) {
   // RUN [ filename$ ] [, cmd_args$ ]
   getargs(&cmdline, 3, ",");
   unsigned char *filename = "", *cmd_args = "";
   switch (argc) {
       case 0:
           break;
       case 1:
           filename = getCstring(argv[0]);
           break;
       case 2:
           cmd_args = getCstring(argv[1]);
           break;
       default:
           filename = getCstring(argv[0]);
           cmd_args = getCstring(argv[2]);
           break;
   }

   // The memory allocated by getCstring() is not preserved across
   // a call to FileLoadProgram() so we need to cache 'filename' and
   // 'cmd_args' on the stack.
   unsigned char buf[MAXSTRLEN + 1];
   if (snprintf(buf, MAXSTRLEN + 1, "\"%s\",\"%s\"", filename, cmd_args) > MAXSTRLEN) {
       error("RUN command line too long");
   }
   unsigned char *pcmd_args = buf + strlen(filename) + 3;

   if (*filename && !FileLoadProgram(buf)) return;

   ClearRuntime();
   WatchdogSet = false;
   PrepareProgram(true);

   // Create a global constant MM.CMDLINE$ containing 'cmd_args'.
   void *ptr = findvar("MM.CMDLINE$", V_FIND | V_DIM_VAR | T_CONST);
   CtoM(pcmd_args);
   memcpy(ptr, pcmd_args + 1, *pcmd_args - 1);

   IgnorePIN = false;
   if(*ProgMemory != T_NEWLINE) return;                            // no program to run
   nextstmt = ProgMemory;
}

> list "cmdline.bas"
Option Explicit On
Print "MM.CMDLINE$='" + Mm.CmdLine$ + "'"
End
> run "cmdline.bas"
MM.CMDLINE$=''
> run "cmdline.bas", "--foo --bar"
MM.CMDLINE$='--foo --bar'
> run , "--wom --bat"
MM.CMDLINE$='--wom --bat'
>

/**
* @brief Transforms input beginning with * into a corresponding RUN command.
*
* e.g.
*   *foo              =>  RUN "foo"
*   *"foo bar"        =>  RUN "foo bar"
*   *foo --wombat     =>  RUN "foo", "--wombat"
*   *foo "wom"        =>  RUN "foo", Chr$(34) + "wom" + Chr$(34)
*   *foo "wom" "bat"  =>  RUN "foo", Chr$(34) + "wom" + Chr$(34) + " " + Chr$(34) + "bat" + Chr$(34)
*   *foo --wom="bat"  =>  RUN "foo", "--wom=" + Chr$(34) + "bat" + Chr$(34)
*/
static MmResult parse_transform_star_command(char *input) {
   char *src = input;
   while (isspace(*src)) src++; // Skip leading whitespace.
   if (*src != '*') return kInternalFault;
   src++;

   // Trim any trailing whitespace from the input.
   char *end = input + strlen(input) - 1;
   while (isspace(*end)) *end-- = '\0';

   // Allocate extra space to avoid string overrun.
   // We rely on the caller to clean this up.
   char *tmp = (char *) GetTempMemory(STRINGSIZE + 32);
   strcpy(tmp, "RUN");
   char *dst = tmp + 3;

   if (*src == '"') {
       // Everything before the second quote is the name of the file to RUN.
       *dst++ = ' ';
       *dst++ = *src++; // Leading quote.
       while (*src && *src != '"') *dst++ = *src++;
       if (*src == '"') *dst++ = *src++; // Trailing quote.
   } else {
       // Everything before the first space is the name of the file to RUN.
       int count = 0;
       while (*src && !isspace(*src)) {
           if (++count == 1) {
               *dst++ = ' ';
               *dst++ = '\"';
           }
           *dst++ = *src++;
       }
       if (count) *dst++ = '\"';
   }

   while (isspace(*src)) src++; // Skip whitespace.

   // Anything else is arguments.
   if (*src) {
       *dst++ = ',';
       *dst++ = ' ';

       // If 'src' starts with double-quote then replace with: Chr$(34) +
       if (*src == '"') {
           memcpy(dst, "Chr$(34) + ", 11);
           dst += 11;
           src++;
       }

       *dst++ = '\"';

       // Copy from 'src' to 'dst'.
       while (*src) {
           if (*src == '"') {
               // Close current set of quotes to insert a Chr$(34)
               memcpy(dst, "\" + Chr$(34)", 12);
               dst += 12;

               // Open another set of quotes unless this was the last character.
               if (*(src + 1)) {
                   memcpy(dst, " + \"", 4);
                   dst += 4;
               }
               src++;
           } else {
               *dst++ = *src++;
           }
           if (dst - tmp >= STRINGSIZE) return kStringTooLong;
       }

       // End with a double quote unless 'src' ended with one.
       if (*(src - 1) != '"') *dst++ = '\"';

       *dst = '\0';
   }

   if (dst - tmp >= STRINGSIZE) return kStringTooLong;

   // Copy transformed string back into the input buffer.
   cstring_cpy(input, tmp, STRINGSIZE);

   return kOk;
}