Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1770 insertions, 0 deletions

diff --git a/src/os_amiga.c b/src/os_amiga.c
new file mode 100644
index 0000000..0e0fa77
--- /dev/null
+++ b/src/os_amiga.c
@@ -0,0 +1,1770 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved	by Bram Moolenaar
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * os_amiga.c
+ *
+ * Amiga system-dependent routines.
+ */
+
+#include "vim.h"
+#include "version.h"
+
+#ifdef Window
+# undef Window	// Amiga has its own Window definition
+#endif
+
+#undef TRUE		// will be redefined by exec/types.h
+#undef FALSE
+
+// cproto fails on missing include files, skip them
+#ifndef PROTO
+
+#ifndef LATTICE
+# include <exec/types.h>
+# include <exec/exec.h>
+# include <libraries/dos.h>
+# include <intuition/intuition.h>
+#endif
+
+// XXX These are included from os_amiga.h
+// #include <proto/exec.h>
+// #include <proto/dos.h>
+// #include <proto/intuition.h>
+
+#include <exec/memory.h>
+#include <libraries/dosextens.h>
+
+#include <dos/dostags.h>	    // for 2.0 functions
+#include <dos/dosasl.h>
+
+// From version 4 of AmigaOS, several system structures must be allocated
+// and freed using system functions. "struct AnchorPath" is one.
+#ifdef __amigaos4__
+# include <dos/anchorpath.h>
+# define	free_fib(x) FreeDosObject(DOS_FIB, x)
+#else
+# define	free_fib(x) vim_free(fib)
+#endif
+
+#if defined(LATTICE) && !defined(SASC) && defined(FEAT_ARP)
+# include <libraries/arp_pragmas.h>
+#endif
+
+#endif // PROTO
+
+/*
+ * Set stack size to 1 MiB on NG systems. This should be enough even for
+ * hungry syntax HL / plugin combinations. Leave the stack alone on OS 3
+ * and below, those systems might be low on memory.
+ */
+#if defined(__amigaos4__)
+static const char* __attribute__((used)) stackcookie = "$STACK: 1048576";
+#elif defined(__AROS__) || defined(__MORPHOS__)
+unsigned long __stack = 1048576;
+#endif
+
+/*
+ * At this point TRUE and FALSE are defined as 1L and 0L, but we want 1 and 0.
+ */
+#undef	TRUE
+#define TRUE (1)
+#undef	FALSE
+#define FALSE (0)
+
+#ifdef __amigaos4__
+# define	dos_packet(a, b, c)   DoPkt(a, b, c, 0, 0, 0, 0)
+#elif !defined(AZTEC_C) && !defined(__AROS__)
+static long dos_packet(struct MsgPort *, long, long);
+#endif
+static int lock2name(BPTR lock, char_u *buf, long   len);
+static void out_num(long n);
+static struct FileInfoBlock *get_fib(char_u *);
+static int sortcmp(const void *a, const void *b);
+
+static BPTR		raw_in = (BPTR)NULL;
+static BPTR		raw_out = (BPTR)NULL;
+static int		close_win = FALSE;  // set if Vim opened the window
+
+/* Use autoopen for AmigaOS4, AROS and MorphOS */
+#if !defined(__amigaos4__) && !defined(__AROS__) && !defined(__MORPHOS__)
+struct IntuitionBase	*IntuitionBase = NULL;
+#endif
+#ifdef FEAT_ARP
+struct ArpBase		*ArpBase = NULL;
+#endif
+
+static struct Window	*wb_window;
+static char_u		*oldwindowtitle = NULL;
+
+#ifdef FEAT_ARP
+int			dos2 = FALSE;	    // Amiga DOS 2.0x or higher
+#endif
+int			size_set = FALSE;   // set to TRUE if window size was set
+
+#ifdef __GNUC__
+static char version[] __attribute__((used)) =
+    "\0$VER: Vim "
+    VIM_VERSION_MAJOR_STR "."
+    VIM_VERSION_MINOR_STR
+# ifdef PATCHLEVEL
+    "." PATCHLEVEL
+# endif
+# ifdef BUILDDATE
+    " (" BUILDDATE ")"
+# endif
+    ;
+#endif
+
+    void
+win_resize_on(void)
+{
+    OUT_STR_NF("\033[12{");
+}
+
+    void
+win_resize_off(void)
+{
+    OUT_STR_NF("\033[12}");
+}
+
+    void
+mch_write(char_u *p, int len)
+{
+    Write(raw_out, (char *)p, (long)len);
+}
+
+/*
+ * mch_inchar(): low level input function.
+ * Get a characters from the keyboard.
+ * If time == 0 do not wait for characters.
+ * If time == n wait a short time for characters.
+ * If time == -1 wait forever for characters.
+ *
+ * Return number of characters read.
+ */
+    int
+mch_inchar(
+    char_u  *buf,
+    int	    maxlen,
+    long    time,		// milliseconds
+    int	    tb_change_cnt UNUSED)
+{
+    int	    len;
+    long    utime;
+
+    if (time >= 0)
+    {
+	if (time == 0)
+	    utime = 100L;	    // time = 0 causes problems in DOS 1.2
+	else
+	    utime = time * 1000L;   // convert from milli to micro secs
+	if (WaitForChar(raw_in, utime) == 0)	// no character available
+	    return 0;
+    }
+    else    // time == -1
+    {
+	/*
+	 * If there is no character available within 2 seconds (default)
+	 * write the autoscript file to disk.  Or cause the CursorHold event
+	 * to be triggered.
+	 */
+	if (WaitForChar(raw_in, p_ut * 1000L) == 0)
+	{
+	    if (trigger_cursorhold() && maxlen >= 3)
+	    {
+		buf[0] = K_SPECIAL;
+		buf[1] = KS_EXTRA;
+		buf[2] = (int)KE_CURSORHOLD;
+		return 3;
+	    }
+	    before_blocking();
+	}
+    }
+
+    for (;;)	    // repeat until we got a character
+    {
+	len = Read(raw_in, (char *)buf, (long)maxlen / input_conv.vc_factor);
+	if (len > 0)
+	{
+	    // Convert from 'termencoding' to 'encoding'.
+	    if (input_conv.vc_type != CONV_NONE)
+		len = convert_input(buf, len, maxlen);
+	    return len;
+	}
+    }
+}
+
+/*
+ * return non-zero if a character is available
+ */
+    int
+mch_char_avail(void)
+{
+    return (WaitForChar(raw_in, 100L) != 0);
+}
+
+/*
+ * Return amount of memory still available in Kbyte.
+ */
+    long_u
+mch_avail_mem(int special)
+{
+#if defined(__amigaos4__) || defined(__AROS__) || defined(__MORPHOS__)
+    return (long_u)AvailMem(MEMF_ANY) >> 10;
+#else
+    return (long_u)(AvailMem(special ? (long)MEMF_CHIP : (long)MEMF_ANY)) >> 10;
+#endif
+}
+
+/*
+ * Waits a specified amount of time, or until input arrives if
+ * flags does not have MCH_DELAY_IGNOREINPUT.
+ */
+    void
+mch_delay(long msec, int flags)
+{
+#ifndef LATTICE		// SAS declares void Delay(ULONG)
+    void	    Delay(long);
+#endif
+
+    if (msec <= 0)
+	return;
+
+    if (flags & MCH_DELAY_IGNOREINPUT)
+	Delay(msec / 20L);	    // Delay works with 20 msec intervals
+    else
+	WaitForChar(raw_in, msec * 1000L);
+}
+
+/*
+ * We have no job control, fake it by starting a new shell.
+ */
+    void
+mch_suspend(void)
+{
+    suspend_shell();
+}
+
+#ifndef DOS_LIBRARY
+# define DOS_LIBRARY	((UBYTE *)"dos.library")
+#endif
+
+    void
+mch_init(void)
+{
+#if !defined(__amigaos4__) && !defined(__AROS__) && !defined(__MORPHOS__)
+    static char	    intlibname[] = "intuition.library";
+#endif
+
+#ifdef AZTEC_C
+    Enable_Abort = 0;		// disallow vim to be aborted
+#endif
+    Columns = 80;
+    Rows = 24;
+
+    /*
+     * Set input and output channels, unless we have opened our own window
+     */
+    if (raw_in == (BPTR)NULL)
+    {
+	raw_in = Input();
+	raw_out = Output();
+	/*
+	 * If Input() is not interactive, then Output() will be (because of
+	 * check in mch_check_win()).  Used for "Vim -".
+	 * Also check the other way around, for "Vim -h | more".
+	 */
+	if (!IsInteractive(raw_in))
+	    raw_in = raw_out;
+	else if (!IsInteractive(raw_out))
+	    raw_out = raw_in;
+    }
+
+    out_flush();
+
+    wb_window = NULL;
+#if !defined(__amigaos4__) && !defined(__AROS__) && !defined(__MORPHOS__)
+    if ((IntuitionBase = (struct IntuitionBase *)
+				OpenLibrary((UBYTE *)intlibname, 0L)) == NULL)
+    {
+	mch_errmsg(_("cannot open "));
+	mch_errmsg(intlibname);
+	mch_errmsg("!?\n");
+	mch_exit(3);
+    }
+#endif
+}
+
+#ifndef PROTO
+# include <workbench/startup.h>
+#endif
+
+/*
+ * Check_win checks whether we have an interactive window.
+ * If not, a new window is opened with the newcli command.
+ * If we would open a window ourselves, the :sh and :! commands would not
+ * work properly (Why? probably because we are then running in a background
+ * CLI). This also is the best way to assure proper working in a next
+ * Workbench release.
+ *
+ * For the -f option (foreground mode) we open our own window and disable :sh.
+ * Otherwise the calling program would never know when editing is finished.
+ */
+#define BUF2SIZE 320	    // length of buffer for argument with complete path
+
+    int
+mch_check_win(int argc, char **argv)
+{
+    int		    i;
+    BPTR	    nilfh, fh;
+    char_u	    buf1[24];
+    char_u	    buf2[BUF2SIZE];
+    static char_u   *(constrings[3]) = {(char_u *)"con:0/0/662/210/",
+					(char_u *)"con:0/0/640/200/",
+					(char_u *)"con:0/0/320/200/"};
+    static char_u   *winerr = (char_u *)N_("VIM: Can't open window!\n");
+    struct WBArg    *argp;
+    int		    ac;
+    char	    *av;
+    char_u	    *device = NULL;
+    int		    exitval = 4;
+#if !defined(__amigaos4__) && !defined(__AROS__) && !defined(__MORPHOS__)
+    struct Library  *DosBase;
+#endif
+    int		    usewin = FALSE;
+
+/*
+ * check if we are running under DOS 2.0x or higher
+ */
+#if !defined(__amigaos4__) && !defined(__AROS__) && !defined(__MORPHOS__)
+    DosBase = OpenLibrary(DOS_LIBRARY, 37L);
+    if (DosBase != NULL)
+    // if (((struct Library *)DOSBase)->lib_Version >= 37)
+    {
+	CloseLibrary(DosBase);
+# ifdef FEAT_ARP
+	dos2 = TRUE;
+# endif
+    }
+    else	    // without arp functions we NEED 2.0
+    {
+# ifndef FEAT_ARP
+	mch_errmsg(_("Need Amigados version 2.04 or later\n"));
+	exit(3);
+# else
+		    // need arp functions for dos 1.x
+	if (!(ArpBase = (struct ArpBase *) OpenLibrary((UBYTE *)ArpName, ArpVersion)))
+	{
+	    fprintf(stderr, _("Need %s version %ld\n"), ArpName, ArpVersion);
+	    exit(3);
+	}
+# endif
+    }
+#endif	/* __amigaos4__ __AROS__ __MORPHOS__ */
+
+    /*
+     * scan argv[] for the "-f" and "-d" arguments
+     */
+    for (i = 1; i < argc; ++i)
+	if (argv[i][0] == '-')
+	{
+	    switch (argv[i][1])
+	    {
+	    case 'f':
+		usewin = TRUE;
+		break;
+
+	    case 'd':
+		if (i < argc - 1
+#ifdef FEAT_DIFF
+			// require using "-dev", "-d" means diff mode
+			&& argv[i][2] == 'e' && argv[i][3] == 'v'
+#endif
+		   )
+		    device = (char_u *)argv[i + 1];
+		break;
+	    }
+	}
+
+/*
+ * If we were not started from workbench, do not have a "-d" or "-dev"
+ * argument and we have been started with an interactive window, use that
+ * window.
+ */
+    if (argc != 0
+	    && device == NULL
+	    && (IsInteractive(Input()) || IsInteractive(Output())))
+	return OK;
+
+/*
+ * When given the "-f" argument, we open our own window. We can't use the
+ * newcli trick below, because the calling program (mail, rn, etc.) would not
+ * know when we are finished.
+ */
+    if (usewin)
+    {
+	/*
+	 * Try to open a window. First try the specified device.
+	 * Then try a 24 line 80 column window.
+	 * If that fails, try two smaller ones.
+	 */
+	for (i = -1; i < 3; ++i)
+	{
+	    if (i >= 0)
+		device = constrings[i];
+	    if (device != NULL && (raw_in = Open((UBYTE *)device,
+					   (long)MODE_NEWFILE)) != (BPTR)NULL)
+		break;
+	}
+	if (raw_in == (BPTR)NULL)	// all three failed
+	{
+	    mch_errmsg(_(winerr));
+	    goto exit;
+	}
+	raw_out = raw_in;
+	close_win = TRUE;
+	return OK;
+    }
+
+    if ((nilfh = Open((UBYTE *)"NIL:", (long)MODE_NEWFILE)) == (BPTR)NULL)
+    {
+	mch_errmsg(_("Cannot open NIL:\n"));
+	goto exit;
+    }
+
+    /*
+     * Make a unique name for the temp file (which we will not delete!).
+     * Use a pointer on the stack (nobody else will be using it).
+     * Under AmigaOS4, this assumption might change in the future, so
+     * we use a pointer to the current task instead. This should be a
+     * shared structure and thus globally unique.
+     */
+#if !defined(__amigaos4__) && !defined(__AROS__) && !defined(__MORPHOS__)
+    sprintf((char *)buf1, "t:nc%p", FindTask(0));
+#else
+    sprintf((char *)buf1, "t:nc%ld", (long)buf1);
+#endif
+    if ((fh = Open((UBYTE *)buf1, (long)MODE_NEWFILE)) == (BPTR)NULL)
+    {
+	mch_errmsg(_("Cannot create "));
+	mch_errmsg((char *)buf1);
+	mch_errmsg("\n");
+	goto exit;
+    }
+    /*
+     * Write the command into the file, put quotes around the arguments that
+     * have a space in them.
+     */
+    if (argc == 0)	// run from workbench
+	ac = ((struct WBStartup *)argv)->sm_NumArgs;
+    else
+	ac = argc;
+    for (i = 0; i < ac; ++i)
+    {
+	if (argc == 0)
+	{
+	    *buf2 = NUL;
+	    argp = &(((struct WBStartup *)argv)->sm_ArgList[i]);
+	    if (argp->wa_Lock)
+		(void)lock2name(argp->wa_Lock, buf2, (long)(BUF2SIZE - 1));
+#ifdef FEAT_ARP
+	    if (dos2)	    // use 2.0 function
+#endif
+		AddPart((UBYTE *)buf2, (UBYTE *)argp->wa_Name, (long)(BUF2SIZE - 1));
+#ifdef FEAT_ARP
+	    else	    // use arp function
+		TackOn((char *)buf2, argp->wa_Name);
+#endif
+	    av = (char *)buf2;
+	}
+	else
+	    av = argv[i];
+
+	// skip '-d' or "-dev" option
+	if (av[0] == '-' && av[1] == 'd'
+#ifdef FEAT_DIFF
+		&& av[2] == 'e' && av[3] == 'v'
+#endif
+		)
+	{
+	    ++i;
+	    continue;
+	}
+	if (vim_strchr((char_u *)av, ' '))
+	    Write(fh, "\"", 1L);
+	Write(fh, av, (long)strlen(av));
+	if (vim_strchr((char_u *)av, ' '))
+	    Write(fh, "\"", 1L);
+	Write(fh, " ", 1L);
+    }
+    Write(fh, "\nendcli\n", 8L);
+    Close(fh);
+
+/*
+ * Try to open a new cli in a window. If "-d" or "-dev" argument was given try
+ * to open the specified device. Then try a 24 line 80 column window.  If that
+ * fails, try two smaller ones.
+ */
+    for (i = -1; i < 3; ++i)
+    {
+	if (i >= 0)
+	    device = constrings[i];
+	else if (device == NULL)
+	    continue;
+	sprintf((char *)buf2, "newcli <nil: >nil: %s from %s", (char *)device, (char *)buf1);
+#ifdef FEAT_ARP
+	if (dos2)
+	{
+#endif
+	    if (!SystemTags((UBYTE *)buf2, SYS_UserShell, TRUE, TAG_DONE))
+		break;
+#ifdef FEAT_ARP
+	}
+	else
+	{
+	    if (Execute((UBYTE *)buf2, nilfh, nilfh))
+		break;
+	}
+#endif
+    }
+    if (i == 3)	    // all three failed
+    {
+	DeleteFile((UBYTE *)buf1);
+	mch_errmsg(_(winerr));
+	goto exit;
+    }
+    exitval = 0;    // The Execute succeeded: exit this program
+
+exit:
+#ifdef FEAT_ARP
+    if (ArpBase)
+	CloseLibrary((struct Library *) ArpBase);
+#endif
+    exit(exitval);
+    // NOTREACHED
+    return FAIL;
+}
+
+/*
+ * Return TRUE if the input comes from a terminal, FALSE otherwise.
+ * We fake there is a window, because we can always open one!
+ */
+    int
+mch_input_isatty(void)
+{
+    return TRUE;
+}
+
+/*
+ * fname_case(): Set the case of the file name, if it already exists.
+ *		 This will cause the file name to remain exactly the same
+ *		 if the file system ignores, but preserves case.
+ */
+//ARGSUSED
+    void
+fname_case(
+    char_u	*name,
+    int		len UNUSED)		// buffer size, ignored here
+{
+    struct FileInfoBlock    *fib;
+    size_t		    flen;
+
+    fib = get_fib(name);
+    if (fib == NULL)
+	return;
+
+    flen = STRLEN(name);
+    // TODO: Check if this fix applies to AmigaOS < 4 too.
+#ifdef __amigaos4__
+    if (fib->fib_DirEntryType == ST_ROOT)
+	strcat(fib->fib_FileName, ":");
+#endif
+    if (flen == strlen(fib->fib_FileName))	// safety check
+	mch_memmove(name, fib->fib_FileName, flen);
+    free_fib(fib);
+}
+
+/*
+ * Get the FileInfoBlock for file "fname"
+ * The returned structure has to be free()d.
+ * Returns NULL on error.
+ */
+    static struct FileInfoBlock *
+get_fib(char_u *fname)
+{
+    BPTR		    flock;
+    struct FileInfoBlock    *fib;
+
+    if (fname == NULL)	    // safety check
+	return NULL;
+#ifdef __amigaos4__
+    fib = AllocDosObject(DOS_FIB,0);
+#else
+    fib = ALLOC_ONE(struct FileInfoBlock);
+#endif
+    if (fib == NULL)
+	return;
+
+    flock = Lock((UBYTE *)fname, (long)ACCESS_READ);
+    if (flock == (BPTR)NULL || !Examine(flock, fib))
+    {
+	free_fib(fib);  // in case of an error the memory is freed here
+	fib = NULL;
+    }
+    if (flock)
+	UnLock(flock);
+    return fib;
+}
+
+/*
+ * set the title of our window
+ * icon name is not set
+ */
+    void
+mch_settitle(char_u *title, char_u *icon)
+{
+    if (wb_window != NULL && title != NULL)
+	SetWindowTitles(wb_window, (UBYTE *)title, (UBYTE *)-1L);
+}
+
+/*
+ * Restore the window/icon title.
+ * which is one of:
+ *  SAVE_RESTORE_TITLE  Just restore title
+ *  SAVE_RESTORE_ICON   Just restore icon (which we don't have)
+ *  SAVE_RESTORE_BOTH   Restore title and icon (which we don't have)
+ */
+    void
+mch_restore_title(int which)
+{
+    if (which & SAVE_RESTORE_TITLE)
+	mch_settitle(oldwindowtitle, NULL);
+}
+
+    int
+mch_can_restore_title(void)
+{
+    return (wb_window != NULL);
+}
+
+    int
+mch_can_restore_icon(void)
+{
+    return FALSE;
+}
+
+    void
+mch_setmouse(int on UNUSED)
+{
+    // TODO: implement
+}
+
+/*
+ * Insert user name in s[len].
+ */
+    int
+mch_get_user_name(char_u *s, int len)
+{
+#if defined(__amigaos4__) || defined(__AROS__) || defined(__MORPHOS__)
+    struct passwd   *pwd = getpwuid(getuid());
+
+    if (pwd != NULL && pwd->pw_name && len > 0)
+    {
+	vim_strncpy(s, (char_u *)pwd->pw_name, len - 1);
+	return OK;
+    }
+#endif
+    *s = NUL;
+    return FAIL;
+}
+
+/*
+ * Insert host name is s[len].
+ */
+    void
+mch_get_host_name(char_u *s, int len)
+{
+#if defined(__amigaos4__) && defined(__CLIB2__)
+    gethostname(s, len);
+#else
+    vim_strncpy(s, "Amiga", len - 1);
+#endif
+}
+
+/*
+ * return process ID
+ */
+    long
+mch_get_pid(void)
+{
+#if defined(__amigaos4__)
+    return (long) getpid();
+#elif defined(__AROS__) || defined(__MORPHOS__)
+    // This is as close to a pid as we can come. We could use CLI numbers also,
+    // but then we would have two different types of process identifiers.
+    return((long)FindTask(0));
+#else
+    return (long)0;
+#endif
+}
+
+/*
+ * Get name of current directory into buffer 'buf' of length 'len' bytes.
+ * Return OK for success, FAIL for failure.
+ */
+    int
+mch_dirname(char_u *buf, int len)
+{
+    return mch_FullName((char_u *)"", buf, len, FALSE);
+}
+
+/*
+ * get absolute file name into buffer 'buf' of length 'len' bytes
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+mch_FullName(
+    char_u	*fname,
+    char_u	*buf,
+    int		len,
+    int		force)
+{
+    BPTR	l;
+    int		retval = FAIL;
+    int		i;
+
+    // Lock the file.  If it exists, we can get the exact name.
+    if ((l = Lock((UBYTE *)fname, (long)ACCESS_READ)) != (BPTR)0)
+    {
+	retval = lock2name(l, buf, (long)len - 1);
+	UnLock(l);
+    }
+    else if (force || !mch_isFullName(fname))	    // not a full path yet
+    {
+	/*
+	 * If the file cannot be locked (doesn't exist), try to lock the
+	 * current directory and concatenate the file name.
+	 */
+	if ((l = Lock((UBYTE *)"", (long)ACCESS_READ)) != (BPTR)NULL)
+	{
+	    retval = lock2name(l, buf, (long)len);
+	    UnLock(l);
+	    if (retval == OK)
+	    {
+		i = STRLEN(buf);
+		// Concatenate the fname to the directory.  Don't add a slash
+		// if fname is empty, but do change "" to "/".
+		if (i == 0 || *fname != NUL)
+		{
+		    if (i < len - 1 && (i == 0 || buf[i - 1] != ':'))
+			buf[i++] = '/';
+		    vim_strncpy(buf + i, fname, len - i - 1);
+		}
+	    }
+	}
+    }
+    if (*buf == 0 || *buf == ':')
+	retval = FAIL;	// something failed; use the file name
+    return retval;
+}
+
+/*
+ * Return TRUE if "fname" does not depend on the current directory.
+ */
+    int
+mch_isFullName(char_u *fname)
+{
+    return (vim_strchr(fname, ':') != NULL && *fname != ':');
+}
+
+/*
+ * Get the full file name from a lock. Use 2.0 function if possible, because
+ * the arp function has more restrictions on the path length.
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    static int
+lock2name(BPTR lock, char_u *buf, long len)
+{
+#ifdef FEAT_ARP
+    if (dos2)		    // use 2.0 function
+#endif
+	return ((int)NameFromLock(lock, (UBYTE *)buf, len) ? OK : FAIL);
+#ifdef FEAT_ARP
+    else		// use arp function
+	return ((int)PathName(lock, (char *)buf, (long)(len/32)) ? OK : FAIL);
+#endif
+}
+
+/*
+ * get file permissions for 'name'
+ * Returns -1 when it doesn't exist.
+ */
+    long
+mch_getperm(char_u *name)
+{
+    struct FileInfoBlock    *fib;
+    long		    retval = -1;
+
+    fib = get_fib(name);
+    if (fib == NULL)
+	return -1;
+
+    retval = fib->fib_Protection;
+    free_fib(fib);
+    return retval;
+}
+
+/*
+ * set file permission for 'name' to 'perm'
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+mch_setperm(char_u *name, long perm)
+{
+    perm &= ~FIBF_ARCHIVE;		// reset archived bit
+    return (SetProtection((UBYTE *)name, (long)perm) ? OK : FAIL);
+}
+
+/*
+ * Set hidden flag for "name".
+ */
+    void
+mch_hide(char_u *name UNUSED)
+{
+    // can't hide a file
+}
+
+/*
+ * return FALSE if "name" is not a directory
+ * return TRUE if "name" is a directory.
+ * return FALSE for error.
+ */
+    int
+mch_isdir(char_u *name)
+{
+    struct FileInfoBlock    *fib;
+    int			    retval = FALSE;
+
+    fib = get_fib(name);
+    if (fib == NULL)
+	return FALSE;
+
+#ifdef __amigaos4__
+    retval = (FIB_IS_DRAWER(fib)) ? TRUE : FALSE;
+#else
+    retval = ((fib->fib_DirEntryType >= 0) ? TRUE : FALSE);
+#endif
+    free_fib(fib);
+    return retval;
+}
+
+/*
+ * Create directory "name".
+ */
+    int
+mch_mkdir(char_u *name)
+{
+    BPTR	lock;
+
+    lock = CreateDir(name);
+    if (lock == NULL)
+	return -1;
+
+    UnLock(lock);
+    return 0;
+}
+
+/*
+ * Return 1 if "name" can be executed, 0 if not.
+ * If "use_path" is FALSE only check if "name" is executable.
+ * Return -1 if unknown.
+ */
+    int
+mch_can_exe(char_u *name, char_u **path UNUSED, int use_path)
+{
+    int exe = -1;
+#ifdef __amigaos4__
+    // Load file sections using elf.library or hunk.library.
+    BPTR seg = LoadSeg(name);
+
+    if (seg && GetSegListInfoTags(seg, GSLI_Native, NULL, TAG_DONE) !=
+	    GetSegListInfoTags(seg, GSLI_68KHUNK, NULL, TAG_DONE))
+    {
+	// Test if file permissions allow execution.
+	struct ExamineData *exd = ExamineObjectTags(EX_StringNameInput, name);
+
+	exe = (exd && !(exd->Protection & EXDF_NO_EXECUTE)) ? 1 : 0;
+	FreeDosObject(DOS_EXAMINEDATA, exd);
+    }
+    else
+    {
+	exe = 0;
+    }
+
+    UnLoadSeg(seg);
+
+    // Search for executable in path if applicable.
+    if (!exe && use_path)
+    {
+	// Save current working dir.
+	BPTR cwd = GetCurrentDir();
+	struct PathNode *head = DupCmdPathList(NULL);
+
+	// For each entry, recur to check for executable.
+	for(struct PathNode *tail = head; !exe && tail;
+		tail = (struct PathNode *) BADDR(tail->pn_Next))
+	{
+	    SetCurrentDir(tail->pn_Lock);
+	    exe = mch_can_exe(name, path, 0);
+	}
+
+	// Go back to where we were.
+	FreeCmdPathList(head);
+	SetCurrentDir(cwd);
+    }
+#endif
+    return exe;
+}
+
+/*
+ * Check what "name" is:
+ * NODE_NORMAL: file or directory (or doesn't exist)
+ * NODE_WRITABLE: writable device, socket, fifo, etc.
+ * NODE_OTHER: non-writable things
+ */
+    int
+mch_nodetype(char_u *name UNUSED)
+{
+    // TODO
+    return NODE_NORMAL;
+}
+
+    void
+mch_early_init(void)
+{
+}
+
+/*
+ * Careful: mch_exit() may be called before mch_init()!
+ */
+    void
+mch_exit(int r)
+{
+    exiting = TRUE;
+
+    if (raw_in)			    // put terminal in 'normal' mode
+    {
+	settmode(TMODE_COOK);
+	stoptermcap();
+    }
+    out_char('\n');
+    if (raw_out)
+    {
+	if (term_console)
+	{
+	    win_resize_off();	    // window resize events de-activated
+	    if (size_set)
+		OUT_STR("\233t\233u");	// reset window size (CSI t CSI u)
+	}
+	out_flush();
+    }
+
+    mch_restore_title(SAVE_RESTORE_BOTH);    // restore window title
+
+    ml_close_all(TRUE);		    // remove all memfiles
+
+#ifdef FEAT_ARP
+    if (ArpBase)
+	CloseLibrary((struct Library *) ArpBase);
+#endif
+    if (close_win)
+	Close(raw_in);
+    if (r)
+	printf(_("Vim exiting with %d\n"), r); // somehow this makes :cq work!?
+    exit(r);
+}
+
+/*
+ * This is a routine for setting a given stream to raw or cooked mode on the
+ * Amiga . This is useful when you are using Lattice C to produce programs
+ * that want to read single characters with the "getch()" or "fgetc" call.
+ *
+ * Written : 18-Jun-87 By Chuck McManis.
+ */
+
+#define MP(xx)	((struct MsgPort *)((struct FileHandle *) (BADDR(xx)))->fh_Type)
+
+/*
+ * Function mch_settmode() - Convert the specified file pointer to 'raw' or
+ * 'cooked' mode. This only works on TTY's.
+ *
+ * Raw: keeps DOS from translating keys for you, also (BIG WIN) it means
+ *	getch() will return immediately rather than wait for a return. You
+ *	lose editing features though.
+ *
+ * Cooked: This function returns the designate file pointer to its normal,
+ *	wait for a <CR> mode. This is exactly like raw() except that
+ *	it sends a 0 to the console to make it back into a CON: from a RAW:
+ */
+    void
+mch_settmode(tmode_T tmode)
+{
+#if defined(__AROS__) || defined(__amigaos4__) || defined(__MORPHOS__)
+    if (!SetMode(raw_in, tmode == TMODE_RAW ? 1 : 0))
+#else
+    if (dos_packet(MP(raw_in), (long)ACTION_SCREEN_MODE,
+					  tmode == TMODE_RAW ? -1L : 0L) == 0)
+#endif
+	mch_errmsg(_("cannot change console mode ?!\n"));
+}
+
+/*
+ * Code for this routine came from the following :
+ *
+ * ConPackets.c -  C. Scheppner, A. Finkel, P. Lindsay	CBM
+ *   DOS packet example
+ *   Requires 1.2
+ *
+ * Found on Fish Disk 56.
+ *
+ * Heavely modified by mool.
+ */
+
+#ifndef PROTO
+# include <devices/conunit.h>
+#endif
+
+/*
+ * Get console size in a system friendly way on AROS and MorphOS.
+ * Return FAIL for failure, OK otherwise
+ */
+#if defined(__AROS__) || defined(__MORPHOS__)
+    int
+mch_get_shellsize(void)
+{
+    if (!term_console)
+	return FAIL;
+
+    if (raw_in && raw_out)
+    {
+	// Save current console mode.
+	int old_tmode = cur_tmode;
+	char ctrl[] = "\x9b""0 q";
+
+	// Set RAW mode.
+	mch_settmode(TMODE_RAW);
+
+	// Write control sequence to console.
+	if (Write(raw_out, ctrl, sizeof(ctrl)) == sizeof(ctrl))
+	{
+	    char scan[] = "\x9b""1;1;%d;%d r",
+		 answ[sizeof(scan) + 8] = { '\0' };
+
+	    // Read return sequence from input.
+	    if (Read(raw_in, answ, sizeof(answ) - 1) > 0)
+	    {
+		// Parse result and set Vim globals.
+		if (sscanf(answ, scan, &Rows, &Columns) == 2)
+		{
+		    // Restore console mode.
+		    mch_settmode(old_tmode);
+		    return OK;
+		}
+	    }
+	}
+
+	// Restore console mode.
+	mch_settmode(old_tmode);
+    }
+
+    // I/O error. Default size fallback.
+    term_console = FALSE;
+    Columns = 80;
+    Rows = 24;
+
+    return FAIL;
+}
+#else
+/*
+ * Try to get the real window size,
+ * return FAIL for failure, OK otherwise
+ */
+    int
+mch_get_shellsize(void)
+{
+    struct ConUnit  *conUnit;
+#ifndef __amigaos4__
+    char	    id_a[sizeof(struct InfoData) + 3];
+#endif
+    struct InfoData *id=0;
+
+    if (!term_console)	// not an amiga window
+	goto out;
+
+    // insure longword alignment
+#ifdef __amigaos4__
+    if (!(id = AllocDosObject(DOS_INFODATA, 0)))
+	goto out;
+#else
+    id = (struct InfoData *)(((long)id_a + 3L) & ~3L);
+#endif
+
+    /*
+     * Should make console aware of real window size, not the one we set.
+     * Unfortunately, under DOS 2.0x this redraws the window and it
+     * is rarely needed, so we skip it now, unless we changed the size.
+     */
+    if (size_set)
+	OUT_STR("\233t\233u");	// CSI t CSI u
+    out_flush();
+
+    if (dos_packet(MP(raw_out), (long)ACTION_DISK_INFO, ((ULONG) id) >> 2) == 0
+	    || (wb_window = (struct Window *)id->id_VolumeNode) == NULL)
+    {
+	// it's not an amiga window, maybe aux device
+	// terminal type should be set
+	term_console = FALSE;
+	goto out;
+    }
+    if (oldwindowtitle == NULL)
+	oldwindowtitle = (char_u *)wb_window->Title;
+    if (id->id_InUse == (BPTR)NULL)
+    {
+	mch_errmsg(_("mch_get_shellsize: not a console??\n"));
+	return FAIL;
+    }
+    conUnit = (struct ConUnit *) ((struct IOStdReq *) id->id_InUse)->io_Unit;
+
+    // get window size
+    Rows = conUnit->cu_YMax + 1;
+    Columns = conUnit->cu_XMax + 1;
+    if (Rows < 0 || Rows > 200)	    // cannot be an amiga window
+    {
+	Columns = 80;
+	Rows = 24;
+	term_console = FALSE;
+	return FAIL;
+    }
+
+    return OK;
+out:
+#ifdef __amigaos4__
+    FreeDosObject(DOS_INFODATA, id); // Safe to pass NULL
+#endif
+
+    return FAIL;
+}
+#endif
+
+/*
+ * Try to set the real window size to Rows and Columns.
+ */
+    void
+mch_set_shellsize(void)
+{
+    if (!term_console)
+	return;
+
+    size_set = TRUE;
+    out_char(CSI);
+    out_num((long)Rows);
+    out_char('t');
+    out_char(CSI);
+    out_num((long)Columns);
+    out_char('u');
+    out_flush();
+}
+
+/*
+ * Rows and/or Columns has changed.
+ */
+    void
+mch_new_shellsize(void)
+{
+    // Nothing to do.
+}
+
+/*
+ * out_num - output a (big) number fast
+ */
+    static void
+out_num(long n)
+{
+    OUT_STR_NF(tltoa((unsigned long)n));
+}
+
+#if !defined(AZTEC_C) && !defined(__AROS__) && !defined(__amigaos4__)
+/*
+ * Sendpacket.c
+ *
+ * An invaluable addition to your Amiga.lib file. This code sends a packet to
+ * the given message port. This makes working around DOS lots easier.
+ *
+ * Note, I didn't write this, those wonderful folks at CBM did. I do suggest
+ * however that you may wish to add it to Amiga.Lib, to do so, compile it and
+ * say 'oml lib:amiga.lib -r sendpacket.o'
+ */
+
+#ifndef PROTO
+// #include <proto/exec.h>
+// #include <proto/dos.h>
+# include <exec/memory.h>
+#endif
+
+/*
+ * Function - dos_packet written by Phil Lindsay, Carolyn Scheppner, and Andy
+ * Finkel. This function will send a packet of the given type to the Message
+ * Port supplied.
+ */
+
+    static long
+dos_packet(
+    struct MsgPort *pid,    // process identifier ... (handlers message port)
+    long	    action, // packet type ... (what you want handler to do)
+    long	    arg)    // single argument
+{
+# ifdef FEAT_ARP
+    struct MsgPort	    *replyport;
+    struct StandardPacket   *packet;
+    long		    res1;
+
+    if (dos2)
+# endif
+	return DoPkt(pid, action, arg, 0L, 0L, 0L, 0L);	// use 2.0 function
+# ifdef FEAT_ARP
+
+    replyport = (struct MsgPort *) CreatePort(NULL, 0);	// use arp function
+    if (!replyport)
+	return (0);
+
+    // Allocate space for a packet, make it public and clear it
+    packet = (struct StandardPacket *)
+	AllocMem((long) sizeof(struct StandardPacket), MEMF_PUBLIC | MEMF_CLEAR);
+    if (!packet)
+    {
+	DeletePort(replyport);
+	return (0);
+    }
+    packet->sp_Msg.mn_Node.ln_Name = (char *) &(packet->sp_Pkt);
+    packet->sp_Pkt.dp_Link = &(packet->sp_Msg);
+    packet->sp_Pkt.dp_Port = replyport;
+    packet->sp_Pkt.dp_Type = action;
+    packet->sp_Pkt.dp_Arg1 = arg;
+
+    PutMsg(pid, (struct Message *)packet);	// send packet
+
+    WaitPort(replyport);
+    GetMsg(replyport);
+
+    res1 = packet->sp_Pkt.dp_Res1;
+
+    FreeMem(packet, (long) sizeof(struct StandardPacket));
+    DeletePort(replyport);
+
+    return (res1);
+# endif
+}
+#endif // !defined(AZTEC_C) && !defined(__AROS__)
+
+/*
+ * Call shell.
+ * Return error number for failure, 0 otherwise
+ */
+    int
+mch_call_shell(
+    char_u	*cmd,
+    int		options)	// SHELL_*, see vim.h
+{
+    BPTR	mydir;
+    int		x;
+    int		tmode = cur_tmode;
+#ifdef AZTEC_C
+    int		use_execute;
+    char_u	*shellcmd = NULL;
+    char_u	*shellarg;
+#endif
+    int		retval = 0;
+
+    if (close_win)
+    {
+	// if Vim opened a window: Executing a shell may cause crashes
+	emsg(_(e_cannot_execute_shell_with_f_option));
+	return -1;
+    }
+
+    if (term_console)
+	win_resize_off();	    // window resize events de-activated
+    out_flush();
+
+    if (options & SHELL_COOKED)
+	settmode(TMODE_COOK);	    // set to normal mode
+    mydir = Lock((UBYTE *)"", (long)ACCESS_READ);   // remember current dir
+
+#if !defined(AZTEC_C)		    // not tested very much
+    if (cmd == NULL)
+    {
+# ifdef FEAT_ARP
+	if (dos2)
+# endif
+	    x = SystemTags(p_sh, SYS_UserShell, TRUE, TAG_DONE);
+# ifdef FEAT_ARP
+	else
+	    x = Execute(p_sh, raw_in, raw_out);
+# endif
+    }
+    else
+    {
+# ifdef FEAT_ARP
+	if (dos2)
+# endif
+	    x = SystemTags((char *)cmd, SYS_UserShell, TRUE, TAG_DONE);
+# ifdef FEAT_ARP
+	else
+	    x = Execute((char *)cmd, 0L, raw_out);
+# endif
+    }
+# ifdef FEAT_ARP
+    if ((dos2 && x < 0) || (!dos2 && !x))
+# else
+    if (x < 0)
+# endif
+    {
+	msg_puts(_("Cannot execute "));
+	if (cmd == NULL)
+	{
+	    msg_puts(_("shell "));
+	    msg_outtrans(p_sh);
+	}
+	else
+	    msg_outtrans(cmd);
+	msg_putchar('\n');
+	retval = -1;
+    }
+# ifdef FEAT_ARP
+    else if (!dos2 || x)
+# else
+    else if (x)
+# endif
+    {
+	if ((x = IoErr()) != 0)
+	{
+	    if (!(options & SHELL_SILENT))
+	    {
+		msg_putchar('\n');
+		msg_outnum((long)x);
+		msg_puts(_(" returned\n"));
+	    }
+	    retval = x;
+	}
+    }
+#else	// else part is for AZTEC_C
+    if (p_st >= 4 || (p_st >= 2 && !(options & SHELL_FILTER)))
+	use_execute = 1;
+    else
+	use_execute = 0;
+    if (!use_execute)
+    {
+	/*
+	 * separate shell name from argument
+	 */
+	shellcmd = vim_strsave(p_sh);
+	if (shellcmd == NULL)	    // out of memory, use Execute
+	    use_execute = 1;
+	else
+	{
+	    shellarg = skiptowhite(shellcmd);	// find start of arguments
+	    if (*shellarg != NUL)
+	    {
+		*shellarg++ = NUL;
+		shellarg = skipwhite(shellarg);
+	    }
+	}
+    }
+    if (cmd == NULL)
+    {
+	if (use_execute)
+	{
+# ifdef FEAT_ARP
+	    if (dos2)
+# endif
+		x = SystemTags((UBYTE *)p_sh, SYS_UserShell, TRUE, TAG_DONE);
+# ifdef FEAT_ARP
+	    else
+		x = !Execute((UBYTE *)p_sh, raw_in, raw_out);
+# endif
+	}
+	else
+	    x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg, NULL);
+    }
+    else if (use_execute)
+    {
+# ifdef FEAT_ARP
+	if (dos2)
+# endif
+	    x = SystemTags((UBYTE *)cmd, SYS_UserShell, TRUE, TAG_DONE);
+# ifdef FEAT_ARP
+	else
+	    x = !Execute((UBYTE *)cmd, 0L, raw_out);
+# endif
+    }
+    else if (p_st & 1)
+	x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg,
+							   (char *)cmd, NULL);
+    else
+	x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg,
+					   (char *)p_shcf, (char *)cmd, NULL);
+# ifdef FEAT_ARP
+    if ((dos2 && x < 0) || (!dos2 && x))
+# else
+    if (x < 0)
+# endif
+    {
+	msg_puts(_("Cannot execute "));
+	if (use_execute)
+	{
+	    if (cmd == NULL)
+		msg_outtrans(p_sh);
+	    else
+		msg_outtrans(cmd);
+	}
+	else
+	{
+	    msg_puts(_("shell "));
+	    msg_outtrans(shellcmd);
+	}
+	msg_putchar('\n');
+	retval = -1;
+    }
+    else
+    {
+	if (use_execute)
+	{
+# ifdef FEAT_ARP
+	    if (!dos2 || x)
+# else
+	    if (x)
+# endif
+		x = IoErr();
+	}
+	else
+	    x = wait();
+	if (x)
+	{
+	    if (!(options & SHELL_SILENT) && !emsg_silent)
+	    {
+		msg_putchar('\n');
+		msg_outnum((long)x);
+		msg_puts(_(" returned\n"));
+	    }
+	    retval = x;
+	}
+    }
+    vim_free(shellcmd);
+#endif	// AZTEC_C
+
+    if ((mydir = CurrentDir(mydir)) != 0) // make sure we stay in the same directory
+	UnLock(mydir);
+    if (tmode == TMODE_RAW)
+    {
+	// The shell may have messed with the mode, always set it.
+	cur_tmode = TMODE_UNKNOWN;
+	settmode(TMODE_RAW);		// set to raw mode
+    }
+    resettitle();
+    if (term_console)
+	win_resize_on();		// window resize events activated
+    return retval;
+}
+
+/*
+ * check for an "interrupt signal"
+ * We only react to a CTRL-C, but also clear the other break signals to avoid
+ * trouble with lattice-c programs.
+ */
+    void
+mch_breakcheck(int force UNUSED)
+{
+   if (SetSignal(0L, (long)(SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D|SIGBREAKF_CTRL_E|SIGBREAKF_CTRL_F)) & SIGBREAKF_CTRL_C)
+	got_int = TRUE;
+}
+
+// this routine causes manx to use this Chk_Abort() rather than its own
+// otherwise it resets our ^C when doing any I/O (even when Enable_Abort
+// is zero).  Since we want to check for our own ^C's
+
+#ifdef _DCC
+#define Chk_Abort chkabort
+#endif
+
+#ifdef LATTICE
+void __regargs __chkabort(void);
+
+void __regargs __chkabort(void)
+{}
+
+#else
+    long
+Chk_Abort(void)
+{
+    return(0L);
+}
+#endif
+
+/*
+ * mch_expandpath() - this code does wild-card pattern matching using the arp
+ *		      routines.
+ *
+ * "pat" has backslashes before chars that are not to be expanded.
+ * Returns the number of matches found.
+ *
+ * This is based on WildDemo2.c (found in arp1.1 distribution).
+ * That code's copyright follows:
+ *	Copyright (c) 1987, Scott Ballantyne
+ *	Use and abuse as you please.
+ */
+
+#ifdef __amigaos4__
+# define	ANCHOR_BUF_SIZE	1024
+#else
+# define ANCHOR_BUF_SIZE (512)
+# define ANCHOR_SIZE (sizeof(struct AnchorPath) + ANCHOR_BUF_SIZE)
+#endif
+
+    int
+mch_expandpath(
+    garray_T	*gap,
+    char_u	*pat,
+    int		flags)		// EW_* flags
+{
+    struct AnchorPath	*Anchor;
+    LONG		Result;
+    char_u		*starbuf, *sp, *dp;
+    int			start_len;
+    int			matches;
+#ifdef __amigaos4__
+    struct TagItem	AnchorTags[] = {
+	{ADO_Strlen, ANCHOR_BUF_SIZE},
+	{ADO_Flags, APF_DODOT|APF_DOWILD|APF_MultiAssigns},
+	{TAG_DONE, 0L}
+    };
+#endif
+
+    start_len = gap->ga_len;
+
+    // Get our AnchorBase
+#ifdef __amigaos4__
+    Anchor = AllocDosObject(DOS_ANCHORPATH, AnchorTags);
+#else
+    Anchor = alloc_clear(ANCHOR_SIZE);
+#endif
+    if (Anchor == NULL)
+	return 0;
+
+#ifndef __amigaos4__
+    Anchor->ap_Strlen = ANCHOR_BUF_SIZE;  // ap_Length not supported anymore
+# ifdef APF_DODOT
+    Anchor->ap_Flags = APF_DODOT | APF_DOWILD;	// allow '.' for current dir
+# else
+    Anchor->ap_Flags = APF_DoDot | APF_DoWild;	// allow '.' for current dir
+# endif
+#endif
+
+#ifdef FEAT_ARP
+    if (dos2)
+    {
+#endif
+	// hack to replace '*' by '#?'
+	starbuf = alloc(2 * STRLEN(pat) + 1);
+	if (starbuf == NULL)
+	    goto Return;
+	for (sp = pat, dp = starbuf; *sp; ++sp)
+	{
+	    if (*sp == '*')
+	    {
+		*dp++ = '#';
+		*dp++ = '?';
+	    }
+	    else
+		*dp++ = *sp;
+	}
+	*dp = NUL;
+	Result = MatchFirst((UBYTE *)starbuf, Anchor);
+	vim_free(starbuf);
+#ifdef FEAT_ARP
+    }
+    else
+	Result = FindFirst((char *)pat, Anchor);
+#endif
+
+    /*
+     * Loop to get all matches.
+     */
+    while (Result == 0)
+    {
+#ifdef __amigaos4__
+	addfile(gap, (char_u *)Anchor->ap_Buffer, flags);
+#else
+	addfile(gap, (char_u *)Anchor->ap_Buf, flags);
+#endif
+#ifdef FEAT_ARP
+	if (dos2)
+#endif
+	    Result = MatchNext(Anchor);
+#ifdef FEAT_ARP
+	else
+	    Result = FindNext(Anchor);
+#endif
+    }
+    matches = gap->ga_len - start_len;
+
+    if (Result == ERROR_BUFFER_OVERFLOW)
+	emsg(_("ANCHOR_BUF_SIZE too small."));
+    else if (matches == 0 && Result != ERROR_OBJECT_NOT_FOUND
+			  && Result != ERROR_DEVICE_NOT_MOUNTED
+			  && Result != ERROR_NO_MORE_ENTRIES)
+	emsg(_("I/O ERROR"));
+
+    /*
+     * Sort the files for this pattern.
+     */
+    if (matches)
+	qsort((void *)(((char_u **)gap->ga_data) + start_len),
+				  (size_t)matches, sizeof(char_u *), sortcmp);
+
+    // Free the wildcard stuff
+#ifdef FEAT_ARP
+    if (dos2)
+#endif
+	MatchEnd(Anchor);
+#ifdef FEAT_ARP
+    else
+	FreeAnchorChain(Anchor);
+#endif
+
+Return:
+#ifdef __amigaos4__
+    FreeDosObject(DOS_ANCHORPATH, Anchor);
+#else
+    vim_free(Anchor);
+#endif
+
+    return matches;
+}
+
+    static int
+sortcmp(const void *a, const void *b)
+{
+    char *s = *(char **)a;
+    char *t = *(char **)b;
+
+    return pathcmp(s, t, -1);
+}
+
+/*
+ * Return TRUE if "p" has wildcards that can be expanded by mch_expandpath().
+ */
+    int
+mch_has_exp_wildcard(char_u *p)
+{
+    for ( ; *p; MB_PTR_ADV(p))
+    {
+	if (*p == '\\' && p[1] != NUL)
+	    ++p;
+	else if (vim_strchr((char_u *)"*?[(#", *p) != NULL)
+	    return TRUE;
+    }
+    return FALSE;
+}
+
+    int
+mch_has_wildcard(char_u *p)
+{
+    for ( ; *p; MB_PTR_ADV(p))
+    {
+	if (*p == '\\' && p[1] != NUL)
+	    ++p;
+	else
+	    if (vim_strchr((char_u *)
+#  ifdef VIM_BACKTICK
+				    "*?[(#$`"
+#  else
+				    "*?[(#$"
+#  endif
+						, *p) != NULL
+		    || (*p == '~' && p[1] != NUL))
+		return TRUE;
+    }
+    return FALSE;
+}
+
+/*
+ * With AmigaDOS 2.0 support for reading local environment variables
+ *
+ * Two buffers are allocated:
+ * - A big one to do the expansion into.  It is freed before returning.
+ * - A small one to hold the return value.  It is kept until the next call.
+ */
+    char_u *
+mch_getenv(char_u *var)
+{
+    int		    len;
+    UBYTE	    *buf;		// buffer to expand in
+    char_u	    *retval;		// return value
+    static char_u   *alloced = NULL;	// allocated memory
+
+#ifdef FEAT_ARP
+    if (!dos2)
+	retval = (char_u *)getenv((char *)var);
+    else
+#endif
+    {
+	VIM_CLEAR(alloced);
+	retval = NULL;
+
+	buf = alloc(IOSIZE);
+	if (buf == NULL)
+	    return NULL;
+
+	len = GetVar((UBYTE *)var, buf, (long)(IOSIZE - 1), (long)0);
+	if (len >= 0)
+	{
+	    retval = vim_strsave((char_u *)buf);
+	    alloced = retval;
+	}
+
+	vim_free(buf);
+    }
+
+    // if $VIM is not defined, use "vim:" instead
+    if (retval == NULL && STRCMP(var, "VIM") == 0)
+	retval = (char_u *)"vim:";
+
+    return retval;
+}
+
+/*
+ * Amiga version of setenv() with AmigaDOS 2.0 support.
+ */
+// ARGSUSED
+    int
+mch_setenv(char *var, char *value, int x UNUSED)
+{
+#ifdef FEAT_ARP
+    if (!dos2)
+	return setenv(var, value);
+#endif
+
+    if (SetVar((UBYTE *)var, (UBYTE *)value, (LONG)-1, (ULONG)GVF_LOCAL_ONLY))
+	return 0;   // success
+    return -1;	    // failure
+}