cmd: Remove redundant const.

[wine/hacks.git] / programs / cmd / batch.c

/*
 * CMD - Wine-compatible command line interface - batch interface.
 *
 * Copyright (C) 1999 D A Pickles
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include "wcmd.h"

void WCMD_batch_command (char *line);
void WCMD_HandleTildaModifiers(char **start, char *forVariable);

extern int echo_mode;
extern char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
extern BATCH_CONTEXT *context;
extern DWORD errorlevel;

/* msdn specified max for Win XP */
#define MAXSTRING 8192

/****************************************************************************
 * WCMD_batch
 *
 * Open and execute a batch file.
 * On entry *command includes the complete command line beginning with the name
 * of the batch file (if a CALL command was entered the CALL has been removed).
 * *file is the name of the file, which might not exist and may not have the
 * .BAT suffix on. Called is 1 for a CALL, 0 otherwise.
 *
 * We need to handle recursion correctly, since one batch program might call another.
 * So parameters for this batch file are held in a BATCH_CONTEXT structure.
 */

void WCMD_batch (char *file, char *command, int called) {

#define WCMD_BATCH_EXT_SIZE 5

HANDLE h = INVALID_HANDLE_VALUE;
char string[MAXSTRING];
char extension_batch[][WCMD_BATCH_EXT_SIZE] = {".bat",".cmd"};
char extension_exe[WCMD_BATCH_EXT_SIZE] = ".exe";
unsigned int  i;
BATCH_CONTEXT *prev_context;

  for(i=0; (i<(sizeof(extension_batch)/WCMD_BATCH_EXT_SIZE)) && 
           (h == INVALID_HANDLE_VALUE); i++) {
  strcpy (string, file);
  CharLower (string);
    if (strstr (string, extension_batch[i]) == NULL) strcat (string, extension_batch[i]);
  h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ,
                  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  }
  if (h == INVALID_HANDLE_VALUE) {
    strcpy (string, file);
    CharLower (string);
    if (strstr (string, extension_exe) == NULL) strcat (string, extension_exe);
    h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ,
                    NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (h != INVALID_HANDLE_VALUE) {
      WCMD_run_program (command, 0);
    } else {
      SetLastError (ERROR_FILE_NOT_FOUND);
      WCMD_print_error ();
    }
    return;
  }

/*
 *      Create a context structure for this batch file.
 */

  prev_context = context;
  context = (BATCH_CONTEXT *)LocalAlloc (LMEM_FIXED, sizeof (BATCH_CONTEXT));
  context -> h = h;
  context -> command = command;
  context -> shift_count = 0;
  context -> prev_context = prev_context;
  context -> skip_rest = FALSE;

/*
 *      Work through the file line by line. Specific batch commands are processed here,
 *      the rest are handled by the main command processor.
 */

  while (context -> skip_rest == FALSE && WCMD_fgets (string, sizeof(string), h)) {
      if (strlen(string) == MAXSTRING -1) {
          WCMD_output_asis( "Line in Batch processing possibly truncated. Using:\n");
          WCMD_output_asis( string);
          WCMD_output_asis( "\n");
      }
      if (string[0] != ':') {                      /* Skip over labels */
          WCMD_batch_command (string);
      }
  }
  CloseHandle (h);

/*
 *      If invoked by a CALL, we return to the context of our caller. Otherwise return
 *      to the caller's caller.
 */

  LocalFree ((HANDLE)context);
  if ((prev_context != NULL) && (!called)) {
    CloseHandle (prev_context -> h);
    context = prev_context -> prev_context;
    LocalFree ((HANDLE)prev_context);
  }
  else {
    context = prev_context;
  }
}

/****************************************************************************
 * WCMD_batch_command
 *
 * Execute one line from a batch file, expanding parameters.
 */

void WCMD_batch_command (char *line) {

DWORD status;
char cmd1[MAXSTRING],cmd2[MAXSTRING];
char *p, *s, *t;
int i;

  /* Get working version of command line */
  strcpy(cmd1, line);

  /* Expand environment variables in a batch file %{0-9} first  */
  /*   Then env vars, and if any left (ie use of undefined vars,*/
  /*   replace with spaces                                      */
  /* FIXME: Winnt would replace %1%fred%1 with first parm, then */
  /*   contents of fred, then the digit 1. Would need to remove */
  /*   ExpandEnvStrings to achieve this                         */

  /* Replace use of %0...%9 and errorlevel*/
  p = cmd1;
  while ((p = strchr(p, '%'))) {
    i = *(p+1) - '0';
    if (*(p+1) == '~') {
      WCMD_HandleTildaModifiers(&p, NULL);
      p++;
    } else if ((i >= 0) && (i <= 9)) {
      s = strdup (p+2);
      t = WCMD_parameter (context -> command, i + context -> shift_count, NULL);
      strcpy (p, t);
      strcat (p, s);
      free (s);
    } else if (*(p+1)=='*') {
      char *startOfParms = NULL;
      s = strdup (p+2);
      t = WCMD_parameter (context -> command, 1, &startOfParms);
      if (startOfParms != NULL) strcpy (p, startOfParms);
      else *p = 0x00;
      strcat (p, s);
      free (s);

    /* Handle DATE, TIME, ERRORLEVEL and CD replacements allowing */
    /* override if existing env var called that name              */
    } else if ((CompareString (LOCALE_USER_DEFAULT,
                              NORM_IGNORECASE | SORT_STRINGSORT,
                              (p+1), 11, "ERRORLEVEL%", -1) == 2) &&
              (GetEnvironmentVariable("ERRORLEVEL", cmd2, 1) == 0) &&
              (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
      char output[10];
      sprintf(output, "%d", errorlevel);
      s = strdup (p+12);
      strcpy (p, output);
      strcat (p, s);

    } else if ((CompareString (LOCALE_USER_DEFAULT,
                              NORM_IGNORECASE | SORT_STRINGSORT,
                              (p+1), 5, "DATE%", -1) == 2) &&
              (GetEnvironmentVariable("DATE", cmd2, 1) == 0) &&
              (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {

      GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL,
                    NULL, cmd2, MAXSTRING);
      s = strdup (p+6);
      strcpy (p, cmd2);
      strcat (p, s);

    } else if ((CompareString (LOCALE_USER_DEFAULT,
                              NORM_IGNORECASE | SORT_STRINGSORT,
                              (p+1), 5, "TIME%", -1) == 2) &&
              (GetEnvironmentVariable("TIME", cmd2, 1) == 0) &&
              (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
      GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, NULL,
                        NULL, cmd2, MAXSTRING);
      s = strdup (p+6);
      strcpy (p, cmd2);
      strcat (p, s);

    } else if ((CompareString (LOCALE_USER_DEFAULT,
                              NORM_IGNORECASE | SORT_STRINGSORT,
                              (p+1), 3, "CD%", -1) == 2) &&
              (GetEnvironmentVariable("CD", cmd2, 1) == 0) &&
              (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
      GetCurrentDirectory (MAXSTRING, cmd2);
      s = strdup (p+4);
      strcpy (p, cmd2);
      strcat (p, s);

    } else {
      p++;
    }
  }

  /* Now replace environment variables */
  status = ExpandEnvironmentStrings(cmd1, cmd2, sizeof(cmd2));
  if (!status) {
    WCMD_print_error ();
    return;
  }

  /* In a batch program, unknown variables are replace by nothing */
  /* so remove any remaining %var%                                */
  p = cmd2;
  while ((p = strchr(p, '%'))) {
    s = strchr(p+1, '%');
    if (!s) {
      *p=0x00;
    } else {
      t = strdup(s+1);
      strcpy(p, t);
      free(t);
    }
  }

  /* Show prompt before batch line IF echo is on */
  if (echo_mode && (line[0] != '@')) {
    WCMD_show_prompt();
    WCMD_output_asis ( cmd2);
    WCMD_output_asis ( "\n");
  }

  WCMD_process_command (cmd2);
}

/*******************************************************************
 * WCMD_parameter - extract a parameter from a command line.
 *
 *      Returns the 'n'th space-delimited parameter on the command line (zero-based).
 *      Parameter is in static storage overwritten on the next call.
 *      Parameters in quotes (and brackets) are handled.
 *      Also returns a pointer to the location of the parameter in the command line.
 */

char *WCMD_parameter (char *s, int n, char **where) {

int i = 0;
static char param[MAX_PATH];
char *p;

  p = param;
  while (TRUE) {
    switch (*s) {
      case ' ':
        s++;
        break;
      case '"':
        if (where != NULL) *where = s;
        s++;
        while ((*s != '\0') && (*s != '"')) {
          *p++ = *s++;
        }
        if (i == n) {
          *p = '\0';
          return param;
        }
        if (*s == '"') s++;
          param[0] = '\0';
          i++;
        p = param;
        break;
      case '(':
        if (where != NULL) *where = s;
        s++;
        while ((*s != '\0') && (*s != ')')) {
          *p++ = *s++;
        }
        if (i == n) {
          *p = '\0';
          return param;
        }
        if (*s == ')') s++;
          param[0] = '\0';
          i++;
        p = param;
        break;
      case '\0':
        return param;
      default:
        /* Only return where if it is for the right parameter */
        if (where != NULL && i==n) *where = s;
        while ((*s != '\0') && (*s != ' ')) {
          *p++ = *s++;
        }
        if (i == n) {
          *p = '\0';
          return param;
        }
          param[0] = '\0';
          i++;
        p = param;
    }
  }
}

/****************************************************************************
 * WCMD_fgets
 *
 * Get one line from a batch file. We can't use the native f* functions because
 * of the filename syntax differences between DOS and Unix. Also need to lose
 * the LF (or CRLF) from the line.
 */

char *WCMD_fgets (char *s, int n, HANDLE h) {

DWORD bytes;
BOOL status;
char *p;

  p = s;
  do {
    status = ReadFile (h, s, 1, &bytes, NULL);
    if ((status == 0) || ((bytes == 0) && (s == p))) return NULL;
    if (*s == '\n') bytes = 0;
    else if (*s != '\r') {
      s++;
      n--;
    }
    *s = '\0';
  } while ((bytes == 1) && (n > 1));
  return p;
}

/* _splitpath - copied from winefile as no obvious way to use it otherwise */
void _splitpath(const CHAR* path, CHAR* drv, CHAR* dir, CHAR* name, CHAR* ext)
{
        const CHAR* end; /* end of processed string */
        const CHAR* p;   /* search pointer */
        const CHAR* s;   /* copy pointer */

        /* extract drive name */
        if (path[0] && path[1]==':') {
                if (drv) {
                        *drv++ = *path++;
                        *drv++ = *path++;
                        *drv = '\0';
                }
        } else if (drv)
                *drv = '\0';

        /* search for end of string or stream separator */
        for(end=path; *end && *end!=':'; )
                end++;

        /* search for begin of file extension */
        for(p=end; p>path && *--p!='\\' && *p!='/'; )
                if (*p == '.') {
                        end = p;
                        break;
                }

        if (ext)
                for(s=end; (*ext=*s++); )
                        ext++;

        /* search for end of directory name */
        for(p=end; p>path; )
                if (*--p=='\\' || *p=='/') {
                        p++;
                        break;
                }

        if (name) {
                for(s=p; s<end; )
                        *name++ = *s++;

                *name = '\0';
        }

        if (dir) {
                for(s=path; s<p; )
                        *dir++ = *s++;

                *dir = '\0';
        }
}

/****************************************************************************
 * WCMD_HandleTildaModifiers
 *
 * Handle the ~ modifiers when expanding %0-9 or (%a-z in for command)
 *    %~xxxxxV  (V=0-9 or A-Z)
 * Where xxxx is any combination of:
 *    ~ - Removes quotes
 *    f - Fully qualified path (assumes current dir if not drive\dir)
 *    d - drive letter
 *    p - path
 *    n - filename
 *    x - file extension
 *    s - path with shortnames
 *    a - attributes
 *    t - date/time
 *    z - size
 *    $ENVVAR: - Searches ENVVAR for (contents of V) and expands to fully
 *                   qualified path
 *
 *  To work out the length of the modifier:
 *
 *  Note: In the case of %0-9 knowing the end of the modifier is easy,
 *    but in a for loop, the for end character may also be a modifier
 *    eg. for %a in (c:\a.a) do echo XXX
 *             where XXX = %~a    (just ~)
 *                         %~aa   (~ and attributes)
 *                         %~aaxa (~, attributes and extension)
 *                   BUT   %~aax  (~ and attributes followed by 'x')
 *
 *  Hence search forwards until find an invalid modifier, and then
 *  backwards until find for variable or 0-9
 */
void WCMD_HandleTildaModifiers(char **start, char *forVariable) {

#define NUMMODIFIERS 11
  const char validmodifiers[NUMMODIFIERS] = {
        '~', 'f', 'd', 'p', 'n', 'x', 's', 'a', 't', 'z', '$'
  };

  WIN32_FILE_ATTRIBUTE_DATA fileInfo;
  char  outputparam[MAX_PATH];
  char  finaloutput[MAX_PATH];
  char  fullfilename[MAX_PATH];
  char  thisoutput[MAX_PATH];
  char  *pos            = *start+1;
  char  *firstModifier  = pos;
  char  *lastModifier   = NULL;
  int   modifierLen     = 0;
  BOOL  finished        = FALSE;
  int   i               = 0;
  BOOL  exists          = TRUE;
  BOOL  skipFileParsing = FALSE;
  BOOL  doneModifier    = FALSE;

  /* Search forwards until find invalid character modifier */
  while (!finished) {

    /* Work on the previous character */
    if (lastModifier != NULL) {

      for (i=0; i<NUMMODIFIERS; i++) {
        if (validmodifiers[i] == *lastModifier) {

          /* Special case '$' to skip until : found */
          if (*lastModifier == '$') {
            while (*pos != ':' && *pos) pos++;
            if (*pos == 0x00) return; /* Invalid syntax */
            pos++;                    /* Skip ':'       */
          }
          break;
        }
      }

      if (i==NUMMODIFIERS) {
        finished = TRUE;
      }
    }

    /* Save this one away */
    if (!finished) {
      lastModifier = pos;
      pos++;
    }
  }

  /* Now make sure the position we stopped at is a valid parameter */
  if (!(*lastModifier >= '0' || *lastModifier <= '9') &&
      (forVariable != NULL) &&
      (toupper(*lastModifier) != toupper(*forVariable)))  {

    /* Its not... Step backwards until it matches or we get to the start */
    while (toupper(*lastModifier) != toupper(*forVariable) &&
          lastModifier > firstModifier) {
      lastModifier--;
    }
    if (lastModifier == firstModifier) return; /* Invalid syntax */
  }

  /* Extract the parameter to play with */
  if ((*lastModifier >= '0' && *lastModifier <= '9')) {
    strcpy(outputparam, WCMD_parameter (context -> command,
                 *lastModifier-'0' + context -> shift_count, NULL));
  } else {
    /* FIXME: Retrieve 'for' variable %c\n", *lastModifier); */
    /* Need to get 'for' loop variable into outputparam      */
    return;
  }

  /* So now, firstModifier points to beginning of modifiers, lastModifier
     points to the variable just after the modifiers. Process modifiers
     in a specific order, remembering there could be duplicates           */
  modifierLen = lastModifier - firstModifier;
  finaloutput[0] = 0x00;

  /* Useful for debugging purposes: */
  /*printf("Modifier string '%*.*s' and variable is %c\n Param starts as '%s'\n",
             (modifierLen), (modifierLen), firstModifier, *lastModifier,
             outputparam);*/

  /* 1. Handle '~' : Strip surrounding quotes */
  if (outputparam[0]=='"' &&
      memchr(firstModifier, '~', modifierLen) != NULL) {
    int len = strlen(outputparam);
    if (outputparam[len-1] == '"') {
        outputparam[len-1]=0x00;
        len = len - 1;
    }
    memmove(outputparam, &outputparam[1], len-1);
  }

  /* 2. Handle the special case of a $ */
  if (memchr(firstModifier, '$', modifierLen) != NULL) {
    /* Special Case: Search envar specified in $[envvar] for outputparam
       Note both $ and : are guaranteed otherwise check above would fail */
    char *start = strchr(firstModifier, '$') + 1;
    char *end   = strchr(firstModifier, ':');
    char env[MAX_PATH];
    char fullpath[MAX_PATH];

    /* Extract the env var */
    strncpy(env, start, (end-start));
    env[(end-start)] = 0x00;

    /* If env var not found, return emptry string */
    if ((GetEnvironmentVariable(env, fullpath, MAX_PATH) == 0) ||
        (SearchPath(fullpath, outputparam, NULL,
                    MAX_PATH, outputparam, NULL) == 0)) {
      finaloutput[0] = 0x00;
      outputparam[0] = 0x00;
      skipFileParsing = TRUE;
    }
  }

  /* After this, we need full information on the file,
    which is valid not to exist.  */
  if (!skipFileParsing) {
    if (GetFullPathName(outputparam, MAX_PATH, fullfilename, NULL) == 0)
      return;

    exists = GetFileAttributesExA(fullfilename, GetFileExInfoStandard,
                                  &fileInfo);

    /* 2. Handle 'a' : Output attributes */
    if (exists &&
        memchr(firstModifier, 'a', modifierLen) != NULL) {

      doneModifier = TRUE;
      strcpy(thisoutput, "---------");
      if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        thisoutput[0]='d';
      if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
        thisoutput[1]='r';
      if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE)
        thisoutput[2]='a';
      if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
        thisoutput[3]='h';
      if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
        thisoutput[4]='s';
      if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED)
        thisoutput[5]='c';
      /* FIXME: What are 6 and 7? */
      if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
        thisoutput[8]='l';
      strcat(finaloutput, thisoutput);
    }

    /* 3. Handle 't' : Date+time */
    if (exists &&
        memchr(firstModifier, 't', modifierLen) != NULL) {

      SYSTEMTIME systime;
      int datelen;

      doneModifier = TRUE;
      if (finaloutput[0] != 0x00) strcat(finaloutput, " ");

      /* Format the time */
      FileTimeToSystemTime(&fileInfo.ftLastWriteTime, &systime);
      GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime,
                        NULL, thisoutput, MAX_PATH);
      strcat(thisoutput, " ");
      datelen = strlen(thisoutput);
      GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &systime,
                        NULL, (thisoutput+datelen), MAX_PATH-datelen);
      strcat(finaloutput, thisoutput);
    }

    /* 4. Handle 'z' : File length */
    if (exists &&
        memchr(firstModifier, 'z', modifierLen) != NULL) {
      /* FIXME: Output full 64 bit size (sprintf not support I64 here) */
      ULONG/*64*/ fullsize = /*(fileInfo.nFileSizeHigh << 32) +*/
                                  fileInfo.nFileSizeLow;

      doneModifier = TRUE;
      if (finaloutput[0] != 0x00) strcat(finaloutput, " ");
      sprintf(thisoutput, "%u", fullsize);
      strcat(finaloutput, thisoutput);
    }

    /* 4. Handle 's' : Use short paths (File doesnt have to exist) */
    if (memchr(firstModifier, 's', modifierLen) != NULL) {
      if (finaloutput[0] != 0x00) strcat(finaloutput, " ");
      /* Dont flag as doneModifier - %~s on its own is processed later */
      GetShortPathName(outputparam, outputparam, sizeof(outputparam));
    }

    /* 5. Handle 'f' : Fully qualified path (File doesnt have to exist) */
    /*      Note this overrides d,p,n,x                                 */
    if (memchr(firstModifier, 'f', modifierLen) != NULL) {
      doneModifier = TRUE;
      if (finaloutput[0] != 0x00) strcat(finaloutput, " ");
      strcat(finaloutput, fullfilename);
    } else {

      char drive[10];
      char dir[MAX_PATH];
      char fname[MAX_PATH];
      char ext[MAX_PATH];
      BOOL doneFileModifier = FALSE;

      if (finaloutput[0] != 0x00) strcat(finaloutput, " ");

      /* Split into components */
      _splitpath(fullfilename, drive, dir, fname, ext);

      /* 5. Handle 'd' : Drive Letter */
      if (memchr(firstModifier, 'd', modifierLen) != NULL) {
        strcat(finaloutput, drive);
        doneModifier = TRUE;
        doneFileModifier = TRUE;
      }

      /* 6. Handle 'p' : Path */
      if (memchr(firstModifier, 'p', modifierLen) != NULL) {
        strcat(finaloutput, dir);
        doneModifier = TRUE;
        doneFileModifier = TRUE;
      }

      /* 7. Handle 'n' : Name */
      if (memchr(firstModifier, 'n', modifierLen) != NULL) {
        strcat(finaloutput, fname);
        doneModifier = TRUE;
        doneFileModifier = TRUE;
      }

      /* 8. Handle 'x' : Ext */
      if (memchr(firstModifier, 'x', modifierLen) != NULL) {
        strcat(finaloutput, ext);
        doneModifier = TRUE;
        doneFileModifier = TRUE;
      }

      /* If 's' but no other parameter, dump the whole thing */
      if (!doneFileModifier &&
          memchr(firstModifier, 's', modifierLen) != NULL) {
        doneModifier = TRUE;
        if (finaloutput[0] != 0x00) strcat(finaloutput, " ");
        strcat(finaloutput, outputparam);
      }
    }
  }

  /* If No other modifier processed,  just add in parameter */
  if (!doneModifier) strcpy(finaloutput, outputparam);

  /* Finish by inserting the replacement into the string */
  pos = strdup (lastModifier+1);
  strcpy(*start, finaloutput);
  strcat(*start, pos);
  free(pos);
}