diff options
Diffstat (limited to 'src/os_riscos.c')
| -rw-r--r-- | src/os_riscos.c | 1288 |
1 files changed, 1288 insertions, 0 deletions
diff --git a/src/os_riscos.c b/src/os_riscos.c new file mode 100644 index 000000000..a1cdab403 --- /dev/null +++ b/src/os_riscos.c @@ -0,0 +1,1288 @@ +/* vi:set ts=8 sts=4 sw=4: + * + * 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. + */ + +#include "vim.h" + +/* + * os_riscos.c + * + * Thomas Leonard <tal197@ecs.soton.ac.uk> + */ + +const char *__dynamic_da_name = "Vim heap"; /* Enable and name our dynamic area */ +int ro_line_mode = TRUE; /* For Ex mode we much echo chars to the screen ourselves */ +int windowed; /* Flag - are we running inside a text window? */ +int WinLeft, WinTop; /* We might be started inside a text window */ +int ScrollTop; /* Make cursor movements relative to ScrollTop. */ + +int old_escape_state = -1; +int old_cursor_state = -1; + +#define rgb(r,g,b) ((b<<24) + (g<<16) + (r<<8)) +#define NORMAL_FG 0x00000000 +#define NORMAL_BG 0xffffffff + +/* Convert a DOS colour number to an RGB palette entry. + * Mappings from X11 rgb/txt file. + */ + static int +map_colour(dos) + int dos; /* Standard DOS colour number. */ +{ + switch (dos) + { + case 0: return 0; /* Black */ + case 1: return rgb(0,0,139); /* DarkBlue */ + case 2: return rgb(0,100,0); /* DarkGreen */ + case 3: return rgb(0,139,139); /* DarkCyan */ + case 4: return rgb(139,0,0); /* DarkRed */ + case 5: return rgb(139,0,139); /* DarkMagenta */ + case 6: return rgb(165,42,42); /* Brown, DarkYellow */ + case 7: return rgb(211,211,211); /* LightGray, LightGrey, Gray, Grey */ + case 8: return rgb(169,169,169); /* DarkGray, DarkGrey */ + case 9: return rgb(173,216,230); /* Blue, LightBlue */ + case 10: return rgb(144,238,144); /* Green, LightGreen */ + case 11: return rgb(224,255,255); /* Cyan, LightCyan */ + case 12: return rgb(255,0,0); /* Red, LightRed */ + case 13: return rgb(255,0,255); /* Magenta, LightMagenta */ + case 14: return rgb(255,255,0); /* Yellow, LightYellow */ + case 15: return rgb(255,255,255); /* White */ + } + return rgb(100,100,100); +} + + static void +text_fg(fg) + int fg; /* Foregound colour in the form &BBGGRR00 */ +{ + xswi(ColourTrans_SetTextColour, fg, 0, 0, 0); +} + + static void +text_bg(bg) + int bg; /* Backgound colour in the form &BBGGRR00 */ +{ + xswi(ColourTrans_SetTextColour, bg, 0, 0, 1 << 7); +} + +#define OUT_NORMAL 0 +#define OUT_NUMBER 1 /* Reading in a number */ + + void +mch_write(s, len) + char_u *s; + int len; +{ + static int mode = OUT_NORMAL; + static int x, y; /* For reading numbers in. */ + + if (!term_console) + { + /* Maybe we are running Vim remotely - don't interpret chars */ + while (len--) + { + char_u c = *s++; + swi(OS_WriteC, c); + /* We might need to send a CR too. This shouldn't + * hurt if we don't need it, should it? + */ + if (c == 10) + swi(OS_WriteI + 13); + } + return; + } + + while (len--) + { + char_u c = *s++; + switch (mode) + { + case OUT_NUMBER: + if (c < '0' || c > '9') + { + mode = OUT_NORMAL; + } + else + { + x = (x * 10) + c - '0'; + continue; + } + /* note: no break here! */ + + case OUT_NORMAL: + switch (c) + { + case 1: + /* Number (in decimal) follows. */ + mode = OUT_NUMBER; + y = x; + x = 0; + break; + case 2: + /* Position cursor. */ + swi(OS_WriteI + 31); + swi(OS_WriteC, x); + swi(OS_WriteC, y - ScrollTop); + break; + case 3: + /* Set scroll region. */ + if (x == Rows -1 && y == 0 && !windowed) + { + /* Whole screen - remove text window. + * This is MUCH faster. + */ + swi(OS_WriteI + 26); + } + else + { + /* Create a text window. */ + swi(OS_WriteI + 28); + swi(OS_WriteC, WinLeft); + swi(OS_WriteC, WinTop + x); + swi(OS_WriteC, WinLeft + Columns - 1); + swi(OS_WriteC, WinTop + y); + } + ScrollTop = y; + break; + case 4: + /* Normal mode. */ + text_fg(NORMAL_FG); + text_bg(NORMAL_BG); + break; + case 5: + /* Reverse mode. */ + text_fg(NORMAL_BG); + text_bg(NORMAL_FG); + break; + case 10: + swi(OS_NewLine); + break; + case 14: + /* Cursor invisible. */ + swi(OS_WriteN, + "\027\001\000\000\000\000\000\000\000\000", + 10); + break; + case 15: + /* Cursor visible. */ + swi(OS_WriteN, + "\027\001\002\000\000\000\000\000\000\000", + 10); + break; + case 16: + /* Cursor very visible (flash) */ + swi(OS_WriteN, + "\027\001\003\000\000\000\000\000\000\000", + 10); + case 17: + /* Set foreground colour. */ + text_fg(map_colour(x)); + break; + case 18: + /* Set background colour. */ + text_bg(map_colour(x)); + break; + case 19: + /* Scroll text down. */ + swi(OS_WriteN, + "\027\007\000\002\000\000\000\000\000\000", + 10); + break; + default: + swi(OS_WriteC, c); + } + continue; + + default: + printf("[output error]"); + mode = OUT_NORMAL; + } + } +} + +/* + * mch_inchar(): low level input funcion. + * Get a characters from the keyboard. + * Return the number of characters that are available. + * If wtime == 0 do not wait for characters. + * If wtime == n wait n msecs for characters. + * If wtime == -1 wait forever for characters. + * + * TODO: call convert_input() for 'fileencoding' to 'encoding' conversion. + */ + int +mch_inchar(buf, maxlen, wtime, tb_change_cnt) + char_u *buf; + int maxlen; + long wtime; + int tb_change_cnt; +{ + int got=0; + unsigned int start_time = clock(); + + if (ro_line_mode) + { + /* We're probably in Ex mode - get whole lines at a time. */ + + static char_u line_buffer[256]; + static int remaining_chars = 0; + static int buf_pos = 0; + + /* Do we need to fetch another line? */ + if (remaining_chars == 0) + { + int old_esc_state; + swi(OS_Byte, 200, 1, 0xfe); + old_esc_state = r1; + + buf_pos = 0; + if (xswi(OS_ReadLine, line_buffer, 255, 0, 255) & (c_flag | v_flag)) + { + got_int = TRUE; /* ESC pressed */ + r1 = 0; + } + line_buffer[r1] = 13; + remaining_chars = r1 + 1; /* Count CR as part of input */ + + swi(OS_Byte, 200, old_esc_state, 0); + } + + /* Can we send the rest of the buffer back in one go? */ + if (remaining_chars <= maxlen) + { + int got = remaining_chars; + + memcpy(buf, line_buffer + buf_pos, got); + remaining_chars = 0; + return got; + } + + /* Send as much as we can */ + memcpy(buf, line_buffer + buf_pos, maxlen); + buf_pos += maxlen; + remaining_chars -= maxlen; + + return maxlen; + } + + if (!term_console) + { + /* Use OS_ReadC for all input. + * Avoids problems with remote access getting interference from + * the keyboard. + */ + if (wtime == 0) + return 0; /* Ignore quick key checks */ + + if (xswi(OS_ReadC) & c_flag) + { + got_int = TRUE; /* ESC pressed - can this happen? */ + swi(OS_Byte, 124); /* Clear Escape state */ + r0 = 0x1b; /* It *might* not have been Escape! */ + } + buf[0] = r0; + return 1; + } + + /* + * OK, here's the plan: + * + * 1) Wait until wtime expires or we get a key + * 2) Get keys until the keyboard buffer is empty or buf is full + */ + + while (xswi(OS_Byte,145,0) & c_flag) + { + /* Nothing at all in the keyboard buffer. + * Has our time expired yet? + */ + if ( (wtime != -1) && (clock() - start_time) >= wtime ) + return 0; /* Nothing read - giving up */ + } + + /* We've got one char (in r2) - are there any more? */ + + while (got < maxlen) + { + buf[got++] = r2; + + if (xswi(OS_Byte,145,0) & c_flag) + return got; /* Keyboard buffer empty */ + } + return got; /* buf is full */ +} + +/* + * return non-zero if a character is available + */ + int +mch_char_avail() +{ + if (!term_console) + return 0; /* Can't tell */ + if (xswi(OS_Byte, 152, 0) & c_flag) + return 0; + return 1; +} + +/* Find out how much free memory we have. + * I don't know how to work this out exactly but, since we can claim + * more memory from the OS, let's just report the free pool size. + * Dynamic area 6 doesn't exist pre 3.6 according to StrongHelp, so + * we'll use Wimp_SlotSize. If that fails (outside the desktop?) + * then just return a big number and hope. + */ + long_u +mch_avail_mem(special) + int special; +{ + if (xswi(Wimp_SlotSize, -1, -1) & v_flag) + return 0x7fffffff; + return r2; +} + + void +mch_delay(msec, ignoreinput) + long msec; + int ignoreinput; +{ + int start_time, time_now; + int csec = msec / 10; + + swi(OS_ReadMonotonicTime); + start_time = r0; + + for (;;) + { + swi(OS_ReadMonotonicTime); + time_now = r0; + if (time_now - start_time > csec) + return; +#ifdef FEAT_GUI + /* In the GUI, allow other programs to run while waiting. */ + if (gui.in_use) + gui_mch_wait_for_chars(start_time + csec); +#endif + } +} + +/* + * If the machine has job control, use it to suspend the program, + * otherwise fake it by starting a new shell. + */ + void +mch_suspend() +{ + suspend_shell(); +} + + void +mch_init() +{ + /* + * Read window size first. Calls to mch_get_shellsize() will + * simply return these values in future so that setting the + * text window (used for scrolling) won't give strange results. + */ + + int buf[7] = {132, 135, 256, 257, 1, 2, -1}; + + /* Command windows are no longer forced open, since if we are + * in the desktop then we'll use the GUI version. + * Opening a command window here messes up the GUI version startup + */ +#ifndef FEAT_GUI + swi(OS_WriteI); +#endif + swi(OS_ReadVduVariables, buf, buf); + WinLeft = buf[0]; + WinTop = buf[1]; + Columns = buf[2]; + Rows = buf[3] + 1; /* Seems to be one off (VduVars wrong?) */ + ScrollTop = 0; + + /* Are we running in a textwindow? */ + if (Rows == buf[5] + 1 && Columns == buf[4] + 1) + windowed = 0; + else + windowed = 1; + + /* Choose a nice colour scheme. */ + text_fg(NORMAL_FG); + text_bg(NORMAL_BG); +} + +/* + * Check_win checks whether we have an interactive stdout. + */ +/* ARGSUSED */ + int +mch_check_win(argc, argv) + int argc; + char **argv; +{ + return OK; +} + +/* + * Return TRUE if the input comes from a terminal, FALSE otherwise. + */ + int +mch_input_isatty() +{ + if (xswi(OS_ChangeRedirection, -1, -1) & v_flag) + return TRUE; /* Error - TRUE is probably correct though */ + if (r0 == 0) + return TRUE; + return FALSE; +} + +#ifdef FEAT_TITLE + int +mch_can_restore_title() +{ + return FALSE; +} + + int +mch_can_restore_icon() +{ + return FALSE; +} + + +/* + * Set the window title and icon. + */ + void +mch_settitle(title, icon) + char_u *title; + char_u *icon; +{ + if (title == NULL) + title = (char_u *) "<untitled>"; +#ifdef FEAT_GUI + if (gui.in_use && strcmp(title, gui.window_title)) + { + int length; + length = strlen(title); + if (length >= gui.window_title_size) + length = gui.window_title_size - 1; + strncpy(gui.window_title, title, length); + gui.window_title[length] = 0; + ro_redraw_title(gui.window_handle); + } +#endif + return; +} + +/* + * Restore the window/icon title. + * "which" is one of: + * 1 only restore title + * 2 only restore icon + * 3 restore title and icon + */ + void +mch_restore_title(which) + int which; +{ + return; +} +#endif + +/* + * Insert user name in s[len]. + * Return OK if a name found. + */ + int +mch_get_user_name(s, len) + char_u *s; + int len; +{ + /* RISC OS doesn't support user names. */ + *s = NUL; + return FAIL; +} + +/* + * Insert host name in s[len]. + */ + + void +mch_get_host_name(s, len) + char_u *s; + int len; +{ + if (xswi(OS_ReadVarVal, "Machine$Name", s, len, 0, 3) & v_flag) + { + /* Variable does not exist (normal operation) */ + STRNCPY(s, "(unknown)", len); + } +} + +/* + * return process ID + */ + long +mch_get_pid() +{ + if (xswi(Wimp_ReadSysInfo, 5) & v_flag) + return 0; + return r0; +} + +/* + * Get name of current directory into buffer 'buf' of length 'len' bytes. + * Return OK for success, FAIL for failure. + */ + int +mch_dirname(buf, len) + char_u *buf; + int len; +{ + if (xswi(OS_FSControl, 37, "@", buf, 0, 0, len) & v_flag) + return FAIL; + return OK; +} + +/* + * Get absolute file name into buffer 'buf' of length 'len' bytes. + * + * return FAIL for failure, OK for success + */ + int +mch_FullName(fname, buf, len, force) + char_u *fname, *buf; + int len; + int force; /* Also expand when already absolute path name. + * Not used under RISC OS. + */ +{ + if (xswi(OS_FSControl, 37, fname, buf, 0, 0, len) & v_flag) + return FAIL; + return OK; +} + +/* + * Return TRUE if "fname" does not depend on the current directory. + */ + int +mch_isFullName(fname) + char_u *fname; +{ + if (strstr(fname, "::") && strstr(fname,".$.")) + return TRUE; + return FALSE; +} + +/* + * Get file permissions for 'name'. + * Returns -1 when it doesn't exist. + */ + long +mch_getperm(name) + char_u *name; +{ + struct stat statb; + + if (stat((char *)name, &statb)) + return -1; + return statb.st_mode; +} + +/* + * set file permission for 'name' to 'perm' + * + * return FAIL for failure, OK otherwise + */ + int +mch_setperm(name, perm) + char_u *name; + long perm; +{ + return (chmod((char *)name, (mode_t)perm) == 0 ? OK : FAIL); +} + +/* + * Set hidden flag for "name". + */ +/* ARGSUSED */ + void +mch_hide(name) + char_u *name; +{ + /* can't hide a file */ +} + +/* + * return TRUE if "name" is a directory + * return FALSE if "name" is not a directory + * return FALSE for error + */ + int +mch_isdir(name) + char_u *name; +{ + if (xswi(OS_File, 17, name) & v_flag) + return FALSE; + if (r0 == 2 || r0 == 3) + return TRUE; /* Count image files as directories. */ + return FALSE; +} + +#if defined(FEAT_EVAL) || defined(PROTO) +/* + * Return 1 if "name" can be executed, 0 if not. + * Return -1 if unknown. Requires which to work. + */ + int +mch_can_exe(name) + char_u *name; +{ + char_u *buf; + char_u *p; + int retval; + + buf = alloc((unsigned)STRLEN(name) + 7); + if (buf == NULL) + return -1; + sprintf((char *)buf, "which %s", name); + p = get_cmd_output(buf, SHELL_SILENT); + vim_free(buf); + if (p == NULL) + return -1; + /* result can be: "name: Command not found" */ + retval = (*p != NUL && strstr((char *)p, "not found") == NULL); + vim_free(p); + return retval; +} +#endif + +/* + * 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(name) + char_u *name; +{ + /* TODO */ + return NODE_NORMAL; +} + + void +mch_early_init() +{ + /* Turn off all the horrible filename munging in UnixLib. */ + __riscosify_control = __RISCOSIFY_NO_PROCESS; +} + + void +mch_exit(r) + int r; +{ + settmode(TMODE_COOK); + exiting = TRUE; + out_flush(); + ml_close_all(TRUE); /* remove all memfiles */ + +#ifdef FEAT_GUI + if (gui.in_use) + gui_exit(r); +#endif + swi(OS_NewLine); + if (old_escape_state != -1) + swi(OS_Byte, 229, old_escape_state, 0); + if (old_cursor_state != -1) + swi(OS_Byte, 4, old_cursor_state); + exit(r); +} + + void +mch_settmode(tmode) + int tmode; /* TMODE_RAW or TMODE_COOK */ +{ + if (tmode == TMODE_COOK) + { + ro_line_mode = TRUE; + return; + } + + ro_line_mode = FALSE; + + if (term_console) + { + /* Block cursor. */ + swi(OS_WriteN, + "\027\000\012\000\000\000\000\000\000\000", + 10); + + /* Disable the standard cursor key actions. */ + swi(OS_Byte, 4, 1); + if (old_cursor_state == -1) + old_cursor_state = r1; + } + + /* Stop Escape from quitting Vim! */ + swi(OS_Byte, 229, 1, 0); + if (old_escape_state == -1) + old_escape_state = r1; +} + +/* + * set mouse clicks on or off (only works for xterms) + */ + void +mch_setmouse(on) + int on; +{ +} + +/* + * set screen mode, always fails. + */ +/* ARGSUSED */ + int +mch_screenmode(arg) + char_u *arg; +{ + EMSG(_(e_screnmode)); + return FAIL; +} + +/* + * Try to get the current window size. + * Return OK when size could be determined, FAIL otherwise. + * Simply return results stored by mch_init() if we are the + * machine's console. If not, we don't know how big the screen is. + */ + int +mch_get_shellsize() +{ + /* if size changed: screenalloc will allocate new screen buffers */ + return term_console ? OK : FAIL; +} + +/* + * Can't change the size. + * Assume the user knows what he's doing and use the new values. + */ + void +mch_set_shellsize() +{ + /* Assume the user knows what he's doing and use the new values. */ +} + +/* + * Rows and/or Columns has changed. + */ + void +mch_new_shellsize() +{ + /* Nothing to do. */ +} + + int +mch_call_shell(cmd, options) + char_u *cmd; + int options; /* SHELL_*, see vim.h */ +{ + int retval; + int tmode = cur_tmode; + + if (cmd == NULL) + cmd = (char_u *) "GOS"; + +#ifdef FEAT_GUI + if (gui.in_use) + return gui_mch_call_shell(cmd, options); +#endif + if (options & SHELL_COOKED) + settmode(TMODE_COOK); /* set to normal mode */ + MSG_PUTS("\n"); + + /* I don't even want to think about what UnixLib must + * be doing to allow this to work... + */ + retval = system(cmd); + if (retval && !(options & SHELL_SILENT)) + EMSG(strerror(EOPSYS)); /* Doesn't seem to set errno? */ + + swi(OS_Byte, 229, 1, 0); /* Re-disable escape */ + if (tmode == TMODE_RAW) + settmode(TMODE_RAW); /* set to raw mode */ + return retval ? FAIL : OK; +} + +/* + * Check for Escape being pressed right now. + * [ different if !term_console? ] + */ + void +mch_breakcheck() +{ + if (xswi(OS_Byte, 121, 0xf0) & v_flag) + return; + if (r1 == 0xff) + { + got_int = TRUE; + swi(OS_Byte, 15, 1); /* Flush input buffer */ + } +} + +/* + * Recursively expand one path component into all matching files and/or + * directories. + * "path" has backslashes before chars that are not to be expanded. + * Return the number of matches found. + */ + int +mch_expandpath(gap, path, flags) + garray_T *gap; /* Grow array for results. */ + char_u *path; + int flags; /* EW_* flags */ +{ + int got; /* Number of matches. */ + char_u *pattern; + + /* Plan: + * + * 1) Get first part of path - no wildcards + * 2) Get next path element (wildcarded) + * 3) Get rest of path + * + * If (3) is nothing then only the leaf is wildcarded - add to gap + * Otherwise call recursively for each path in (2), passing (3) + * + * This is just the header function. + */ + + /* We must be able to modifiy path, so make a copy */ + pattern = vim_strsave(path); + if (pattern == NULL) + return 0; + got = expand_section(gap, (char_u *)"", pattern, flags); + vim_free(pattern); + return got; +} + +/* + * expand_section(gap, "$.Dir1.Dir2", "ABBA*.myleaf##") + * + * calls expand_section(gap, "$.Dir1.Dir2.ABBA_Gold", "myleaf##") + * and expand_section(gap, "$.Dir1.Dir2.ABBA_Live", "myleaf##") + * + * If rest is just a leaf then all matches are added to gap. + * + * Returns number of items added to gap. + */ + int +expand_section(gap, root, rest, flags) + garray_T *gap; + char_u *root; /* Non-wildcarded path to search */ + char_u *rest; /* Wildcarded remainder of path */ + int flags; /* Add dirs/files/missing objects. */ +{ + static char_u buf[MAXPATHL]; /* Temporary buffer. */ + char_u dir[MAXPATHL]; + int start_element = -1; /* Start of wildcarded element */ + char_u c; + int i; + int got, dir_pos; + int buflen; /* Chars used in buf[] */ + int colon = 0; /* Dir ends in ':' */ + + buflen = strlen(root); + STRNCPY(buf, root, buflen); /* Copy root into buffer. */ + + /* + * Find end of nonwildcarded section. + * Count ':' as a path sep since Vim:Bug* is a valid pathname. + */ + + for (i = 0; c = rest[i]; i++) + { + if (c == PATHSEP) + { + start_element = i; + colon = 0; + } + if (c == ':') + { + start_element = i + 1; + colon = 1; + } + if (c == '#' || c == '*') + break; + } + if (c == 0) + start_element = i; + + /* + * start_element +> terminator for non-wildcarded section. + * Transfer this bit into buf. + */ + if (buflen + start_element + 4 >= MAXPATHL) + return 0; /* Buffer full */ + if (start_element >= 0) + { + if (*root && !colon) + buf[buflen++] = PATHSEP; + strncpy(buf + buflen, rest, start_element); + buflen += start_element; + } + buf[buflen] = 0; + + /* + * Did we reach the end of the string without hitting any wildcards? + */ + if (c == 0) + { + /* Yes - add combined path to grow array and return. */ + addfile(gap, buf, flags); + return 1; + } + + if (start_element < 0 || !colon) + start_element++; + rest += start_element; + + /* + * rest does contain wildcards if we get here. + * + * Now : have we reached the leaf names part yet? + * If so, add all matches (files and dirs) to gap. + * If not, get next path element and scan all matching directories. + */ + + start_element = -1; + for (i = 0; rest[i]; i++) + { + if (rest[i] == '.') + { + start_element = i; + rest[i] = 0; /* Break string here. */ + break; + } + } + + /* If start_element is -1 then we are matching leaf names */ + + r3 = 0; /* Number of objs read. */ + dir_pos = 0; /* Position through directory. */ + got = 0; /* Files added so far. */ + while (dir_pos != -1) + { + buf[buflen] = 0; + if (xswi(OS_GBPB, 9, + buf, /* Directory to scan. */ + buf + buflen + (1 - colon), /* Buffer for result. */ + 1, /* Number of objects to read. */ + dir_pos, /* Search position. */ + MAXPATHL - 2 - buflen, /* Size of result buffer. */ + rest) /* Wildcarded leafname. */ + & v_flag) + { + EMSG(r0 + 4); + r4 = -1; + } + dir_pos = r4; /* r4 corrupted by addfile() */ + if (r3 > 0) + { + char_u *path = buf; + if (buflen == 0) + path++; /* Don't do '.File' */ + else if (!colon) + buf[buflen] = '.'; /* Join path and leaf */ + + /* Path -> full path of object found */ + if (start_element == -1) + { + addfile(gap, path, flags); + got++; + } + else + { + /* Scan into subdirectories and images; ignore files */ + swi(OS_File, 17, path); + if (r0 == 2 || r0 == 3) + got += expand_section(gap, + path, + rest + start_element + 1, + flags); + } + } + } + + /* Restore the dot if we removed it. */ + if (start_element >= 0) + rest[start_element] = '.'; + return got; +} + +/* + * mch_expand_wildcards() - this code does wild-card pattern matching using + * the shell. It isn't used under RISC OS. + * + * return OK for success, FAIL for error (you may lose some memory) and put + * an error message in *file. + * + * num_pat is number of input patterns + * pat is array of pointers to input patterns + * num_file is pointer to number of matched file names + * file is pointer to array of pointers to matched file names + */ + int +mch_expand_wildcards(num_pat, pat, num_file, file, flags) + int num_pat; + char_u **pat; + int *num_file; + char_u ***file; + int flags; /* EW_* flags */ +{ + /* This doesn't get called unless SPECIAL_WILDCHAR is defined. */ + return FAIL; +} + +/* + * Return TRUE if "p" contains wildcards which can be expanded by + * mch_expandpath(). + */ + int +mch_has_exp_wildcard(p) + char_u *p; +{ + if (vim_strpbrk((char_u *)"*#", p)) + return TRUE; + return FALSE; +} + +/* Return TRUE if "p" contains wildcards. */ + int +mch_has_wildcard(p) + char_u *p; +{ + if (vim_strpbrk((char_u *)"*#`", p)) + return TRUE; + return FALSE; +} + + int /* see Unix unlink(2) */ +mch_remove(file) + char_u *file; /* Name of file to delete. */ +{ + if (xswi(OS_FSControl, 27, file, 0, 0) & v_flag) + return EXIT_FAILURE; + return EXIT_SUCCESS; +} + +/* Try to make existing scripts work without modification. + * Return a pointer to the new string (freed by caller), or NULL + * + * Two main cases: + * - Absolute : $VIM/syntax/help.vim + * - Relative : Adfs::4.$.!Vim.Resources.Syntax/help.vim + */ + char_u * +mch_munge_fname(fname) + char_u *fname; +{ + char_u c; + int len; + char_u *retval; + + retval = fname = vim_strsave(fname); + if (fname == NULL) + return NULL; + + if (strncmp(fname, "$VIM/", 5) == 0) + { + strncpy(fname, "Vim:", 4); + for (fname += 5; c = *fname; fname++) + { + if (c == '.') + break; + if (c == '/') + fname[-1] = '.'; + else + fname[-1] = c; + } + fname[-1] = '\0'; + } + else + { + /* Check to see if the file exists without modification. */ + if (xswi(OS_File, 17, fname) & v_flag) + r0 == 0; /* Invalid filename? */ + if (r0) + return retval; + + len = strlen(fname); + if (strcmp(fname + len - 4, ".vim") == 0) + { + fname[len - 4] = '\0'; + for (; c = *fname; fname++) + { + if (c == '/') + *fname = '.'; + } + } + } + return retval; +} + +/* QuickFix reads munged names from the error file. + * Correct them. + */ + int +ro_buflist_add(old_name) + char_u *old_name; /* Name of file found by quickfix */ +{ + char_u *fname; + char_u *leaf; /* Pointer to start of leaf in old_name */ + char_u *ptr; + char_u c; + int retval; + + if (old_name == NULL) + return buflist_add(NULL, 0); + + /* Copy the name so we can mess around with it. */ + fname = vim_strsave(old_name); + if (fname == NULL) + /* Out of memory - can't modify name */ + return buflist_add(old_name, 0); + + /* Change `dir/main.c' into `dir.c.main' */ + leaf = fname; + for (ptr = fname; c = *ptr; ptr++) + { + if (c == '/') + { + leaf = ptr + 1; + *ptr = '.'; + } + else if (c == '.') + break; + } + if (c == '.') + { + /* Change `main.c' into `c.main' + * | | + * leaf ptr + */ + ptr += old_name - fname; + *ptr = '\0'; + sprintf(leaf, + "%s.%s", + ptr + 1, + leaf - fname + old_name); + } + + retval = buflist_add(fname, 0); + free(fname); + return retval; +} + +/* Change the current directory. + * Strip trailing dots to make it easier to use with filename completion. + * Return 0 for success, -1 for failure. + */ + int +mch_chdir(dir) + char_u *dir; +{ + int length; + int retval; + char_u *new_dir; + + length = strlen(dir); + if (dir[length - 1] != '.') + return chdir(dir); /* No trailing dots - nothing to do. */ + new_dir = vim_strsave(dir); + if (new_dir == NULL) + return chdir(dir); /* Can't allocate memory. */ + + while (new_dir[--length] == '.') + new_dir[length] = '\0'; + + retval = chdir(new_dir); + vim_free(new_dir); + return retval; +} + +/* Examine the named file, and set the 'osfiletype' option + * (in curbuf) to the file's type. + */ + void +mch_read_filetype(file) + char_u *file; +{ + int type; + char_u type_string[9]; + int i; + + if (xswi(OS_File, 23, file) & v_flag) + type = 0xfff; /* Default to Text */ + else + type = r6; + + /* Type is the numerical value - see if we have a textual equivalent */ + swi(OS_FSControl, 18, 0, type); + ((int *) type_string)[0] = r2; + ((int *) type_string)[1] = r3; + type_string[8] = 0; + for (i = 0; type_string[i] > ' '; i++) + ; + type_string[i] = 0; + + set_string_option_direct("osfiletype", -1, type_string, OPT_FREE); + return; +} + + void +mch_set_filetype(file, type) + char_u *file; + char_u *type; +{ + if (xswi(OS_FSControl, 31, type) & v_flag) + { + EMSG(_("E366: Invalid 'osfiletype' option - using Text")); + r2 = 0xfff; + } + + swi(OS_File, 18, file, r2); +} + +/* Return TRUE if the file's type matches 'type' + * RISC OS types always start with '&' + */ + int +mch_check_filetype(fname, type) + char_u *fname; + char_u *type; +{ + int value; + char *end; + + if (*type != '&') + return FALSE; + + value = strtol(type + 1, &end, 16); + if (*end) + return FALSE; /* Invalid type (report error?) */ + + if (xswi(OS_File, 23, fname) & v_flag) + return FALSE; /* Invalid filename? */ + + return (r0 && r6 == value); +} |