#define DOSINST

#include "dosinst.h"

#define GVIMEXT64_PATH "GvimExt64\\gvimext.dll"

#define GVIMEXT32_PATH "GvimExt32\\gvimext.dll"

#define CHECK_REG_ERROR(code) \

do { \

if (code != ERROR_SUCCESS) \

{ \

printf("%ld error number: %ld\n", (long)__LINE__, (long)code); \

return 1; \

} \

} while (0)

int has_vim = 0; /* installable vim.exe exists */

int has_gvim = 0; /* installable gvim.exe exists */

char oldvimrc[BUFSIZE]; /* name of existing vimrc file */

char vimrc[BUFSIZE]; /* name of vimrc file to create */

char *default_bat_dir = NULL; /* when not NULL, use this as the default

char *default_vim_dir = NULL; /* when not NULL, use this as the default

struct choice

};

struct choice choices[30]; /* choices the user can make */

int choice_count = 0; /* number of choices available */

#define TABLE_SIZE(s) (int)(sizeof(s) / sizeof(*s))

{

compat_vi = 1,

compat_some_enhancements,

compat_all_enhancements

};

char *(compat_choices[]) =

{

"\nChoose the default way to run Vim:",

"Vi compatible",

"with some Vim enhancements",

"with syntax highlighting and other features switched on",

};

int compat_choice = (int)compat_all_enhancements;

char *compat_text = "- run Vim %s";

{

remap_no = 1,

remap_win

};

char *(remap_choices[]) =

{

"\nChoose:",

"Do not remap keys for Windows behavior",

"Remap a few keys for Windows behavior (CTRL-V, CTRL-C, CTRL-F, etc)",

};

int remap_choice = (int)remap_no;

char *remap_text = "- %s";

{

mouse_xterm = 1,

mouse_mswin,

mouse_default

};

char *(mouse_choices[]) =

{

"\nChoose the way how Vim uses the mouse:",

"right button extends selection (the Unix way)",

"right button has a popup menu, left button starts select mode (the Windows way)",

"right button has a popup menu, left button starts visual mode",

};

int mouse_choice = (int)mouse_default;

char *mouse_text = "- The mouse %s";

{

vimfiles_dir_none = 1,

vimfiles_dir_vim,

vimfiles_dir_home

};

static char *(vimfiles_dir_choices[]) =

{

"\nCreate plugin directories:",

"No",

"In the VIM directory",

"In your HOME directory",

};

static int vimfiles_dir_choice;

static int install_popup = 0;

static int install_openwith = 0;

static int need_uninstall_entry = 0;

static char *(vimfiles_subdirs[]) =

{

"colors",

"compiler",

"doc",

"ftdetect",

"ftplugin",

"indent",

"keymap",

"plugin",

"syntax",

};

static int

get_choice(char **table, int entries)

{

int answer;

int idx;

char dummy[100];

do

{

for (idx = 0; idx < entries; ++idx)

{

if (idx)

printf("%2d ", idx);

puts(table[idx]);

}

printf("Choice: ");

if (scanf("%d", &answer) != 1)

{

scanf("%99s", dummy);

answer = 0;

}

}

while (answer < 1 || answer >= entries);

return answer;

}

static void

check_unpack(void)

{

char buf[BUFSIZE];

FILE *fd;

struct stat st;

/* check for presence of the correct version number in installdir[] */

runtimeidx = strlen(installdir) - strlen(VIM_VERSION_NODOT);

if (runtimeidx <= 0

|| stricmp(installdir + runtimeidx, VIM_VERSION_NODOT) != 0

|| (installdir[runtimeidx - 1] != '/'

&& installdir[runtimeidx - 1] != '\\'))

{

printf("ERROR: Install program not in directory \"%s\"\n",

VIM_VERSION_NODOT);

printf("This program can only work when it is located in its original directory\n");

myexit(1);

}

/* check if filetype.vim is present, which means the runtime archive has

sprintf(buf, "%s\\filetype.vim", installdir);

if (stat(buf, &st) < 0)

{

printf("ERROR: Cannot find filetype.vim in \"%s\"\n", installdir);

printf("It looks like you did not unpack the runtime archive.\n");

printf("You must unpack the runtime archive \"vim%srt.zip\" before installing.\n",

VIM_VERSION_NODOT + 3);

myexit(1);

}

/* Check if vim.exe or gvim.exe is in the current directory. */

if ((fd = fopen("gvim.exe", "r")) != NULL)

{

fclose(fd);

has_gvim = 1;

}

if ((fd = fopen("vim.exe", "r")) != NULL)

{

fclose(fd);

has_vim = 1;

}

if (!has_gvim && !has_vim)

{

printf("ERROR: Cannot find any Vim executables in \"%s\"\n\n",

installdir);

myexit(1);

}

}

static int

pathcmp(char *p, int plen, char *q, int qlen)

{

int i;

if (plen < 0)

plen = strlen(p);

if (qlen < 0)

qlen = strlen(q);

for (i = 0; ; ++i)

{

/* End of "p": check if "q" also ends or just has a slash. */

if (i == plen)

{

if (i == qlen) /* match */

return 0;

if (i == qlen - 1 && (q[i] == '\\' || q[i] == '/'))

return 0; /* match with trailing slash */

return 1; /* no match */

}

/* End of "q": check if "p" also ends or just has a slash. */

if (i == qlen)

{

if (i == plen) /* match */

return 0;

if (i == plen - 1 && (p[i] == '\\' || p[i] == '/'))

return 0; /* match with trailing slash */

return 1; /* no match */

}

if (!(mytoupper(p[i]) == mytoupper(q[i])

|| ((p[i] == '/' || p[i] == '\\')

&& (q[i] == '/' || q[i] == '\\'))))

return 1; /* no match */

}

/*NOTREACHED*/

}

static void

findoldfile(char **destination)

{

char *bp = *destination;

size_t indir_l = strlen(installdir);

char *cp = bp + indir_l;

char *tmpname;

char *farname;

/*

if (bp == NULL

|| strnicmp(bp, installdir, indir_l) != 0

|| strchr("/\\", *cp++) == NULL

|| strchr(cp, '\\') != NULL

|| strchr(cp, '/') != NULL)

return;

tmpname = alloc((int)strlen(cp) + 1);

strcpy(tmpname, cp);

tmpname[strlen(tmpname) - 1] = 'x'; /* .exe -> .exx */

if (access(tmpname, 0) == 0)

{

printf("\nERROR: %s and %s clash. Remove or rename %s.\n",

tmpname, cp, tmpname);

myexit(1);

}

if (rename(cp, tmpname) != 0)

{

printf("\nERROR: failed to rename %s to %s: %s\n",

cp, tmpname, strerror(0));

myexit(1);

}

farname = searchpath_save(cp);

if (rename(tmpname, cp) != 0)

{

printf("\nERROR: failed to rename %s back to %s: %s\n",

tmpname, cp, strerror(0));

myexit(1);

}

free(*destination);

free(tmpname);

*destination = farname;

}

static void

find_bat_exe(int check_bat_only)

{

int i;

/* avoid looking in the "installdir" by chdir to system root */

mch_chdir(sysdrive);

mch_chdir("\\");

for (i = 1; i < TARGET_COUNT; ++i)

{

targets[i].oldbat = searchpath_save(targets[i].batname);

if (!check_bat_only)

targets[i].oldexe = searchpath_save(targets[i].exename);

if (default_bat_dir == NULL && targets[i].oldbat != NULL)

{

default_bat_dir = alloc(strlen(targets[i].oldbat) + 1);

strcpy(default_bat_dir, targets[i].oldbat);

remove_tail(default_bat_dir);

}

if (check_bat_only && targets[i].oldbat != NULL)

{

free(targets[i].oldbat);

targets[i].oldbat = NULL;

}

}

mch_chdir(installdir);

}

static void

get_vim_env(void)

{

char *vim;

char buf[BUFSIZE];

FILE *fd;

char fname[BUFSIZE];

/* First get $VIMRUNTIME. If it's set, remove the tail. */

vim = getenv("VIMRUNTIME");

if (vim != NULL && *vim != 0 && strlen(vim) < BUFSIZE)

{

strcpy(buf, vim);

remove_tail(buf);

vim = buf;

}

else

{

vim = getenv("VIM");

if (vim == NULL || *vim == 0)

{

/* Use the directory from an old uninstall entry. */

if (default_vim_dir != NULL)

vim = default_vim_dir;

else

/* Let NSIS know there is no default, it should use

vim = "";

}

}

/* NSIS also uses GetTempPath(), thus we should get the same directory

GetTempPath(BUFSIZE, fname);

add_pathsep(fname);

strcat(fname, "vimini.ini");

fd = fopen(fname, "w");

if (fd != NULL)

{

/* Make it look like an .ini file, so that NSIS can read it with a

fprintf(fd, "[vimini]\n");

fprintf(fd, "dir=\"%s\"\n", vim);

fclose(fd);

}

else

{

printf("Failed to open %s\n", fname);

sleep(2);

}

}

static int num_windows;

static BOOL CALLBACK

window_cb(HWND hwnd, LPARAM lparam)

{

char title[256];

title[0] = 0;

GetWindowText(hwnd, title, 256);

if (strstr(title, "Vim ") != NULL && strstr(title, "Uninstall:") != NULL)

++num_windows;

return TRUE;

}

static int

uninstall_check(int skip_question)

{

HKEY key_handle;

HKEY uninstall_key_handle;

char *uninstall_key = "software\\Microsoft\\Windows\\CurrentVersion\\Uninstall";

char subkey_name_buff[BUFSIZE];

char temp_string_buffer[BUFSIZE];

DWORD local_bufsize = BUFSIZE;

FILETIME temp_pfiletime;

DWORD key_index;

char input;

long code;

DWORD value_type;

DWORD orig_num_keys;

DWORD new_num_keys;

int foundone = 0;

code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, uninstall_key, 0,

KEY_WOW64_64KEY | KEY_READ, &key_handle);

CHECK_REG_ERROR(code);

for (key_index = 0;

RegEnumKeyEx(key_handle, key_index, subkey_name_buff, &local_bufsize,

NULL, NULL, NULL, &temp_pfiletime) != ERROR_NO_MORE_ITEMS;

key_index++)

{

local_bufsize = BUFSIZE;

if (strncmp("Vim", subkey_name_buff, 3) == 0)

{

/* Open the key named Vim* */

code = RegOpenKeyEx(key_handle, subkey_name_buff, 0,

KEY_WOW64_64KEY | KEY_READ, &uninstall_key_handle);

CHECK_REG_ERROR(code);

/* get the DisplayName out of it to show the user */

code = RegQueryValueEx(uninstall_key_handle, "displayname", 0,

&value_type, (LPBYTE)temp_string_buffer,

&local_bufsize);

local_bufsize = BUFSIZE;

CHECK_REG_ERROR(code);

foundone = 1;

printf("\n*********************************************************\n");

printf("Vim Install found what looks like an existing Vim version.\n");

printf("The name of the entry is:\n");

printf("\n \"%s\"\n\n", temp_string_buffer);

printf("Installing the new version will disable part of the existing version.\n");

printf("(The batch files used in a console and the \"Edit with Vim\" entry in\n");

printf("the popup menu will use the new version)\n");

if (skip_question)

printf("\nRunning uninstall program for \"%s\"\n", temp_string_buffer);

else

printf("\nDo you want to uninstall \"%s\" now?\n(y)es/(n)o) ", temp_string_buffer);

fflush(stdout);

/* get the UninstallString */

code = RegQueryValueEx(uninstall_key_handle, "uninstallstring", 0,

&value_type, (LPBYTE)temp_string_buffer, &local_bufsize);

local_bufsize = BUFSIZE;

CHECK_REG_ERROR(code);

/* Remember the directory, it is used as the default for NSIS. */

default_vim_dir = alloc(strlen(temp_string_buffer) + 1);

strcpy(default_vim_dir, temp_string_buffer);

remove_tail(default_vim_dir);

remove_tail(default_vim_dir);

input = 'n';

do

{

if (input != 'n')

printf("%c is an invalid reply. Please enter either 'y' or 'n'\n", input);

if (skip_question)

input = 'y';

else

{

rewind(stdin);

scanf("%c", &input);

}

switch (input)

{

case 'y':

case 'Y':

/* save the number of uninstall keys so we can know if

RegQueryInfoKey(key_handle, NULL, NULL, NULL,

&orig_num_keys, NULL, NULL, NULL,

NULL, NULL, NULL, NULL);

/* Find existing .bat files before deleting them. */

find_bat_exe(TRUE);

/* Execute the uninstall program. Put it in double

{

char buf[BUFSIZE];

if (strchr(temp_string_buffer, ' ') != NULL)

sprintf(buf, "\"%s\"", temp_string_buffer);

else

strcpy(buf, temp_string_buffer);

run_command(buf);

}

/* Count the number of windows with a title that match

sleep(1); /* wait for uninstaller to start up */

num_windows = 0;

EnumWindows(window_cb, 0);

sleep(1); /* wait for windows to be counted */

if (num_windows == 0)

{

/* Did not find the uninstaller, ask user to press

printf("Press Enter when the uninstaller is finished\n");

rewind(stdin);

(void)getchar();

}

else

{

printf("Waiting for the uninstaller to finish (press CTRL-C to abort).");

do

{

printf(".");

fflush(stdout);

num_windows = 0;

EnumWindows(window_cb, 0);

sleep(1); /* wait for windows to be counted */

} while (num_windows > 0);

}

printf("\nDone!\n");

/* Check if an uninstall reg key was deleted.

RegQueryInfoKey(key_handle, NULL, NULL, NULL,

&new_num_keys, NULL, NULL, NULL,

NULL, NULL, NULL, NULL);

if (new_num_keys < orig_num_keys)

key_index--;

input = 'y';

break;

case 'n':

case 'N':

/* Do not uninstall */

input = 'n';

break;

default: /* just drop through and redo the loop */

break;

}

} while (input != 'n' && input != 'y');

RegCloseKey(uninstall_key_handle);

}

}

RegCloseKey(key_handle);

return foundone;

}

static void

inspect_system(void)

{

char *p;

char buf[BUFSIZE];

FILE *fd;

int i;

int foundone;

/* This may take a little while, let the user know what we're doing. */

printf("Inspecting system...\n");

/*

p = getenv("VIM");

if (p != NULL && pathcmp(p, -1, installdir, runtimeidx - 1) != 0)

{

printf("------------------------------------------------------\n");

printf("$VIM is set to \"%s\".\n", p);

printf("This is different from where this version of Vim is:\n");

strcpy(buf, installdir);

*(buf + runtimeidx - 1) = NUL;

printf("\"%s\"\n", buf);

printf("You must adjust or remove the setting of $VIM,\n");

if (interactive)

{

printf("to be able to use this install program.\n");

myexit(1);

}

printf("otherwise Vim WILL NOT WORK properly!\n");

printf("------------------------------------------------------\n");

}

/*

p = getenv("VIMRUNTIME");

if (p != NULL && pathcmp(p, -1, installdir, -1) != 0)

{

printf("------------------------------------------------------\n");

printf("$VIMRUNTIME is set to \"%s\".\n", p);

printf("This is different from where this version of Vim is:\n");

printf("\"%s\"\n", installdir);

printf("You must adjust or remove the setting of $VIMRUNTIME,\n");

if (interactive)

{

printf("to be able to use this install program.\n");

myexit(1);

}

printf("otherwise Vim WILL NOT WORK properly!\n");

printf("------------------------------------------------------\n");

}

/*

find_bat_exe(FALSE);

/*

foundone = 0;

for (i = 1; i < TARGET_COUNT; ++i)

{

findoldfile(&(targets[i].oldexe));

if (targets[i].oldexe != NULL)

foundone = 1;

}

if (foundone)

{

printf("Warning: Found Vim executable(s) in your $PATH:\n");

for (i = 1; i < TARGET_COUNT; ++i)

if (targets[i].oldexe != NULL)

printf("%s\n", targets[i].oldexe);

printf("It will be used instead of the version you are installing.\n");

printf("Please delete or rename it, or adjust your $PATH setting.\n");

}

/*

strcpy(oldvimrc, installdir);

strcpy(oldvimrc + runtimeidx, "_vimrc");

if ((fd = fopen(oldvimrc, "r")) == NULL)

{

strcpy(oldvimrc + runtimeidx, "vimrc~1"); /* short version of .vimrc */

if ((fd = fopen(oldvimrc, "r")) == NULL)

{

strcpy(oldvimrc + runtimeidx, ".vimrc");

fd = fopen(oldvimrc, "r");

}

}

if (fd != NULL)

fclose(fd);

else

*oldvimrc = NUL;

}

static void

add_dummy_choice(void)

{

choices[choice_count].installfunc = NULL;

choices[choice_count].active = 0;

choices[choice_count].changefunc = NULL;

choices[choice_count].installfunc = NULL;

++choice_count;

}

static void

install_bat_choice(int idx)

{

char *batpath = targets[choices[idx].arg].batpath;

char *oldname = targets[choices[idx].arg].oldbat;

char *exename = targets[choices[idx].arg].exenamearg;

char *vimarg = targets[choices[idx].arg].exearg;

FILE *fd;

if (*batpath != NUL)

{

fd = fopen(batpath, "w");

if (fd == NULL)

printf("\nERROR: Cannot open \"%s\" for writing.\n", batpath);

else

{

need_uninstall_entry = 1;

fprintf(fd, "@echo off\n");

fprintf(fd, "rem -- Run Vim --\n");

fprintf(fd, "\n");

fprintf(fd, "setlocal\n");

/* Don't use double quotes for the "set" argument, also when it

fprintf(fd, "set VIM_EXE_DIR=%s\n", installdir);

fprintf(fd, "if exist \"%%VIM%%\\%s\\%s\" set VIM_EXE_DIR=%%VIM%%\\%s\n",

VIM_VERSION_NODOT, exename, VIM_VERSION_NODOT);

fprintf(fd, "if exist \"%%VIMRUNTIME%%\\%s\" set VIM_EXE_DIR=%%VIMRUNTIME%%\n", exename);

fprintf(fd, "\n");

/* Give an error message when the executable could not be found. */

fprintf(fd, "if exist \"%%VIM_EXE_DIR%%\\%s\" goto havevim\n",

exename);

fprintf(fd, "echo \"%%VIM_EXE_DIR%%\\%s\" not found\n", exename);

fprintf(fd, "goto eof\n");

fprintf(fd, "\n");

fprintf(fd, ":havevim\n");

fprintf(fd, "rem collect the arguments in VIMARGS for Win95\n");

fprintf(fd, "set VIMARGS=\n");

if (*exename == 'g')

fprintf(fd, "set VIMNOFORK=\n");

fprintf(fd, ":loopstart\n");

fprintf(fd, "if .%%1==. goto loopend\n");

if (*exename == 'g')

{

fprintf(fd, "if NOT .%%1==.--nofork goto noforklongarg\n");

fprintf(fd, "set VIMNOFORK=1\n");

fprintf(fd, ":noforklongarg\n");

fprintf(fd, "if NOT .%%1==.-f goto noforkarg\n");

fprintf(fd, "set VIMNOFORK=1\n");

fprintf(fd, ":noforkarg\n");

}

fprintf(fd, "set VIMARGS=%%VIMARGS%% %%1\n");

fprintf(fd, "shift\n");

fprintf(fd, "goto loopstart\n");

fprintf(fd, ":loopend\n");

fprintf(fd, "\n");

fprintf(fd, "if .%%OS%%==.Windows_NT goto ntaction\n");

fprintf(fd, "\n");

/* For gvim.exe use "start" to avoid that the console window stays

if (*exename == 'g')

{

fprintf(fd, "if .%%VIMNOFORK%%==.1 goto nofork\n");

fprintf(fd, "start ");

}

/* Always use quotes, $VIM or $VIMRUNTIME might have a space. */

fprintf(fd, "\"%%VIM_EXE_DIR%%\\%s\" %s %%VIMARGS%%\n",

exename, vimarg);

fprintf(fd, "goto eof\n");

fprintf(fd, "\n");

if (*exename == 'g')

{

fprintf(fd, ":nofork\n");

fprintf(fd, "start /w ");

/* Always use quotes, $VIM or $VIMRUNTIME might have a space. */

fprintf(fd, "\"%%VIM_EXE_DIR%%\\%s\" %s %%VIMARGS%%\n",

exename, vimarg);

fprintf(fd, "goto eof\n");

fprintf(fd, "\n");

}

fprintf(fd, ":ntaction\n");

fprintf(fd, "rem for WinNT we can use %%*\n");

/* For gvim.exe use "start /b" to avoid that the console window

if (*exename == 'g')

{

fprintf(fd, "if .%%VIMNOFORK%%==.1 goto noforknt\n");

fprintf(fd, "start \"dummy\" /b ");

}

/* Always use quotes, $VIM or $VIMRUNTIME might have a space. */

fprintf(fd, "\"%%VIM_EXE_DIR%%\\%s\" %s %%*\n", exename, vimarg);

fprintf(fd, "goto eof\n");

fprintf(fd, "\n");

if (*exename == 'g')

{

fprintf(fd, ":noforknt\n");

fprintf(fd, "start \"dummy\" /b /wait ");

/* Always use quotes, $VIM or $VIMRUNTIME might have a space. */

fprintf(fd, "\"%%VIM_EXE_DIR%%\\%s\" %s %%*\n",

exename, vimarg);

}

fprintf(fd, "\n:eof\n");

fprintf(fd, "set VIMARGS=\n");

if (*exename == 'g')

fprintf(fd, "set VIMNOFORK=\n");

fclose(fd);

printf("%s has been %s\n", batpath,

oldname == NULL ? "created" : "overwritten");

}

}

}

static void

alloc_text(int idx, char *fmt, char *arg)

{

if (choices[idx].text != NULL)

free(choices[idx].text);

choices[idx].text = alloc((int)(strlen(fmt) + strlen(arg)) - 1);

sprintf(choices[idx].text, fmt, arg);

}

static void

toggle_bat_choice(int idx)

{

char *batname = targets[choices[idx].arg].batpath;

char *oldname = targets[choices[idx].arg].oldbat;

if (*batname == NUL)

{

alloc_text(idx, " Overwrite %s", oldname);

strcpy(batname, oldname);

}

else

{

alloc_text(idx, " Do NOT overwrite %s", oldname);

*batname = NUL;

}

}

static void

set_bat_text(int idx, char *batpath, char *name)

{

strcat(batpath, name);

alloc_text(idx, " Create %s", batpath);

}

static void

change_bat_choice(int idx)

{

char *path;

char *batpath;

char *name;

int n;

char *s;

char *p;

int count;

char **names = NULL;

int i;

int target = choices[idx].arg;

name = targets[target].batname;

batpath = targets[target].batpath;

path = getenv("PATH");

if (path == NULL)

{

printf("\nERROR: The variable $PATH is not set\n");

return;

}

/*

for (;;)

{

count = 1;

for (p = path; *p; )

{

s = strchr(p, ';');

if (s == NULL)

s = p + strlen(p);

if (names != NULL)

{

names[count] = alloc((int)(s - p) + 1);

strncpy(names[count], p, s - p);

names[count][s - p] = NUL;

}

++count;

p = s;

if (*p != NUL)

++p;

}

if (names != NULL)

break;

names = alloc((int)(count + 1) * sizeof(char *));

}

names[0] = alloc(50);

sprintf(names[0], "Select directory to create %s in:", name);

names[count] = alloc(50);

if (choices[idx].arg == 0)

sprintf(names[count], "Do not create any .bat file.");

else

sprintf(names[count], "Do not create a %s file.", name);

n = get_choice(names, count + 1);

if (n == count)

{

/* Selected last item, don't create bat file. */

*batpath = NUL;

if (choices[idx].arg != 0)

alloc_text(idx, " Do NOT create %s", name);

}