![[BACK]](/icons/back.gif){kind=icon}
Return to unix.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim|
Return to unix.c CVS log | Up to [local] / src / usr.bin / vim |
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: * OS/2 port by Paul Slootman
6: *
7: * Do ":help uganda" in Vim to read copying and usage conditions.
8: * Do ":help credits" in Vim to see a list of people who contributed.
9: */
10:
11: /*
12: * unix.c -- code for all flavors of Unix (BSD, SYSV, SVR4, POSIX, ...)
13: * Also for OS/2, using the excellent EMX package!!!
14: *
15: * A lot of this file was originally written by Juergen Weigert and later
16: * changed beyond recognition.
17: */
18:
19: /*
20: * Some systems have a prototype for select() that has (int *) instead of
21: * (fd_set *), which is wrong. This define removes that prototype. We include
22: * our own prototype in osdef.h.
23: */
24: #define select select_declared_wrong
25:
26: #include "vim.h"
27: #include "globals.h"
28: #include "option.h"
29: #include "proto.h"
30:
31: #ifdef HAVE_FCNTL_H
32: # include <fcntl.h>
33: #endif
34:
35: #include "unixunix.h" /* unix includes for unix.c only */
36:
37: /*
38: * Use this prototype for select, some include files have a wrong prototype
39: */
40: #undef select
41:
42: #if defined(HAVE_SELECT)
43: extern int select __ARGS((int, fd_set *, fd_set *, fd_set *, struct timeval *));
44: #endif
45:
46: /*
47: * end of autoconf section. To be extended...
48: */
49:
50: /* Are the following #ifdefs still required? And why? Is that for X11? */
51:
52: #if defined(ESIX) || defined(M_UNIX) && !defined(SCO)
53: # ifdef SIGWINCH
54: # undef SIGWINCH
55: # endif
56: # ifdef TIOCGWINSZ
57: # undef TIOCGWINSZ
58: # endif
59: #endif
60:
61: #if defined(SIGWINDOW) && !defined(SIGWINCH) /* hpux 9.01 has it */
62: # define SIGWINCH SIGWINDOW
63: #endif
64:
65: #if defined(HAVE_X11) && defined(WANT_X11)
66: # include <X11/Xlib.h>
67: # include <X11/Xutil.h>
68: # include <X11/Xatom.h>
69:
70: Window x11_window = 0;
71: Display *x11_display = NULL;
72: int got_x_error = FALSE;
73:
74: static int get_x11_windis __ARGS((void));
75: static void set_x11_title __ARGS((char_u *));
76: static void set_x11_icon __ARGS((char_u *));
77: #endif
78:
79: static int get_x11_title __ARGS((int));
80: static int get_x11_icon __ARGS((int));
81:
82: static void may_core_dump __ARGS((void));
83:
84: static int Read __ARGS((char_u *, long));
85: static int WaitForChar __ARGS((long));
86: static int RealWaitForChar __ARGS((int, long));
87: static void fill_inbuf __ARGS((int));
88:
89: #if defined(SIGWINCH)
90: static RETSIGTYPE sig_winch __ARGS(SIGPROTOARG);
91: #endif
92: #if defined(SIGALRM) && defined(HAVE_X11) && defined(WANT_X11)
93: static RETSIGTYPE sig_alarm __ARGS(SIGPROTOARG);
94: #endif
95: static RETSIGTYPE deathtrap __ARGS(SIGPROTOARG);
96:
97: static void catch_signals __ARGS((RETSIGTYPE (*func)()));
98: #ifndef __EMX__
99: static int have_wildcard __ARGS((int, char_u **));
100: static int have_dollars __ARGS((int, char_u **));
101: #endif
102:
103: static int do_resize = FALSE;
104: static char_u *oldtitle = NULL;
105: static char_u *fixedtitle = (char_u *)"Thanks for flying Vim";
106: static char_u *oldicon = NULL;
107: #ifndef __EMX__
108: static char_u *extra_shell_arg = NULL;
109: static int show_shell_mess = TRUE;
110: #endif
111: static int core_dump = FALSE; /* core dump in mch_windexit() */
112:
113: #ifdef SYS_SIGLIST_DECLARED
114: /*
115: * I have seen
116: * extern char *_sys_siglist[NSIG];
117: * on Irix, Linux, NetBSD and Solaris. It contains a nice list of strings
118: * that describe the signals. That is nearly what we want here. But
119: * autoconf does only check for sys_siglist (without the underscore), I
120: * do not want to change everything today.... jw.
121: * This is why AC_DECL_SYS_SIGLIST is commented out in configure.in
122: */
123: #endif
124:
125: static struct
126: {
127: int sig; /* Signal number, eg. SIGSEGV etc */
128: char *name; /* Signal name (not char_u!). */
129: int dump; /* Should this signal cause a core dump? */
130: } signal_info[] =
131: {
132: #ifdef SIGHUP
133: {SIGHUP, "HUP", FALSE},
134: #endif
135: #ifdef SIGINT
136: {SIGINT, "INT", FALSE},
137: #endif
138: #ifdef SIGQUIT
139: {SIGQUIT, "QUIT", TRUE},
140: #endif
141: #ifdef SIGILL
142: {SIGILL, "ILL", TRUE},
143: #endif
144: #ifdef SIGTRAP
145: {SIGTRAP, "TRAP", TRUE},
146: #endif
147: #ifdef SIGABRT
148: {SIGABRT, "ABRT", TRUE},
149: #endif
150: #ifdef SIGEMT
151: {SIGEMT, "EMT", TRUE},
152: #endif
153: #ifdef SIGFPE
154: {SIGFPE, "FPE", TRUE},
155: #endif
156: #ifdef SIGBUS
157: {SIGBUS, "BUS", TRUE},
158: #endif
159: #ifdef SIGSEGV
160: {SIGSEGV, "SEGV", TRUE},
161: #endif
162: #ifdef SIGSYS
163: {SIGSYS, "SYS", TRUE},
164: #endif
165: #ifdef SIGALRM
166: {SIGALRM, "ALRM", FALSE},
167: #endif
168: #ifdef SIGTERM
169: {SIGTERM, "TERM", FALSE},
170: #endif
171: #ifdef SIGVTALRM
172: {SIGVTALRM, "VTALRM", FALSE},
173: #endif
174: #ifdef SIGPROF
175: {SIGPROF, "PROF", FALSE},
176: #endif
177: #ifdef SIGXCPU
178: {SIGXCPU, "XCPU", TRUE},
179: #endif
180: #ifdef SIGXFSZ
181: {SIGXFSZ, "XFSZ", TRUE},
182: #endif
183: #ifdef SIGUSR1
184: {SIGUSR1, "USR1", FALSE},
185: #endif
186: #ifdef SIGUSR2
187: {SIGUSR2, "USR2", FALSE},
188: #endif
189: {-1, "Unknown!", -1}
190: };
191:
192: void
193: mch_write(s, len)
194: char_u *s;
195: int len;
196: {
197: #ifdef USE_GUI
198: if (gui.in_use && !gui.dying)
199: {
200: gui_write(s, len);
201: if (p_wd)
202: gui_mch_wait_for_chars(p_wd);
203: }
204: else
205: #endif
206: {
207: write(1, (char *)s, len);
208: if (p_wd) /* Unix is too fast, slow down a bit more */
209: RealWaitForChar(0, p_wd);
210: }
211: }
212:
213: /*
214: * mch_inchar(): low level input funcion.
215: * Get a characters from the keyboard.
216: * Return the number of characters that are available.
217: * If wtime == 0 do not wait for characters.
218: * If wtime == n wait a short time for characters.
219: * If wtime == -1 wait forever for characters.
220: */
221: int
222: mch_inchar(buf, maxlen, wtime)
223: char_u *buf;
224: int maxlen;
225: long wtime; /* don't use "time", MIPS cannot handle it */
226: {
227: int len;
228:
229: #ifdef USE_GUI
230: if (gui.in_use)
231: {
232: if (!gui_mch_wait_for_chars(wtime))
233: return 0;
234: return Read(buf, (long)maxlen);
235: }
236: #endif
237:
238: if (wtime >= 0)
239: {
240: while (WaitForChar(wtime) == 0) /* no character available */
241: {
242: if (!do_resize) /* return if not interrupted by resize */
243: return 0;
244: set_winsize(0, 0, FALSE);
245: do_resize = FALSE;
246: }
247: }
248: else /* wtime == -1 */
249: {
250: /*
251: * If there is no character available within 'updatetime' seconds
252: * flush all the swap files to disk
253: * Also done when interrupted by SIGWINCH.
254: */
255: if (WaitForChar(p_ut) == 0)
256: updatescript(0);
257: }
258:
259: for (;;) /* repeat until we got a character */
260: {
261: if (do_resize) /* window changed size */
262: {
263: set_winsize(0, 0, FALSE);
264: do_resize = FALSE;
265: }
266: /*
267: * we want to be interrupted by the winch signal
268: */
269: WaitForChar(-1L);
270: if (do_resize) /* interrupted by SIGWINCHsignal */
271: continue;
272:
273: /*
274: * For some terminals we only get one character at a time.
275: * We want the get all available characters, so we could keep on
276: * trying until none is available
277: * For some other terminals this is quite slow, that's why we don't do
278: * it.
279: */
280: len = Read(buf, (long)maxlen);
281: if (len > 0)
282: {
283: #ifdef OS2
284: int i;
285:
286: for (i = 0; i < len; i++)
287: if (buf[i] == 0)
288: buf[i] = K_NUL;
289: #endif
290: return len;
291: }
292: }
293: }
294:
295: /*
296: * return non-zero if a character is available
297: */
298: int
299: mch_char_avail()
300: {
301: #ifdef USE_GUI
302: if (gui.in_use)
303: {
304: gui_mch_update();
305: return !is_input_buf_empty();
306: }
307: #endif
308: return WaitForChar(0L);
309: }
310:
311: long
312: mch_avail_mem(special)
313: int special;
314: {
315: #ifdef __EMX__
316: return ulimit(3, 0L); /* always 32MB? */
317: #else
318: return 0x7fffffff; /* virtual memory eh */
319: #endif
320: }
321:
322: void
323: mch_delay(msec, ignoreinput)
324: long msec;
325: int ignoreinput;
326: {
327: if (ignoreinput)
328: #ifndef HAVE_SELECT
329: poll(NULL, 0, (int)msec);
330: #else
331: # ifdef __EMX__
332: _sleep2(msec);
333: # else
334: {
335: struct timeval tv;
336:
337: tv.tv_sec = msec / 1000;
338: tv.tv_usec = (msec % 1000) * 1000;
339: select(0, NULL, NULL, NULL, &tv);
340: }
341: # endif /* __EMX__ */
342: #endif /* HAVE_SELECT */
343: else
344: #ifdef USE_GUI
345: if (gui.in_use)
346: gui_mch_wait_for_chars(msec);
347: else
348: #endif
349: WaitForChar(msec);
350: }
351:
352: #if defined(SIGWINCH)
353: /*
354: * We need correct potatotypes, otherwise mean compilers will barf when the
355: * second argument to signal() is ``wrong''.
356: * Let me try it with a few tricky defines from my own osdef.h (jw).
357: */
358: static RETSIGTYPE
359: sig_winch SIGDEFARG(sigarg)
360: {
361: /* this is not required on all systems, but it doesn't hurt anybody */
362: signal(SIGWINCH, (RETSIGTYPE (*)())sig_winch);
363: do_resize = TRUE;
364: SIGRETURN;
365: }
366: #endif
367:
368: #if defined(SIGALRM) && defined(HAVE_X11) && defined(WANT_X11)
369: /*
370: * signal function for alarm().
371: */
372: static RETSIGTYPE
373: sig_alarm SIGDEFARG(sigarg)
374: {
375: /* doesn't do anything, just to break a system call */
376: SIGRETURN;
377: }
378: #endif
379:
380: void
381: mch_resize()
382: {
383: do_resize = TRUE;
384: }
385:
386: /*
387: * This function handles deadly signals.
388: * It tries to preserve any swap file and exit properly.
389: * (partly from Elvis).
390: */
391: static RETSIGTYPE
392: deathtrap SIGDEFARG(sigarg)
393: {
394: static int entered = 0;
395: #ifdef SIGHASARG
396: int i;
397:
398: for (i = 0; signal_info[i].dump != -1; i++)
399: {
400: if (sigarg == signal_info[i].sig)
401: {
402: if (signal_info[i].dump)
403: core_dump = TRUE;
404: break;
405: }
406: }
407: #endif
408:
409: /*
410: * If something goes wrong after entering here, we may get here again.
411: * When this happens, give a message and try to exit nicely (resetting the
412: * terminal mode, etc.)
413: * When this happens twice, just exit, don't even try to give a message,
414: * stack may be corrupt or something weird.
415: */
416: if (entered == 2)
417: {
418: may_core_dump();
419: exit(7);
420: }
421: if (entered)
422: {
423: OUTSTR("Vim: Double signal, exiting\n");
424: flushbuf();
425: getout(1);
426: }
427: ++entered;
428:
429: sprintf((char *)IObuff, "Vim: Caught %s %s\n",
430: #ifdef SIGHASARG
431: "deadly signal", signal_info[i].name);
432: #else
433: "some", "deadly signal");
434: #endif
435:
436: preserve_exit(); /* preserve files and exit */
437:
438: SIGRETURN;
439: }
440:
441: /*
442: * If the machine has job control, use it to suspend the program,
443: * otherwise fake it by starting a new shell.
444: * When running the GUI iconify the window.
445: */
446: void
447: mch_suspend()
448: {
449: #ifdef USE_GUI
450: if (gui.in_use)
451: {
452: gui_mch_iconify();
453: return;
454: }
455: #endif
456: #ifdef SIGTSTP
457: flushbuf(); /* needed to make cursor visible on some systems */
458: settmode(0);
459: flushbuf(); /* needed to disable mouse on some systems */
460: kill(0, SIGTSTP); /* send ourselves a STOP signal */
461:
462: /*
463: * Set oldtitle to NULL, so the current title is obtained again.
464: */
465: if (oldtitle != fixedtitle)
466: {
467: vim_free(oldtitle);
468: oldtitle = NULL;
469: }
470: settmode(1);
471: #else
472: MSG_OUTSTR("new shell started\n");
473: (void)call_shell(NULL, SHELL_COOKED);
474: #endif
475: need_check_timestamps = TRUE;
476: }
477:
478: void
479: mch_windinit()
480: {
481: Columns = 80;
482: Rows = 24;
483:
484: flushbuf();
485:
486: (void)mch_get_winsize();
487:
488: #if defined(SIGWINCH)
489: /*
490: * WINDOW CHANGE signal is handled with sig_winch().
491: */
492: signal(SIGWINCH, (RETSIGTYPE (*)())sig_winch);
493: #endif
494:
495: /*
496: * We want the STOP signal to work, to make mch_suspend() work
497: */
498: #ifdef SIGTSTP
499: signal(SIGTSTP, SIG_DFL);
500: #endif
501:
502: /*
503: * We want to ignore breaking of PIPEs.
504: */
505: #ifdef SIGPIPE
506: signal(SIGPIPE, SIG_IGN);
507: #endif
508:
509: /*
510: * Arrange for other signals to gracefully shutdown Vim.
511: */
512: catch_signals(deathtrap);
513: }
514:
515: static void
516: catch_signals(func)
517: RETSIGTYPE (*func)();
518: {
519: int i;
520:
521: for (i = 0; signal_info[i].dump != -1; i++)
522: signal(signal_info[i].sig, func);
523: }
524:
525: void
526: reset_signals()
527: {
528: catch_signals(SIG_DFL);
529: }
530:
531: /*
532: * Check_win checks whether we have an interactive window.
533: */
534: int
535: mch_check_win(argc, argv)
536: int argc;
537: char **argv;
538: {
539: if (isatty(1))
540: return OK;
541: return FAIL;
542: }
543:
544: int
545: mch_check_input()
546: {
547: if (isatty(0))
548: return OK;
549: return FAIL;
550: }
551:
552: #if defined(HAVE_X11) && defined(WANT_X11)
553: /*
554: * X Error handler, otherwise X just exits! (very rude) -- webb
555: */
556: static int
557: x_error_handler(dpy, error_event)
558: Display *dpy;
559: XErrorEvent *error_event;
560: {
561: XGetErrorText(dpy, error_event->error_code, (char *)IObuff, IOSIZE);
562: STRCAT(IObuff, "\nVim: Got X error\n");
563:
564: #if 1
565: preserve_exit(); /* preserve files and exit */
566: #else
567: printf(IObuff); /* print error message and continue */
568: /* Makes my system hang */
569: #endif
570:
571: return 0; /* NOTREACHED */
572: }
573:
574: /*
575: * Another X Error handler, just used to check for errors.
576: */
577: static int
578: x_error_check(dpy, error_event)
579: Display *dpy;
580: XErrorEvent *error_event;
581: {
582: got_x_error = TRUE;
583: return 0;
584: }
585:
586: /*
587: * try to get x11 window and display
588: *
589: * return FAIL for failure, OK otherwise
590: */
591: static int
592: get_x11_windis()
593: {
594: char *winid;
595: XTextProperty text_prop;
596: int (*old_handler)();
597: static int result = -1;
598: static int x11_display_opened_here = FALSE;
599:
600: /* X just exits if it finds an error otherwise! */
601: XSetErrorHandler(x_error_handler);
602:
603: #ifdef USE_GUI_X11
604: if (gui.in_use)
605: {
606: /*
607: * If the X11 display was opened here before, for the window where Vim
608: * was started, close that one now to avoid a memory leak.
609: */
610: if (x11_display_opened_here && x11_display != NULL)
611: {
612: XCloseDisplay(x11_display);
613: x11_display = NULL;
614: x11_display_opened_here = FALSE;
615: }
616: return gui_get_x11_windis(&x11_window, &x11_display);
617: }
618: #endif
619:
620: if (result != -1) /* Have already been here and set this */
621: return result; /* Don't do all these X calls again */
622:
623: /*
624: * If WINDOWID not set, should try another method to find out
625: * what the current window number is. The only code I know for
626: * this is very complicated.
627: * We assume that zero is invalid for WINDOWID.
628: */
629: if (x11_window == 0 && (winid = getenv("WINDOWID")) != NULL)
630: x11_window = (Window)atol(winid);
631: if (x11_window != 0 && x11_display == NULL)
632: {
633: #ifdef SIGALRM
634: RETSIGTYPE (*sig_save)();
635:
636: /*
637: * Opening the Display may hang if the DISPLAY setting is wrong, or
638: * the network connection is bad. Set an alarm timer to get out.
639: */
640: sig_save = (RETSIGTYPE (*)())signal(SIGALRM,
641: (RETSIGTYPE (*)())sig_alarm);
642: alarm(2);
643: #endif
644: x11_display = XOpenDisplay(NULL);
645: #ifdef SIGALRM
646: alarm(0);
647: signal(SIGALRM, (RETSIGTYPE (*)())sig_save);
648: #endif
649: if (x11_display != NULL)
650: {
651: /*
652: * Try to get the window title. I don't actually want it yet, so
653: * there may be a simpler call to use, but this will cause the
654: * error handler x_error_check() to be called if anything is wrong,
655: * such as the window pointer being invalid (as can happen when the
656: * user changes his DISPLAY, but not his WINDOWID) -- webb
657: */
658: old_handler = XSetErrorHandler(x_error_check);
659: got_x_error = FALSE;
660: if (XGetWMName(x11_display, x11_window, &text_prop))
661: XFree((void *)text_prop.value);
662: XSync(x11_display, False);
663: if (got_x_error)
664: {
665: /* Maybe window id is bad */
666: x11_window = 0;
667: XCloseDisplay(x11_display);
668: x11_display = NULL;
669: }
670: else
671: x11_display_opened_here = TRUE;
672: XSetErrorHandler(old_handler);
673: }
674: }
675: if (x11_window == 0 || x11_display == NULL)
676: return (result = FAIL);
677: return (result = OK);
678: }
679:
680: /*
681: * Determine original x11 Window Title
682: */
683: static int
684: get_x11_title(test_only)
685: int test_only;
686: {
687: XTextProperty text_prop;
688: int retval = FALSE;
689:
690: if (get_x11_windis() == OK)
691: {
692: /* Get window name if any */
693: if (XGetWMName(x11_display, x11_window, &text_prop))
694: {
695: if (text_prop.value != NULL)
696: {
697: retval = TRUE;
698: if (!test_only)
699: oldtitle = strsave((char_u *)text_prop.value);
700: }
701: XFree((void *)text_prop.value);
702: }
703: }
704: if (oldtitle == NULL && !test_only) /* could not get old title */
705: oldtitle = fixedtitle;
706:
707: return retval;
708: }
709:
710: /*
711: * Determine original x11 Window icon
712: */
713:
714: static int
715: get_x11_icon(test_only)
716: int test_only;
717: {
718: XTextProperty text_prop;
719: int retval = FALSE;
720:
721: if (get_x11_windis() == OK)
722: {
723: /* Get icon name if any */
724: if (XGetWMIconName(x11_display, x11_window, &text_prop))
725: {
726: if (text_prop.value != NULL)
727: {
728: retval = TRUE;
729: if (!test_only)
730: oldicon = strsave((char_u *)text_prop.value);
731: }
732: XFree((void *)text_prop.value);
733: }
734: }
735:
736: /* could not get old icon, use terminal name */
737: if (oldicon == NULL && !test_only)
738: {
739: if (STRNCMP(term_strings[KS_NAME], "builtin_", 8) == 0)
740: oldicon = term_strings[KS_NAME] + 8;
741: else
742: oldicon = term_strings[KS_NAME];
743: }
744:
745: return retval;
746: }
747:
748: /*
749: * Set x11 Window Title
750: *
751: * get_x11_windis() must be called before this and have returned OK
752: */
753: static void
754: set_x11_title(title)
755: char_u *title;
756: {
757: #if XtSpecificationRelease >= 4
758: XTextProperty text_prop;
759:
760: text_prop.value = title;
761: text_prop.nitems = STRLEN(title);
762: text_prop.encoding = XA_STRING;
763: text_prop.format = 8;
764: XSetWMName(x11_display, x11_window, &text_prop);
765: #else
766: XStoreName(x11_display, x11_window, (char *)title);
767: #endif
768: XFlush(x11_display);
769: }
770:
771: /*
772: * Set x11 Window icon
773: *
774: * get_x11_windis() must be called before this and have returned OK
775: */
776: static void
777: set_x11_icon(icon)
778: char_u *icon;
779: {
780: #if XtSpecificationRelease >= 4
781: XTextProperty text_prop;
782:
783: text_prop.value = icon;
784: text_prop.nitems = STRLEN(icon);
785: text_prop.encoding = XA_STRING;
786: text_prop.format = 8;
787: XSetWMIconName(x11_display, x11_window, &text_prop);
788: #else
789: XSetIconName(x11_display, x11_window, (char *)icon);
790: #endif
791: XFlush(x11_display);
792: }
793:
794: #else /* HAVE_X11 && WANT_X11 */
795:
796: static int
797: get_x11_title(test_only)
798: int test_only;
799: {
800: if (!test_only)
801: oldtitle = fixedtitle;
802: return FALSE;
803: }
804:
805: static int
806: get_x11_icon(test_only)
807: int test_only;
808: {
809: if (!test_only)
810: {
811: if (STRNCMP(term_strings[KS_NAME], "builtin_", 8) == 0)
812: oldicon = term_strings[KS_NAME] + 8;
813: else
814: oldicon = term_strings[KS_NAME];
815: }
816: return FALSE;
817: }
818:
819: #endif /* HAVE_X11 && WANT_X11 */
820:
821: int
822: mch_can_restore_title()
823: {
824: #ifdef USE_GUI
825: /*
826: * If GUI is (going to be) used, we can always set the window title.
827: * Saves a bit of time, because the X11 display server does not need to be
828: * contacted.
829: */
830: if (gui.starting || gui.in_use)
831: return TRUE;
832: #endif
833: return get_x11_title(TRUE);
834: }
835:
836: int
837: mch_can_restore_icon()
838: {
839: #ifdef USE_GUI
840: /*
841: * If GUI is (going to be) used, we can always set the icon name.
842: * Saves a bit of time, because the X11 display server does not need to be
843: * contacted.
844: */
845: if (gui.starting || gui.in_use)
846: return TRUE;
847: #endif
848: return get_x11_icon(TRUE);
849: }
850:
851: /*
852: * Set the window title and icon.
853: * Currently only works for x11.
854: */
855: void
856: mch_settitle(title, icon)
857: char_u *title;
858: char_u *icon;
859: {
860: int type = 0;
861:
862: if (term_strings[KS_NAME] == NULL) /* no terminal name (yet) */
863: return;
864: if (title == NULL && icon == NULL) /* nothing to do */
865: return;
866:
867: /*
868: * if the window ID and the display is known, we may use X11 calls
869: */
870: #if defined(HAVE_X11) && defined(WANT_X11)
871: if (get_x11_windis() == OK)
872: type = 1;
873: #endif
874:
875: /*
876: * Note: if terminal is xterm, title is set with escape sequence rather
877: * than x11 calls, because the x11 calls don't always work
878: * Check only if the start of the terminal name is "xterm", also catch
879: * "xterms".
880: */
881: if (is_xterm(term_strings[KS_NAME]))
882: type = 2;
883:
884: if (is_iris_ansi(term_strings[KS_NAME]))
885: type = 3;
886:
887: if (type)
888: {
889: if (title != NULL)
890: {
891: if (oldtitle == NULL) /* first call, save title */
892: (void)get_x11_title(FALSE);
893:
894: switch(type)
895: {
896: #if defined(HAVE_X11) && defined(WANT_X11)
897: case 1: set_x11_title(title); /* x11 */
898: break;
899: #endif
900: case 2: outstrn((char_u *)"\033]2;"); /* xterm */
901: outstrn(title);
902: outchar(Ctrl('G'));
903: flushbuf();
904: break;
905:
906: case 3: outstrn((char_u *)"\033P1.y"); /* iris-ansi */
907: outstrn(title);
908: outstrn((char_u *)"\234");
909: flushbuf();
910: break;
911: }
912: }
913:
914: if (icon != NULL)
915: {
916: if (oldicon == NULL) /* first call, save icon */
917: get_x11_icon(FALSE);
918:
919: switch(type)
920: {
921: #if defined(HAVE_X11) && defined(WANT_X11)
922: case 1: set_x11_icon(icon); /* x11 */
923: break;
924: #endif
925: case 2: outstrn((char_u *)"\033]1;"); /* xterm */
926: outstrn(icon);
927: outchar(Ctrl('G'));
928: flushbuf();
929: break;
930:
931: case 3: outstrn((char_u *)"\033P3.y"); /* iris-ansi */
932: outstrn(icon);
933: outstrn((char_u *)"\234");
934: flushbuf();
935: break;
936: }
937: }
938: }
939: }
940:
941: int
942: is_xterm(name)
943: char_u *name;
944: {
945: if (name == NULL)
946: return FALSE;
947: return (vim_strnicmp(name, (char_u *)"xterm", (size_t)5) == 0 ||
948: STRCMP(name, "builtin_xterm") == 0);
949: }
950:
951: int
952: is_iris_ansi(name)
953: char_u *name;
954: {
955: if (name == NULL)
956: return FALSE;
957: return (vim_strnicmp(name, (char_u *)"iris-ansi", (size_t)9) == 0 ||
958: STRCMP(name, "builtin_iris-ansi") == 0);
959: }
960:
961: /*
962: * Return TRUE if "name" is a terminal for which 'ttyfast' should be set.
963: * This should include all windowed terminal emulators.
964: */
965: int
966: is_fastterm(name)
967: char_u *name;
968: {
969: if (name == NULL)
970: return FALSE;
971: if (is_xterm(name) || is_iris_ansi(name))
972: return TRUE;
973: return (vim_strnicmp(name, (char_u *)"hpterm", (size_t)6) == 0 ||
974: vim_strnicmp(name, (char_u *)"sun-cmd", (size_t)7) == 0 ||
975: vim_strnicmp(name, (char_u *)"screen", (size_t)6) == 0 ||
976: vim_strnicmp(name, (char_u *)"dtterm", (size_t)6) == 0);
977: }
978:
979: /*
980: * Restore the window/icon title.
981: * which is one of:
982: * 1 Just restore title
983: * 2 Just restore icon
984: * 3 Restore title and icon
985: */
986: void
987: mch_restore_title(which)
988: int which;
989: {
990: mch_settitle((which & 1) ? oldtitle : NULL, (which & 2) ? oldicon : NULL);
991: }
992:
993: /*
994: * Insert user name in s[len].
995: * Return OK if a name found.
996: */
997: int
998: mch_get_user_name(s, len)
999: char_u *s;
1000: int len;
1001: {
1002: #if defined(HAVE_PWD_H) && defined(HAVE_GETPWUID)
1003: struct passwd *pw;
1004: #endif
1005: uid_t uid;
1006:
1007: uid = getuid();
1008: #if defined(HAVE_PWD_H) && defined(HAVE_GETPWUID)
1009: if ((pw = getpwuid(uid)) != NULL &&
1010: pw->pw_name != NULL && *pw->pw_name != NUL)
1011: {
1012: STRNCPY(s, pw->pw_name, len);
1013: return OK;
1014: }
1015: #endif
1016: sprintf((char *)s, "%d", (int)uid); /* assumes s is long enough */
1017: return FAIL; /* a number is not a name */
1018: }
1019:
1020: /*
1021: * Insert host name is s[len].
1022: */
1023:
1024: #ifdef HAVE_SYS_UTSNAME_H
1025: void
1026: mch_get_host_name(s, len)
1027: char_u *s;
1028: int len;
1029: {
1030: struct utsname vutsname;
1031:
1032: uname(&vutsname);
1033: STRNCPY(s, vutsname.nodename, len);
1034: }
1035: #else /* HAVE_SYS_UTSNAME_H */
1036:
1037: # ifdef HAVE_SYS_SYSTEMINFO_H
1038: # define gethostname(nam, len) sysinfo(SI_HOSTNAME, nam, len)
1039: # endif
1040:
1041: void
1042: mch_get_host_name(s, len)
1043: char_u *s;
1044: int len;
1045: {
1046: gethostname((char *)s, len);
1047: }
1048: #endif /* HAVE_SYS_UTSNAME_H */
1049:
1050: /*
1051: * return process ID
1052: */
1053: long
1054: mch_get_pid()
1055: {
1056: return (long)getpid();
1057: }
1058:
1059: #if !defined(HAVE_STRERROR) && defined(USE_GETCWD)
1060: static char *strerror __ARGS((int));
1061:
1062: static char *
1063: strerror(err)
1064: int err;
1065: {
1066: extern int sys_nerr;
1067: extern char *sys_errlist[];
1068: static char er[20];
1069:
1070: if (err > 0 && err < sys_nerr)
1071: return (sys_errlist[err]);
1072: sprintf(er, "Error %d", err);
1073: return er;
1074: }
1075: #endif
1076:
1077: /*
1078: * Get name of current directory into buffer 'buf' of length 'len' bytes.
1079: * Return OK for success, FAIL for failure.
1080: */
1081: int
1082: mch_dirname(buf, len)
1083: char_u *buf;
1084: int len;
1085: {
1086: #if defined(USE_GETCWD)
1087: if (getcwd((char *)buf, len) == NULL)
1088: {
1089: STRCPY(buf, strerror(errno));
1090: return FAIL;
1091: }
1092: return OK;
1093: #else
1094: return (getwd((char *)buf) != NULL ? OK : FAIL);
1095: #endif
1096: }
1097:
1098: #ifdef __EMX__
1099: /*
1100: * Replace all slashes by backslashes.
1101: */
1102: static void
1103: slash_adjust(p)
1104: char_u *p;
1105: {
1106: while (*p)
1107: {
1108: if (*p == '/')
1109: *p = '\\';
1110: ++p;
1111: }
1112: }
1113: #endif
1114:
1115: /*
1116: * Get absolute filename into buffer 'buf' of length 'len' bytes.
1117: *
1118: * return FAIL for failure, OK for success
1119: */
1120: int
1121: FullName(fname, buf, len, force)
1122: char_u *fname, *buf;
1123: int len;
1124: int force; /* also expand when already absolute path name */
1125: {
1126: int l;
1127: #ifdef OS2
1128: int only_drive; /* only a drive letter is specified in file name */
1129: #endif
1130: #ifdef HAVE_FCHDIR
1131: int fd = -1;
1132: static int dont_fchdir = FALSE; /* TRUE when fchdir() doesn't work */
1133: #endif
1134: char_u olddir[MAXPATHL];
1135: char_u *p;
1136: char_u c;
1137: int retval = OK;
1138:
1139: if (fname == NULL) /* always fail */
1140: {
1141: *buf = NUL;
1142: return FAIL;
1143: }
1144:
1145: *buf = 0;
1146: if (force || !isFullName(fname)) /* if forced or not an absolute path */
1147: {
1148: /*
1149: * If the file name has a path, change to that directory for a moment,
1150: * and then do the getwd() (and get back to where we were).
1151: * This will get the correct path name with "../" things.
1152: */
1153: #ifdef OS2
1154: only_drive = 0;
1155: if (((p = vim_strrchr(fname, '/')) != NULL) ||
1156: ((p = vim_strrchr(fname, '\\')) != NULL) ||
1157: (((p = vim_strchr(fname, ':')) != NULL) && ++only_drive))
1158: #else
1159: if ((p = vim_strrchr(fname, '/')) != NULL)
1160: #endif
1161: {
1162: #ifdef HAVE_FCHDIR
1163: /*
1164: * Use fchdir() if possible, it's said to be faster and more
1165: * reliable. But on SunOS 4 it might not work. Check this by
1166: * doing a fchdir() right now.
1167: */
1168: if (!dont_fchdir)
1169: {
1170: fd = open(".", O_RDONLY | O_EXTRA);
1171: if (fd >= 0 && fchdir(fd) < 0)
1172: {
1173: close(fd);
1174: fd = -1;
1175: dont_fchdir = TRUE; /* don't try again */
1176: }
1177: }
1178: #endif
1179: if (
1180: #ifdef HAVE_FCHDIR
1181: fd < 0 &&
1182: #endif
1183: mch_dirname(olddir, MAXPATHL) == FAIL)
1184: {
1185: p = NULL; /* can't get current dir: don't chdir */
1186: retval = FAIL;
1187: }
1188: else
1189: {
1190: #ifdef OS2
1191: /*
1192: * compensate for case where ':' from "D:" was the only
1193: * path separator detected in the file name; the _next_
1194: * character has to be removed, and then restored later.
1195: */
1196: if (only_drive)
1197: p++;
1198: #endif
1199: c = *p;
1200: *p = NUL;
1201: if (vim_chdir((char *)fname))
1202: retval = FAIL;
1203: else
1204: fname = p + 1;
1205: *p = c;
1206: #ifdef OS2
1207: if (only_drive)
1208: {
1209: p--;
1210: if (retval != FAIL)
1211: fname--;
1212: }
1213: #endif
1214: }
1215: }
1216: if (mch_dirname(buf, len) == FAIL)
1217: {
1218: retval = FAIL;
1219: *buf = NUL;
1220: }
1221: l = STRLEN(buf);
1222: if (l && buf[l - 1] != '/')
1223: STRCAT(buf, "/");
1224: if (p != NULL)
1225: {
1226: #ifdef HAVE_FCHDIR
1227: if (fd >= 0)
1228: {
1229: fchdir(fd);
1230: close(fd);
1231: }
1232: else
1233: #endif
1234: vim_chdir((char *)olddir);
1235: }
1236: }
1237: STRCAT(buf, fname);
1238: #ifdef OS2
1239: slash_adjust(buf);
1240: #endif
1241: return retval;
1242: }
1243:
1244: /*
1245: * return TRUE is fname is an absolute path name
1246: */
1247: int
1248: isFullName(fname)
1249: char_u *fname;
1250: {
1251: #ifdef __EMX__
1252: return _fnisabs(fname);
1253: #else
1254: return (*fname == '/' || *fname == '~');
1255: #endif
1256: }
1257:
1258: /*
1259: * get file permissions for 'name'
1260: */
1261: long
1262: getperm(name)
1263: char_u *name;
1264: {
1265: struct stat statb;
1266:
1267: if (stat((char *)name, &statb))
1268: return -1;
1269: return statb.st_mode;
1270: }
1271:
1272: /*
1273: * set file permission for 'name' to 'perm'
1274: *
1275: * return FAIL for failure, OK otherwise
1276: */
1277: int
1278: setperm(name, perm)
1279: char_u *name;
1280: int perm;
1281: {
1282: return (chmod((char *)name, (mode_t)perm) == 0 ? OK : FAIL);
1283: }
1284:
1285: /*
1286: * return TRUE if "name" is a directory
1287: * return FALSE if "name" is not a directory
1288: * return FALSE for error
1289: */
1290: int
1291: mch_isdir(name)
1292: char_u *name;
1293: {
1294: struct stat statb;
1295:
1296: if (stat((char *)name, &statb))
1297: return FALSE;
1298: #ifdef _POSIX_SOURCE
1299: return (S_ISDIR(statb.st_mode) ? TRUE : FALSE);
1300: #else
1301: return ((statb.st_mode & S_IFMT) == S_IFDIR ? TRUE : FALSE);
1302: #endif
1303: }
1304:
1305: void
1306: mch_windexit(r)
1307: int r;
1308: {
1309: settmode(0);
1310: exiting = TRUE;
1311: mch_settitle(oldtitle, oldicon); /* restore xterm title */
1312: stoptermcap();
1313: flushbuf();
1314: ml_close_all(TRUE); /* remove all memfiles */
1315: may_core_dump();
1316: exit(r);
1317: }
1318:
1319: static void
1320: may_core_dump()
1321: {
1322: #ifdef SIGQUIT
1323: signal(SIGQUIT, SIG_DFL);
1324: if (core_dump)
1325: kill(getpid(), SIGQUIT); /* force a core dump */
1326: #endif
1327: }
1328:
1329: static int curr_tmode = 0; /* contains current raw/cooked mode (0 = cooked) */
1330:
1331: void
1332: mch_settmode(raw)
1333: int raw;
1334: {
1335: static int first = TRUE;
1336:
1337: /* Why is NeXT excluded here (and not in unixunix.h)? */
1338: #if defined(ECHOE) && defined(ICANON) && (defined(HAVE_TERMIO_H) || defined(HAVE_TERMIOS_H)) && !defined(__NeXT__)
1339: /* for "new" tty systems */
1340: # ifdef HAVE_TERMIOS_H
1341: static struct termios told;
1342: struct termios tnew;
1343: # else
1344: static struct termio told;
1345: struct termio tnew;
1346: # endif
1347:
1348: # ifdef TIOCLGET
1349: static unsigned long tty_local;
1350: # endif
1351:
1352: if (raw)
1353: {
1354: if (first)
1355: {
1356: first = FALSE;
1357: # ifdef TIOCLGET
1358: ioctl(0, TIOCLGET, &tty_local);
1359: # endif
1360: # if defined(HAVE_TERMIOS_H)
1361: tcgetattr(0, &told);
1362: # else
1363: ioctl(0, TCGETA, &told);
1364: # endif
1365: }
1366: tnew = told;
1367: /*
1368: * ICRNL enables typing ^V^M
1369: */
1370: tnew.c_iflag &= ~ICRNL;
1371: tnew.c_lflag &= ~(ICANON | ECHO | ISIG | ECHOE
1372: # if defined(IEXTEN) && !defined(MINT)
1373: | IEXTEN /* IEXTEN enables typing ^V on SOLARIS */
1374: /* but it breaks function keys on MINT */
1375: # endif
1376: );
1377: tnew.c_cc[VMIN] = 1; /* return after 1 char */
1378: tnew.c_cc[VTIME] = 0; /* don't wait */
1379: # if defined(HAVE_TERMIOS_H)
1380: tcsetattr(0, TCSANOW, &tnew);
1381: # else
1382: ioctl(0, TCSETA, &tnew);
1383: # endif
1384: }
1385: else
1386: {
1387: # if defined(HAVE_TERMIOS_H)
1388: tcsetattr(0, TCSANOW, &told);
1389: # else
1390: ioctl(0, TCSETA, &told);
1391: # endif
1392: # ifdef TIOCLGET
1393: ioctl(0, TIOCLSET, &tty_local);
1394: # endif
1395: }
1396: #else
1397: # ifndef TIOCSETN
1398: # define TIOCSETN TIOCSETP /* for hpux 9.0 */
1399: # endif
1400: /* for "old" tty systems */
1401: static struct sgttyb ttybold;
1402: struct sgttyb ttybnew;
1403:
1404: if (raw)
1405: {
1406: if (first)
1407: {
1408: first = FALSE;
1409: ioctl(0, TIOCGETP, &ttybold);
1410: }
1411: ttybnew = ttybold;
1412: ttybnew.sg_flags &= ~(CRMOD | ECHO);
1413: ttybnew.sg_flags |= RAW;
1414: ioctl(0, TIOCSETN, &ttybnew);
1415: }
1416: else
1417: ioctl(0, TIOCSETN, &ttybold);
1418: #endif
1419: curr_tmode = raw;
1420: }
1421:
1422: /*
1423: * Try to get the code for "t_kb" from the stty setting
1424: *
1425: * Even if termcap claims a backspace key, the user's setting *should*
1426: * prevail. stty knows more about reality than termcap does, and if
1427: * somebody's usual erase key is DEL (which, for most BSD users, it will
1428: * be), they're going to get really annoyed if their erase key starts
1429: * doing forward deletes for no reason. (Eric Fischer)
1430: */
1431: void
1432: get_stty()
1433: {
1434: char_u buf[2];
1435: char_u *p;
1436:
1437: /* Why is NeXT excluded here (and not in unixunix.h)? */
1438: #if defined(ECHOE) && defined(ICANON) && (defined(HAVE_TERMIO_H) || defined(HAVE_TERMIOS_H)) && !defined(__NeXT__)
1439: /* for "new" tty systems */
1440: # ifdef HAVE_TERMIOS_H
1441: struct termios keys;
1442: # else
1443: struct termio keys;
1444: # endif
1445:
1446: # if defined(HAVE_TERMIOS_H)
1447: if (tcgetattr(0, &keys) != -1)
1448: # else
1449: if (ioctl(0, TCGETA, &keys) != -1)
1450: # endif
1451: {
1452: buf[0] = keys.c_cc[VERASE];
1453: #else
1454: /* for "old" tty systems */
1455: struct sgttyb keys;
1456:
1457: if (ioctl(0, TIOCGETP, &keys) != -1)
1458: {
1459: buf[0] = keys.sg_erase;
1460: #endif
1461: buf[1] = NUL;
1462: add_termcode((char_u *)"kb", buf);
1463:
1464: /*
1465: * If <BS> and <DEL> are now the same, redefine <DEL>.
1466: */
1467: p = find_termcode((char_u *)"kD");
1468: if (p != NULL && p[0] == buf[0] && p[1] == buf[1])
1469: do_fixdel();
1470: }
1471: #if 0
1472: } /* to keep cindent happy */
1473: #endif
1474: }
1475:
1476: #ifdef USE_MOUSE
1477: /*
1478: * set mouse clicks on or off (only works for xterms)
1479: */
1480: void
1481: mch_setmouse(on)
1482: int on;
1483: {
1484: static int ison = FALSE;
1485:
1486: if (on == ison) /* return quickly if nothing to do */
1487: return;
1488:
1489: if (is_xterm(term_strings[KS_NAME]))
1490: {
1491: if (on)
1492: outstrn((char_u *)"\033[?1000h"); /* xterm: enable mouse events */
1493: else
1494: outstrn((char_u *)"\033[?1000l"); /* xterm: disable mouse events */
1495: }
1496: ison = on;
1497: }
1498: #endif
1499:
1500: /*
1501: * set screen mode, always fails.
1502: */
1503: int
1504: mch_screenmode(arg)
1505: char_u *arg;
1506: {
1507: EMSG("Screen mode setting not supported");
1508: return FAIL;
1509: }
1510:
1511: /*
1512: * Try to get the current window size:
1513: * 1. with an ioctl(), most accurate method
1514: * 2. from the environment variables LINES and COLUMNS
1515: * 3. from the termcap
1516: * 4. keep using the old values
1517: */
1518: int
1519: mch_get_winsize()
1520: {
1521: int old_Rows = Rows;
1522: int old_Columns = Columns;
1523: char_u *p;
1524:
1525: #ifdef USE_GUI
1526: if (gui.in_use)
1527: return gui_mch_get_winsize();
1528: #endif
1529:
1530: Columns = 0;
1531: Rows = 0;
1532:
1533: /*
1534: * For OS/2 use _scrsize().
1535: */
1536: # ifdef __EMX__
1537: {
1538: int s[2];
1539: _scrsize(s);
1540: Columns = s[0];
1541: Rows = s[1];
1542: }
1543: # endif
1544:
1545: /*
1546: * 1. try using an ioctl. It is the most accurate method.
1547: *
1548: * Try using TIOCGWINSZ first, some systems that have it also define TIOCGSIZE
1549: * but don't have a struct ttysize.
1550: */
1551: # ifdef TIOCGWINSZ
1552: {
1553: struct winsize ws;
1554:
1555: if (ioctl(0, TIOCGWINSZ, &ws) == 0)
1556: {
1557: Columns = ws.ws_col;
1558: Rows = ws.ws_row;
1559: }
1560: }
1561: # else /* TIOCGWINSZ */
1562: # ifdef TIOCGSIZE
1563: {
1564: struct ttysize ts;
1565:
1566: if (ioctl(0, TIOCGSIZE, &ts) == 0)
1567: {
1568: Columns = ts.ts_cols;
1569: Rows = ts.ts_lines;
1570: }
1571: }
1572: # endif /* TIOCGSIZE */
1573: # endif /* TIOCGWINSZ */
1574:
1575: /*
1576: * 2. get size from environment
1577: */
1578: if (Columns == 0 || Rows == 0)
1579: {
1580: if ((p = (char_u *)getenv("LINES")))
1581: Rows = atoi((char *)p);
1582: if ((p = (char_u *)getenv("COLUMNS")))
1583: Columns = atoi((char *)p);
1584: }
1585:
1586: #ifdef HAVE_TGETENT
1587: /*
1588: * 3. try reading the termcap
1589: */
1590: if (Columns == 0 || Rows == 0)
1591: getlinecol(); /* get "co" and "li" entries from termcap */
1592: #endif
1593:
1594: /*
1595: * 4. If everything fails, use the old values
1596: */
1597: if (Columns <= 0 || Rows <= 0)
1598: {
1599: Columns = old_Columns;
1600: Rows = old_Rows;
1601: return FAIL;
1602: }
1603:
1604: check_winsize();
1605:
1606: /* if size changed: screenalloc will allocate new screen buffers */
1607: return OK;
1608: }
1609:
1610: void
1611: mch_set_winsize()
1612: {
1613: char_u string[10];
1614:
1615: #ifdef USE_GUI
1616: if (gui.in_use)
1617: {
1618: gui_mch_set_winsize();
1619: return;
1620: }
1621: #endif
1622:
1623: /* try to set the window size to Rows and Columns */
1624: if (is_iris_ansi(term_strings[KS_NAME]))
1625: {
1626: sprintf((char *)string, "\033[203;%ld;%ld/y", Rows, Columns);
1627: outstrn(string);
1628: flushbuf();
1629: screen_start(); /* don't know where cursor is now */
1630: }
1631: }
1632:
1633: int
1634: call_shell(cmd, options)
1635: char_u *cmd;
1636: int options; /* SHELL_FILTER if called by do_filter() */
1637: /* SHELL_COOKED if term needs cooked mode */
1638: /* SHELL_EXPAND if called by ExpandWildCards() */
1639: {
1640: #ifdef USE_SYSTEM /* use system() to start the shell: simple but slow */
1641:
1642: int x;
1643: #ifndef __EMX__
1644: char_u newcmd[1024]; /* only needed for unix */
1645: #else /* __EMX__ */
1646: /*
1647: * Set the preferred shell in the EMXSHELL environment variable (but
1648: * only if it is different from what is already in the environment).
1649: * Emx then takes care of whether to use "/c" or "-c" in an
1650: * intelligent way. Simply pass the whole thing to emx's system() call.
1651: * Emx also starts an interactive shell if system() is passed an empty
1652: * string.
1653: */
1654: char_u *p, *old;
1655:
1656: if (((old = getenv("EMXSHELL")) == NULL) || strcmp(old, p_sh))
1657: {
1658: /* should check HAVE_SETENV, but I know we don't have it. */
1659: p = alloc(10 + strlen(p_sh));
1660: if (p)
1661: {
1662: sprintf(p, "EMXSHELL=%s", p_sh);
1663: putenv(p); /* don't free the pointer! */
1664: }
1665: }
1666: #endif
1667:
1668: flushbuf();
1669:
1670: if (options & SHELL_COOKED)
1671: settmode(0); /* set to cooked mode */
1672:
1673: #ifdef __EMX__
1674: if (cmd == NULL)
1675: x = system(""); /* this starts an interactive shell in emx */
1676: else
1677: x = system(cmd);
1678: if (x == -1) /* system() returns -1 when error occurs in starting shell */
1679: {
1680: MSG_OUTSTR("\nCannot execute shell ");
1681: msg_outstr(p_sh);
1682: msg_outchar('\n');
1683: }
1684: #else /* not __EMX__ */
1685: if (cmd == NULL)
1686: x = system(p_sh);
1687: else
1688: {
1689: sprintf(newcmd, "%s %s -c \"%s\"", p_sh,
1690: extra_shell_arg == NULL ? "" : (char *)extra_shell_arg,
1691: (char *)cmd);
1692: x = system(newcmd);
1693: }
1694: if (x == 127)
1695: {
1696: MSG_OUTSTR("\nCannot execute shell sh\n");
1697: }
1698: #endif /* __EMX__ */
1699: else if (x && !expand_interactively)
1700: {
1701: msg_outchar('\n');
1702: msg_outnum((long)x);
1703: MSG_OUTSTR(" returned\n");
1704: }
1705:
1706: settmode(1); /* set to raw mode */
1707: #ifdef OS2
1708: /* external command may change the window size in OS/2, so check it */
1709: mch_get_winsize();
1710: #endif
1711: resettitle();
1712: return (x ? FAIL : OK);
1713:
1714: #else /* USE_SYSTEM */ /* don't use system(), use fork()/exec() */
1715:
1716: #define EXEC_FAILED 122 /* Exit code when shell didn't execute. Don't use
1717: 127, some shell use that already */
1718:
1719: char_u newcmd[1024];
1720: int pid;
1721: #ifdef HAVE_UNION_WAIT
1722: union wait status;
1723: #else
1724: int status = -1;
1725: #endif
1726: int retval = FAIL;
1727: char **argv = NULL;
1728: int argc;
1729: int i;
1730: char_u *p;
1731: int inquote;
1732: #ifdef USE_GUI
1733: int pty_master_fd = -1; /* for pty's */
1734: int pty_slave_fd = -1;
1735: char *tty_name;
1736: int fd_toshell[2]; /* for pipes */
1737: int fd_fromshell[2];
1738: int pipe_error = FALSE;
1739: # ifdef HAVE_SETENV
1740: char envbuf[50];
1741: # else
1742: static char envbuf_Rows[20];
1743: static char envbuf_Columns[20];
1744: # endif
1745: #endif
1746: int did_settmode = FALSE; /* TRUE when settmode(1) called */
1747:
1748: flushbuf();
1749: if (options & SHELL_COOKED)
1750: settmode(0); /* set to cooked mode */
1751:
1752: /*
1753: * 1: find number of arguments
1754: * 2: separate them and built argv[]
1755: */
1756: STRCPY(newcmd, p_sh);
1757: for (i = 0; i < 2; ++i)
1758: {
1759: p = newcmd;
1760: inquote = FALSE;
1761: argc = 0;
1762: for (;;)
1763: {
1764: if (i == 1)
1765: argv[argc] = (char *)p;
1766: ++argc;
1767: while (*p && (inquote || (*p != ' ' && *p != TAB)))
1768: {
1769: if (*p == '"')
1770: inquote = !inquote;
1771: ++p;
1772: }
1773: if (*p == NUL)
1774: break;
1775: if (i == 1)
1776: *p++ = NUL;
1777: p = skipwhite(p);
1778: }
1779: if (i == 0)
1780: {
1781: argv = (char **)alloc((unsigned)((argc + 4) * sizeof(char *)));
1782: if (argv == NULL) /* out of memory */
1783: goto error;
1784: }
1785: }
1786: if (cmd != NULL)
1787: {
1788: if (extra_shell_arg != NULL)
1789: argv[argc++] = (char *)extra_shell_arg;
1790: argv[argc++] = "-c";
1791: argv[argc++] = (char *)cmd;
1792: }
1793: argv[argc] = NULL;
1794:
1795: #ifdef tower32
1796: /*
1797: * reap lost children (seems necessary on NCR Tower,
1798: * although I don't have a clue why...) (Slootman)
1799: */
1800: while (wait(&status) != 0 && errno != ECHILD)
1801: ; /* do it again, if necessary */
1802: #endif
1803:
1804: #ifdef USE_GUI
1805: /*
1806: * First try at using a pseudo-tty to get the stdin/stdout of the executed
1807: * command into the current window for the GUI.
1808: */
1809:
1810: if (gui.in_use && show_shell_mess)
1811: {
1812: /*
1813: * Try to open a master pty.
1814: * If this works, open the slave pty.
1815: * If the slave can't be opened, close the master pty.
1816: */
1817: if (p_guipty)
1818: {
1819: pty_master_fd = OpenPTY(&tty_name); /* open pty */
1820: if (pty_master_fd >= 0 && ((pty_slave_fd =
1821: open(tty_name, O_RDWR | O_EXTRA)) < 0))
1822: {
1823: close(pty_master_fd);
1824: pty_master_fd = -1;
1825: }
1826: }
1827: /*
1828: * If opening a pty didn't work, try using pipes.
1829: */
1830: if (pty_master_fd < 0)
1831: {
1832: pipe_error = (pipe(fd_toshell) < 0);
1833: if (!pipe_error) /* pipe create OK */
1834: {
1835: pipe_error = (pipe(fd_fromshell) < 0);
1836: if (pipe_error) /* pipe create failed */
1837: {
1838: close(fd_toshell[0]);
1839: close(fd_toshell[1]);
1840: }
1841: }
1842: if (pipe_error)
1843: {
1844: MSG_OUTSTR("\nCannot create pipes\n");
1845: flushbuf();
1846: }
1847: }
1848: }
1849:
1850: if (!pipe_error) /* pty or pipe opened or not used */
1851: #endif
1852:
1853: {
1854: if ((pid = fork()) == -1) /* maybe we should use vfork() */
1855: {
1856: MSG_OUTSTR("\nCannot fork\n");
1857: #ifdef USE_GUI
1858: if (gui.in_use && show_shell_mess)
1859: {
1860: if (pty_master_fd >= 0) /* close the pseudo tty */
1861: {
1862: close(pty_master_fd);
1863: close(pty_slave_fd);
1864: }
1865: else /* close the pipes */
1866: {
1867: close(fd_toshell[0]);
1868: close(fd_toshell[1]);
1869: close(fd_fromshell[0]);
1870: close(fd_fromshell[1]);
1871: }
1872: }
1873: #endif
1874: }
1875: else if (pid == 0) /* child */
1876: {
1877: reset_signals(); /* handle signals normally */
1878: if (!show_shell_mess)
1879: {
1880: int fd;
1881:
1882: /*
1883: * Don't want to show any message from the shell. Can't just
1884: * close stdout and stderr though, because some systems will
1885: * break if you try to write to them after that, so we must
1886: * use dup() to replace them with something else -- webb
1887: */
1888: fd = open("/dev/null", O_WRONLY | O_EXTRA);
1889: fclose(stdout);
1890: fclose(stderr);
1891:
1892: /*
1893: * If any of these open()'s and dup()'s fail, we just continue
1894: * anyway. It's not fatal, and on most systems it will make
1895: * no difference at all. On a few it will cause the execvp()
1896: * to exit with a non-zero status even when the completion
1897: * could be done, which is nothing too serious. If the open()
1898: * or dup() failed we'd just do the same thing ourselves
1899: * anyway -- webb
1900: */
1901: if (fd >= 0)
1902: {
1903: /* To replace stdout (file descriptor 1) */
1904: dup(fd);
1905:
1906: /* To replace stderr (file descriptor 2) */
1907: dup(fd);
1908:
1909: /* Don't need this now that we've duplicated it */
1910: close(fd);
1911: }
1912: }
1913: #ifdef USE_GUI
1914: else if (gui.in_use)
1915: {
1916:
1917: #ifdef HAVE_SETSID
1918: (void)setsid();
1919: #endif
1920: #ifdef TIOCSCTTY
1921: /* try to become controlling tty (probably doesn't work,
1922: * unless run by root) */
1923: ioctl(pty_slave_fd, TIOCSCTTY, (char *)NULL);
1924: #endif
1925: /* Simulate to have a dumb terminal (for now) */
1926: #ifdef HAVE_SETENV
1927: setenv("TERM", "dumb", 1);
1928: sprintf((char *)envbuf, "%ld", Rows);
1929: setenv("ROWS", (char *)envbuf, 1);
1930: sprintf((char *)envbuf, "%ld", Columns);
1931: setenv("COLUMNS", (char *)envbuf, 1);
1932: #else
1933: /*
1934: * Putenv does not copy the string, it has to remain valid.
1935: * Use a static array to avoid loosing allocated memory.
1936: */
1937: putenv("TERM=dumb");
1938: sprintf(envbuf_Rows, "ROWS=%ld", Rows);
1939: putenv(envbuf_Rows);
1940: sprintf(envbuf_Columns, "COLUMNS=%ld", Columns);
1941: putenv(envbuf_Columns);
1942: #endif
1943:
1944: if (pty_master_fd >= 0)
1945: {
1946: close(pty_master_fd); /* close master side of pty */
1947:
1948: /* set up stdin/stdout/stderr for the child */
1949: close(0);
1950: dup(pty_slave_fd);
1951: close(1);
1952: dup(pty_slave_fd);
1953: close(2);
1954: dup(pty_slave_fd);
1955:
1956: close(pty_slave_fd); /* has been dupped, close it now */
1957: }
1958: else
1959: {
1960: /* set up stdin for the child */
1961: close(fd_toshell[1]);
1962: close(0);
1963: dup(fd_toshell[0]);
1964: close(fd_toshell[0]);
1965:
1966: /* set up stdout for the child */
1967: close(fd_fromshell[0]);
1968: close(1);
1969: dup(fd_fromshell[1]);
1970: close(fd_fromshell[1]);
1971:
1972: /* set up stderr for the child */
1973: close(2);
1974: dup(1);
1975: }
1976: }
1977: #endif
1978: /*
1979: * There is no type cast for the argv, because the type may be
1980: * different on different machines. This may cause a warning
1981: * message with strict compilers, don't worry about it.
1982: */
1983: execvp(argv[0], argv);
1984: exit(EXEC_FAILED); /* exec failed, return failure code */
1985: }
1986: else /* parent */
1987: {
1988: /*
1989: * While child is running, ignore terminating signals.
1990: */
1991: catch_signals(SIG_IGN);
1992:
1993: #ifdef USE_GUI
1994:
1995: /*
1996: * For the GUI we redirect stdin, stdout and stderr to our window.
1997: */
1998: if (gui.in_use && show_shell_mess)
1999: {
2000: #define BUFLEN 100 /* length for buffer, pseudo tty limit is 128 */
2001: char_u buffer[BUFLEN];
2002: int len;
2003: int p_more_save;
2004: int old_State;
2005: int read_count;
2006: int c;
2007: int toshell_fd;
2008: int fromshell_fd;
2009:
2010: if (pty_master_fd >= 0)
2011: {
2012: close(pty_slave_fd); /* close slave side of pty */
2013: fromshell_fd = pty_master_fd;
2014: toshell_fd = dup(pty_master_fd);
2015: }
2016: else
2017: {
2018: close(fd_toshell[0]);
2019: close(fd_fromshell[1]);
2020: toshell_fd = fd_toshell[1];
2021: fromshell_fd = fd_fromshell[0];
2022: }
2023:
2024: /*
2025: * Write to the child if there are typed characters.
2026: * Read from the child if there are characters available.
2027: * Repeat the reading a few times if more characters are
2028: * available. Need to check for typed keys now and then, but
2029: * not too often (delays when no chars are available).
2030: * This loop is quit if no characters can be read from the pty
2031: * (WaitForChar detected special condition), or there are no
2032: * characters available and the child has exited.
2033: * Only check if the child has exited when there is no more
2034: * output. The child may exit before all the output has
2035: * been printed.
2036: *
2037: * Currently this busy loops!
2038: * This can probably dead-lock when the write blocks!
2039: */
2040: p_more_save = p_more;
2041: p_more = FALSE;
2042: old_State = State;
2043: State = EXTERNCMD; /* don't redraw at window resize */
2044:
2045: for (;;)
2046: {
2047: /*
2048: * Check if keys have been typed, write them to the child
2049: * if there are any. Don't do this if we are expanding
2050: * wild cards (would eat typeahead).
2051: */
2052: if (!(options & SHELL_EXPAND) &&
2053: (len = mch_inchar(buffer, BUFLEN - 1, 10)) != 0)
2054: {
2055: /*
2056: * For pipes:
2057: * Check for CTRL-C: sent interrupt signal to child.
2058: * Check for CTRL-D: EOF, close pipe to child.
2059: */
2060: if (len == 1 && (pty_master_fd < 0 || cmd != NULL))
2061: {
2062: #ifdef SIGINT
2063: if (buffer[0] == Ctrl('C'))
2064: {
2065: /* Use both kill() and killpg(), in case one
2066: * of the two fails */
2067: kill(pid, SIGINT);
2068: # ifdef HAVE_KILLPG
2069: killpg(0, SIGINT);
2070: # endif
2071: }
2072: #endif
2073: if (pty_master_fd < 0 && toshell_fd >= 0 &&
2074: buffer[0] == Ctrl('D'))
2075: {
2076: close(toshell_fd);
2077: toshell_fd = -1;
2078: }
2079: }
2080:
2081: /* replace K_BS by <BS> and K_DEL by <DEL> */
2082: for (i = 0; i < len; ++i)
2083: {
2084: if (buffer[i] == CSI && len - i > 2)
2085: {
2086: c = TERMCAP2KEY(buffer[i + 1], buffer[i + 2]);
2087: if (c == K_DEL || c == K_BS)
2088: {
2089: vim_memmove(buffer + i + 1, buffer + i + 3,
2090: (size_t)(len - i - 2));
2091: if (c == K_DEL)
2092: buffer[i] = DEL;
2093: else
2094: buffer[i] = Ctrl('H');
2095: len -= 2;
2096: }
2097: }
2098: else if (buffer[i] == '\r')
2099: buffer[i] = '\n';
2100: }
2101:
2102: /*
2103: * For pipes: echo the typed characters.
2104: * For a pty this does not seem to work.
2105: */
2106: if (pty_master_fd < 0)
2107: {
2108: for (i = 0; i < len; ++i)
2109: if (buffer[i] == '\n' || buffer[i] == '\b')
2110: msg_outchar(buffer[i]);
2111: else
2112: msg_outtrans_len(buffer + i, 1);
2113: windgoto(msg_row, msg_col);
2114: flushbuf();
2115: }
2116:
2117: /*
2118: * Write the characters to the child, unless EOF has
2119: * been typed for pipes. Ignore errors.
2120: */
2121: if (toshell_fd >= 0)
2122: write(toshell_fd, (char *)buffer, (size_t)len);
2123: }
2124:
2125: /*
2126: * Check if the child has any characters to be printed.
2127: * Read them and write them to our window.
2128: * Repeat this a few times as long as there is something
2129: * to do, avoid the 10ms wait for mch_inchar().
2130: * TODO: This should handle escape sequences.
2131: */
2132: for (read_count = 0; read_count < 10 &&
2133: RealWaitForChar(fromshell_fd, 10); ++read_count)
2134: {
2135: len = read(fromshell_fd, (char *)buffer,
2136: (size_t)BUFLEN);
2137: if (len == 0) /* end of file */
2138: goto finished;
2139: buffer[len] = NUL;
2140: msg_outstr(buffer);
2141: windgoto(msg_row, msg_col);
2142: cursor_on();
2143: flushbuf();
2144: }
2145:
2146: /*
2147: * Check if the child still exists when we finished
2148: * outputting all characters.
2149: */
2150: if (read_count == 0 &&
2151: #ifdef __NeXT__
2152: wait4(pid, &status, WNOHANG, (struct rusage *) 0) &&
2153: #else
2154: waitpid(pid, &status, WNOHANG) &&
2155: #endif
2156: WIFEXITED(status))
2157: break;
2158: }
2159: finished:
2160: p_more = p_more_save;
2161: State = old_State;
2162: if (toshell_fd >= 0)
2163: close(toshell_fd);
2164: close(fromshell_fd);
2165: }
2166: #endif /* USE_GUI */
2167:
2168: /*
2169: * Wait until child has exited.
2170: */
2171: #ifdef ECHILD
2172: /* Don't stop waiting when a signal (e.g. SIGWINCH) is received. */
2173: while (wait(&status) == -1 && errno != ECHILD)
2174: ;
2175: #else
2176: wait(&status);
2177: #endif
2178: /*
2179: * Set to raw mode right now, otherwise a CTRL-C after
2180: * catch_signals will kill Vim.
2181: */
2182: settmode(1);
2183: did_settmode = TRUE;
2184: catch_signals(deathtrap);
2185:
2186: /*
2187: * Check the window size, in case it changed while executing the
2188: * external command.
2189: */
2190: mch_get_winsize();
2191:
2192: if (WIFEXITED(status))
2193: {
2194: i = WEXITSTATUS(status);
2195: if (i)
2196: {
2197: if (i == EXEC_FAILED)
2198: {
2199: MSG_OUTSTR("\nCannot execute shell ");
2200: msg_outtrans(p_sh);
2201: msg_outchar('\n');
2202: }
2203: else if (!expand_interactively)
2204: {
2205: msg_outchar('\n');
2206: msg_outnum((long)i);
2207: MSG_OUTSTR(" returned\n");
2208: }
2209: }
2210: else
2211: retval = OK;
2212: }
2213: else
2214: MSG_OUTSTR("\nCommand terminated\n");
2215: }
2216: }
2217: vim_free(argv);
2218:
2219: error:
2220: if (!did_settmode)
2221: settmode(1); /* always set to raw mode */
2222: resettitle();
2223:
2224: return retval;
2225:
2226: #endif /* USE_SYSTEM */
2227: }
2228:
2229: /*
2230: * The input characters are buffered to be able to check for a CTRL-C.
2231: * This should be done with signals, but I don't know how to do that in
2232: * a portable way for a tty in RAW mode.
2233: */
2234:
2235: /*
2236: * Internal typeahead buffer. Includes extra space for long key code
2237: * descriptions which would otherwise overflow. The buffer is considered full
2238: * when only this extra space (or part of it) remains.
2239: */
2240: #define INBUFLEN 250
2241:
2242: static char_u inbuf[INBUFLEN + MAX_KEY_CODE_LEN];
2243: static int inbufcount = 0; /* number of chars in inbuf[] */
2244:
2245: /*
2246: * is_input_buf_full(), is_input_buf_empty(), add_to_input_buf(), and
2247: * trash_input_buf() are functions for manipulating the input buffer. These
2248: * are used by the gui_* calls when a GUI is used to handle keyboard input.
2249: *
2250: * NOTE: These functions will be identical in msdos.c etc, and should probably
2251: * be taken out and put elsewhere, but at the moment inbuf is only local.
2252: */
2253:
2254: int
2255: is_input_buf_full()
2256: {
2257: return (inbufcount >= INBUFLEN);
2258: }
2259:
2260: int
2261: is_input_buf_empty()
2262: {
2263: return (inbufcount == 0);
2264: }
2265:
2266: /* Add the given bytes to the input buffer */
2267: void
2268: add_to_input_buf(s, len)
2269: char_u *s;
2270: int len;
2271: {
2272: if (inbufcount + len > INBUFLEN + MAX_KEY_CODE_LEN)
2273: return; /* Shouldn't ever happen! */
2274:
2275: while (len--)
2276: inbuf[inbufcount++] = *s++;
2277: }
2278:
2279: /* Remove everything from the input buffer. Called when ^C is found */
2280: void
2281: trash_input_buf()
2282: {
2283: inbufcount = 0;
2284: }
2285:
2286: static int
2287: Read(buf, maxlen)
2288: char_u *buf;
2289: long maxlen;
2290: {
2291: if (inbufcount == 0) /* if the buffer is empty, fill it */
2292: fill_inbuf(TRUE);
2293: if (maxlen > inbufcount)
2294: maxlen = inbufcount;
2295: vim_memmove(buf, inbuf, (size_t)maxlen);
2296: inbufcount -= maxlen;
2297: if (inbufcount)
2298: vim_memmove(inbuf, inbuf + maxlen, (size_t)inbufcount);
2299: return (int)maxlen;
2300: }
2301:
2302: void
2303: mch_breakcheck()
2304: {
2305: #ifdef USE_GUI
2306: if (gui.in_use)
2307: {
2308: gui_mch_update();
2309: return;
2310: }
2311: #endif /* USE_GUI */
2312:
2313: /*
2314: * Check for CTRL-C typed by reading all available characters.
2315: * In cooked mode we should get SIGINT, no need to check.
2316: */
2317: if (curr_tmode && RealWaitForChar(0, 0L)) /* if characters available */
2318: fill_inbuf(FALSE);
2319: }
2320:
2321: static void
2322: fill_inbuf(exit_on_error)
2323: int exit_on_error;
2324: {
2325: int len;
2326: int try;
2327:
2328: #ifdef USE_GUI
2329: if (gui.in_use)
2330: {
2331: gui_mch_update();
2332: return;
2333: }
2334: #endif
2335: if (is_input_buf_full())
2336: return;
2337: /*
2338: * Fill_inbuf() is only called when we really need a character.
2339: * If we can't get any, but there is some in the buffer, just return.
2340: * If we can't get any, and there isn't any in the buffer, we give up and
2341: * exit Vim.
2342: */
2343: for (try = 0; try < 100; ++try)
2344: {
2345: len = read(0, (char *)inbuf + inbufcount,
2346: (size_t)(INBUFLEN - inbufcount));
2347: if (len > 0)
2348: break;
2349: if (!exit_on_error)
2350: return;
2351: }
2352: if (len <= 0)
2353: {
2354: windgoto((int)Rows - 1, 0);
2355: fprintf(stderr, "Vim: Error reading input, exiting...\n");
2356: ml_sync_all(FALSE, TRUE); /* preserve all swap files */
2357: getout(1);
2358: }
2359: while (len-- > 0)
2360: {
2361: /*
2362: * if a CTRL-C was typed, remove it from the buffer and set got_int
2363: */
2364: if (inbuf[inbufcount] == 3)
2365: {
2366: /* remove everything typed before the CTRL-C */
2367: vim_memmove(inbuf, inbuf + inbufcount, (size_t)(len + 1));
2368: inbufcount = 0;
2369: got_int = TRUE;
2370: }
2371: ++inbufcount;
2372: }
2373: }
2374:
2375: /*
2376: * Wait "msec" msec until a character is available from the keyboard or from
2377: * inbuf[]. msec == -1 will block forever.
2378: * When a GUI is being used, this will never get called -- webb
2379: */
2380:
2381: static int
2382: WaitForChar(msec)
2383: long msec;
2384: {
2385: if (inbufcount) /* something in inbuf[] */
2386: return 1;
2387: return RealWaitForChar(0, msec);
2388: }
2389:
2390: /*
2391: * Wait "msec" msec until a character is available from file descriptor "fd".
2392: * Time == -1 will block forever.
2393: * When a GUI is being used, this will not be used for input -- webb
2394: */
2395: static int
2396: RealWaitForChar(fd, msec)
2397: int fd;
2398: long msec;
2399: {
2400: #ifndef HAVE_SELECT
2401: struct pollfd fds;
2402:
2403: fds.fd = fd;
2404: fds.events = POLLIN;
2405: return (poll(&fds, 1, (int)msec) > 0); /* is this correct when fd != 0?? */
2406: #else
2407: struct timeval tv;
2408: fd_set rfds, efds;
2409:
2410: # ifdef __EMX__
2411: /* don't check for incoming chars if not in raw mode, because select()
2412: * always returns TRUE then (in some version of emx.dll) */
2413: if (curr_tmode == 0)
2414: return 0;
2415: # endif
2416:
2417: if (msec >= 0)
2418: {
2419: tv.tv_sec = msec / 1000;
2420: tv.tv_usec = (msec % 1000) * (1000000/1000);
2421: }
2422:
2423: /*
2424: * Select on ready for reading and exceptional condition (end of file).
2425: */
2426: FD_ZERO(&rfds); /* calls bzero() on a sun */
2427: FD_ZERO(&efds);
2428: FD_SET(fd, &rfds);
2429: FD_SET(fd, &efds);
2430: return (select(fd + 1, &rfds, NULL, &efds, (msec >= 0) ? &tv : NULL) > 0);
2431: #endif
2432: }
2433:
2434: /*
2435: * ExpandWildCards() - this code does wild-card pattern matching using the shell
2436: *
2437: * return OK for success, FAIL for error (you may lose some memory) and put
2438: * an error message in *file.
2439: *
2440: * num_pat is number of input patterns
2441: * pat is array of pointers to input patterns
2442: * num_file is pointer to number of matched file names
2443: * file is pointer to array of pointers to matched file names
2444: * On Unix we do not check for files only yet
2445: * list_notfound is ignored
2446: */
2447:
2448: extern char *mktemp __ARGS((char *));
2449: #ifndef SEEK_SET
2450: # define SEEK_SET 0
2451: #endif
2452: #ifndef SEEK_END
2453: # define SEEK_END 2
2454: #endif
2455:
2456: int
2457: ExpandWildCards(num_pat, pat, num_file, file, files_only, list_notfound)
2458: int num_pat;
2459: char_u **pat;
2460: int *num_file;
2461: char_u ***file;
2462: int files_only;
2463: int list_notfound;
2464: {
2465: int i;
2466: size_t len;
2467: char_u *p;
2468: #ifdef __EMX__
2469: # define EXPL_ALLOC_INC 16
2470: char_u **expl_files;
2471: size_t files_alloced, files_free;
2472:
2473: *num_file = 0; /* default: no files found */
2474: files_alloced = EXPL_ALLOC_INC; /* how much space is allocated */
2475: files_free = EXPL_ALLOC_INC; /* how much space is not used */
2476: *file = (char_u **) alloc(sizeof(char_u **) * files_alloced);
2477: if (!*file)
2478: {
2479: emsg(e_outofmem);
2480: return FAIL;
2481: }
2482:
2483: for (; num_pat > 0; num_pat--, pat++)
2484: {
2485: expl_files = NULL;
2486: if (vim_strchr(*pat, '$') || vim_strchr(*pat, '~'))
2487: {
2488: /* expand environment var or home dir */
2489: char_u *buf = alloc(1024);
2490: if (!buf)
2491: {
2492: emsg(e_outofmem);
2493: return FAIL;
2494: }
2495: expand_env(*pat, buf, 1024);
2496: if (mch_has_wildcard(buf)) /* still wildcards in there? */
2497: {
2498: expl_files = (char_u **)_fnexplode(buf);
2499: }
2500: if (expl_files == NULL)
2501: {
2502: /*
2503: * If no wildcard still remaining, simply add
2504: * the pattern to the results.
2505: * If wildcard did not match, add the pattern to
2506: * the list of results anyway. This way, doing
2507: * :n exist.c notexist*
2508: * will at least edits exist.c and then say
2509: * notexist* [new file]
2510: */
2511: expl_files = (char_u **)alloc(sizeof(char_u **) * 2);
2512: expl_files[0] = strsave(buf);
2513: expl_files[1] = NULL;
2514: }
2515: vim_free(buf);
2516: }
2517: else
2518: {
2519: expl_files = (char_u **)_fnexplode(*pat);
2520: if (expl_files == NULL)
2521: {
2522: /* see above for explanation */
2523: expl_files = (char_u **)alloc(sizeof(char_u **) * 2);
2524: expl_files[0] = strsave(*pat);
2525: expl_files[1] = NULL;
2526: }
2527: }
2528: if (!expl_files)
2529: {
2530: /* Can't happen */
2531: char_u msg[128];
2532: sprintf(msg, "%s (unix.c:%d)", e_internal, __LINE__);
2533: emsg(msg);
2534: *file = (char_u **)"";
2535: *num_file = 0;
2536: return OK;
2537: }
2538: /*
2539: * Count number of names resulting from expansion,
2540: * At the same time add a backslash to the end of names that happen to be
2541: * directories, and replace slashes with backslashes.
2542: */
2543: for (i = 0; (p = expl_files[i]) != NULL; i++, (*num_file)++)
2544: {
2545: if (--files_free == 0)
2546: {
2547: /* need more room in table of pointers */
2548: files_alloced += EXPL_ALLOC_INC;
2549: *file = (char_u **) realloc(*file,
2550: sizeof(char_u **) * files_alloced);
2551: files_free = EXPL_ALLOC_INC;
2552: }
2553: slash_adjust(p);
2554: if (mch_isdir(p))
2555: {
2556: len = strlen(p);
2557: p = realloc(p, len + 2);
2558: if (!p)
2559: {
2560: emsg(e_outofmem);
2561: return FAIL;
2562: }
2563: (*file)[*num_file] = p;
2564: p += len;
2565: *p++ = '\\';
2566: *p = 0;
2567: }
2568: else
2569: {
2570: (*file)[*num_file] = strsave(p);
2571: }
2572: }
2573: _fnexplodefree(expl_files);
2574: }
2575: return OK;
2576:
2577: #else /* __EMX__ */
2578:
2579: int dir;
2580: char_u tmpname[TMPNAMELEN];
2581: char_u *command;
2582: FILE *fd;
2583: char_u *buffer;
2584: int use_glob = FALSE;
2585:
2586: *num_file = 0; /* default: no files found */
2587: *file = (char_u **)"";
2588:
2589: /*
2590: * If there are no wildcards, just copy the names to allocated memory.
2591: * Saves a lot of time, because we don't have to start a new shell.
2592: */
2593: if (!have_wildcard(num_pat, pat))
2594: {
2595: *file = (char_u **)alloc(num_pat * sizeof(char_u *));
2596: if (*file == NULL)
2597: {
2598: *file = (char_u **)"";
2599: return FAIL;
2600: }
2601: for (i = 0; i < num_pat; i++)
2602: (*file)[i] = strsave(pat[i]);
2603: *num_file = num_pat;
2604: return OK;
2605: }
2606:
2607: /*
2608: * get a name for the temp file
2609: */
2610: STRCPY(tmpname, TMPNAME2);
2611: if (*mktemp((char *)tmpname) == NUL)
2612: {
2613: emsg(e_notmp);
2614: return FAIL;
2615: }
2616:
2617: /*
2618: * let the shell expand the patterns and write the result into the temp file
2619: * If we use csh, glob will work better than echo.
2620: */
2621: if ((len = STRLEN(p_sh)) >= 3 && STRCMP(p_sh + len - 3, "csh") == 0)
2622: use_glob = TRUE;
2623:
2624: len = TMPNAMELEN + 11;
2625: for (i = 0; i < num_pat; ++i) /* count the length of the patterns */
2626: len += STRLEN(pat[i]) + 3;
2627: command = alloc(len);
2628: if (command == NULL)
2629: return FAIL;
2630: if (use_glob)
2631: STRCPY(command, "glob >"); /* build the shell command */
2632: else
2633: STRCPY(command, "echo >"); /* build the shell command */
2634: STRCAT(command, tmpname);
2635: for (i = 0; i < num_pat; ++i)
2636: {
2637: #ifdef USE_SYSTEM
2638: STRCAT(command, " \""); /* need extra quotes because we */
2639: STRCAT(command, pat[i]); /* start the shell twice */
2640: STRCAT(command, "\"");
2641: #else
2642: STRCAT(command, " ");
2643: STRCAT(command, pat[i]);
2644: #endif
2645: }
2646: if (expand_interactively)
2647: show_shell_mess = FALSE;
2648: /*
2649: * If we use -f then shell variables set in .cshrc won't get expanded.
2650: * vi can do it, so we will too, but it is only necessary if there is a "$"
2651: * in one of the patterns, otherwise we can still use the fast option.
2652: */
2653: if (use_glob && !have_dollars(num_pat, pat)) /* Use csh fast option */
2654: extra_shell_arg = (char_u *)"-f";
2655: i = call_shell(command, SHELL_EXPAND); /* execute it */
2656: extra_shell_arg = NULL;
2657: show_shell_mess = TRUE;
2658: vim_free(command);
2659: if (i == FAIL) /* call_shell failed */
2660: {
2661: vim_remove(tmpname);
2662: /*
2663: * With interactive completion, the error message is not printed.
2664: * However with USE_SYSTEM, I don't know how to turn off error messages
2665: * from the shell, so screen may still get messed up -- webb.
2666: */
2667: #ifndef USE_SYSTEM
2668: if (!expand_interactively)
2669: #endif
2670: {
2671: must_redraw = CLEAR; /* probably messed up screen */
2672: msg_outchar('\n'); /* clear bottom line quickly */
2673: cmdline_row = Rows - 1; /* continue on last line */
2674: }
2675: return FAIL;
2676: }
2677:
2678: /*
2679: * read the names from the file into memory
2680: */
2681: fd = fopen((char *)tmpname, "r");
2682: if (fd == NULL)
2683: {
2684: emsg2(e_notopen, tmpname);
2685: return FAIL;
2686: }
2687: fseek(fd, 0L, SEEK_END);
2688: len = ftell(fd); /* get size of temp file */
2689: fseek(fd, 0L, SEEK_SET);
2690: buffer = alloc(len + 1);
2691: if (buffer == NULL)
2692: {
2693: vim_remove(tmpname);
2694: fclose(fd);
2695: return FAIL;
2696: }
2697: i = fread((char *)buffer, 1, len, fd);
2698: fclose(fd);
2699: vim_remove(tmpname);
2700: if (i != len)
2701: {
2702: emsg2(e_notread, tmpname);
2703: vim_free(buffer);
2704: return FAIL;
2705: }
2706:
2707: if (use_glob) /* file names are separated with NUL */
2708: {
2709: buffer[len] = NUL; /* make sure the buffers ends in NUL */
2710: i = 0;
2711: for (p = buffer; p < buffer + len; ++p)
2712: if (*p == NUL) /* count entry */
2713: ++i;
2714: if (len)
2715: ++i; /* count last entry */
2716: }
2717: else /* file names are separated with SPACE */
2718: {
2719: buffer[len] = '\n'; /* make sure the buffers ends in NL */
2720: p = buffer;
2721: for (i = 0; *p != '\n'; ++i) /* count number of entries */
2722: {
2723: while (*p != ' ' && *p != '\n') /* skip entry */
2724: ++p;
2725: p = skipwhite(p); /* skip to next entry */
2726: }
2727: }
2728: if (i == 0)
2729: {
2730: /*
2731: * Can happen when using /bin/sh and typing ":e $NO_SUCH_VAR^I".
2732: * /bin/sh will happily expand it to nothing rather than returning an
2733: * error; and hey, it's good to check anyway -- webb.
2734: */
2735: vim_free(buffer);
2736: *file = (char_u **)"";
2737: return FAIL;
2738: }
2739: *num_file = i;
2740: *file = (char_u **)alloc(sizeof(char_u *) * i);
2741: if (*file == NULL)
2742: {
2743: vim_free(buffer);
2744: *file = (char_u **)"";
2745: return FAIL;
2746: }
2747:
2748: /*
2749: * Isolate the individual file names.
2750: */
2751: p = buffer;
2752: for (i = 0; i < *num_file; ++i)
2753: {
2754: (*file)[i] = p;
2755: if (use_glob)
2756: {
2757: while (*p && p < buffer + len) /* skip entry */
2758: ++p;
2759: ++p; /* skip NUL */
2760: }
2761: else
2762: {
2763: while (*p != ' ' && *p != '\n') /* skip entry */
2764: ++p;
2765: if (*p == '\n') /* last entry */
2766: *p = NUL;
2767: else
2768: {
2769: *p++ = NUL;
2770: p = skipwhite(p); /* skip to next entry */
2771: }
2772: }
2773: }
2774:
2775: /*
2776: * Move the file names to allocated memory.
2777: */
2778: for (i = 0; i < *num_file; ++i)
2779: {
2780: /* Require the files to exist. Helps when using /bin/sh */
2781: if (expand_interactively)
2782: {
2783: struct stat st;
2784: int j;
2785:
2786: if (stat((char *)((*file)[i]), &st) < 0)
2787: {
2788: for (j = i; j + 1 < *num_file; ++j)
2789: (*file)[j] = (*file)[j + 1];
2790: --*num_file;
2791: --i;
2792: continue;
2793: }
2794: }
2795:
2796: /* if file doesn't exist don't add '/' */
2797: dir = (mch_isdir((*file)[i]));
2798: p = alloc((unsigned)(STRLEN((*file)[i]) + 1 + dir));
2799: if (p)
2800: {
2801: STRCPY(p, (*file)[i]);
2802: if (dir)
2803: STRCAT(p, "/");
2804: }
2805: (*file)[i] = p;
2806: }
2807: vim_free(buffer);
2808:
2809: if (*num_file == 0) /* rejected all entries */
2810: {
2811: vim_free(*file);
2812: *file = (char_u **)"";
2813: return FAIL;
2814: }
2815:
2816: return OK;
2817:
2818: #endif /* __EMX__ */
2819: }
2820:
2821: int
2822: mch_has_wildcard(p)
2823: char_u *p;
2824: {
2825: for ( ; *p; ++p)
2826: {
2827: if (*p == '\\' && p[1] != NUL)
2828: ++p;
2829: else if (vim_strchr((char_u *)"*?[{`~$", *p) != NULL)
2830: return TRUE;
2831: }
2832: return FALSE;
2833: }
2834:
2835: #ifndef __EMX__
2836: static int
2837: have_wildcard(num, file)
2838: int num;
2839: char_u **file;
2840: {
2841: register int i;
2842:
2843: for (i = 0; i < num; i++)
2844: if (mch_has_wildcard(file[i]))
2845: return 1;
2846: return 0;
2847: }
2848:
2849: static int
2850: have_dollars(num, file)
2851: int num;
2852: char_u **file;
2853: {
2854: register int i;
2855:
2856: for (i = 0; i < num; i++)
2857: if (vim_strchr(file[i], '$') != NULL)
2858: return TRUE;
2859: return FALSE;
2860: }
2861: #endif /* ifndef __EMX__ */
2862:
2863: #ifndef HAVE_RENAME
2864: /*
2865: * Scaled-down version of rename, which is missing in Xenix.
2866: * This version can only move regular files and will fail if the
2867: * destination exists.
2868: */
2869: int
2870: rename(src, dest)
2871: const char *src, *dest;
2872: {
2873: struct stat st;
2874:
2875: if (stat(dest, &st) >= 0) /* fail if destination exists */
2876: return -1;
2877: if (link(src, dest) != 0) /* link file to new name */
2878: return -1;
2879: if (vim_remove(src) == 0) /* delete link to old name */
2880: return 0;
2881: return -1;
2882: }
2883: #endif /* !HAVE_RENAME */