Mercurial > vim
annotate src/os_amiga.c @ 7805:0b6c37dd858d v7.4.1199
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Author: Bram Moolenaar <Bram@vim.org>
Date: Fri Jan 29 22:47:03 2016 +0100
patch 7.4.1199
Problem: Still using __ARGS.
Solution: Remove __ARGS in several files. (script by Hirohito Higashi)
author | Christian Brabandt <cb@256bit.org> |
---|---|
date | Fri, 29 Jan 2016 23:00:05 +0100 |
parents | 6529590f6c43 |
children | c079097365f3 |
rev | line source |
---|---|
7 | 1 /* vi:set ts=8 sts=4 sw=4: |
2 * | |
3 * VIM - Vi IMproved by Bram Moolenaar | |
4 * | |
5 * Do ":help uganda" in Vim to read copying and usage conditions. | |
6 * Do ":help credits" in Vim to see a list of people who contributed. | |
7 * See README.txt for an overview of the Vim source code. | |
8 */ | |
9 | |
10 /* | |
11 * os_amiga.c | |
12 * | |
13 * Amiga system-dependent routines. | |
14 */ | |
15 | |
16 #include "vim.h" | |
17 | |
18 #ifdef Window | |
19 # undef Window /* Amiga has its own Window definition */ | |
20 #endif | |
21 | |
22 #undef TRUE /* will be redefined by exec/types.h */ | |
23 #undef FALSE | |
24 | |
3927 | 25 /* cproto fails on missing include files, skip them */ |
26 #ifndef PROTO | |
27 | |
7 | 28 #ifndef LATTICE |
29 # include <exec/types.h> | |
30 # include <exec/exec.h> | |
31 # include <libraries/dos.h> | |
32 # include <intuition/intuition.h> | |
33 #endif | |
34 | |
1030 | 35 /* XXX These are included from os_amiga.h |
36 #include <proto/exec.h> | |
37 #include <proto/dos.h> | |
38 #include <proto/intuition.h> | |
39 */ | |
40 | |
7 | 41 #include <exec/memory.h> |
1030 | 42 #include <libraries/dosextens.h> |
7 | 43 |
44 #include <dos/dostags.h> /* for 2.0 functions */ | |
45 #include <dos/dosasl.h> | |
46 | |
1030 | 47 /* From version 4 of AmigaOS, several system structures must be allocated |
48 * and freed using system functions. "struct AnchorPath" is one. | |
49 */ | |
50 #ifdef __amigaos4__ | |
51 # include <dos/anchorpath.h> | |
52 # define free_fib(x) FreeDosObject(DOS_FIB, x) | |
53 #else | |
54 # define free_fib(x) vim_free(fib) | |
55 #endif | |
56 | |
7 | 57 #if defined(LATTICE) && !defined(SASC) && defined(FEAT_ARP) |
58 # include <libraries/arp_pragmas.h> | |
59 #endif | |
60 | |
3927 | 61 #endif /* PROTO */ |
62 | |
7 | 63 /* |
64 * At this point TRUE and FALSE are defined as 1L and 0L, but we want 1 and 0. | |
65 */ | |
66 #undef TRUE | |
67 #define TRUE (1) | |
68 #undef FALSE | |
69 #define FALSE (0) | |
70 | |
1030 | 71 #ifdef __amigaos4__ |
72 # define dos_packet(a, b, c) DoPkt(a, b, c, 0, 0, 0, 0) | |
73 #elif !defined(AZTEC_C) && !defined(__AROS__) | |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6695
diff
changeset
|
74 static long dos_packet(struct MsgPort *, long, long); |
7 | 75 #endif |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6695
diff
changeset
|
76 static int lock2name(BPTR lock, char_u *buf, long len); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6695
diff
changeset
|
77 static void out_num(long n); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6695
diff
changeset
|
78 static struct FileInfoBlock *get_fib(char_u *); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6695
diff
changeset
|
79 static int sortcmp(const void *a, const void *b); |
7 | 80 |
81 static BPTR raw_in = (BPTR)NULL; | |
82 static BPTR raw_out = (BPTR)NULL; | |
83 static int close_win = FALSE; /* set if Vim opened the window */ | |
84 | |
1030 | 85 #ifndef __amigaos4__ /* Use autoopen for AmigaOS4 */ |
7 | 86 struct IntuitionBase *IntuitionBase = NULL; |
1030 | 87 #endif |
7 | 88 #ifdef FEAT_ARP |
89 struct ArpBase *ArpBase = NULL; | |
90 #endif | |
91 | |
92 static struct Window *wb_window; | |
93 static char_u *oldwindowtitle = NULL; | |
94 | |
95 #ifdef FEAT_ARP | |
96 int dos2 = FALSE; /* Amiga DOS 2.0x or higher */ | |
97 #endif | |
98 int size_set = FALSE; /* set to TRUE if window size was set */ | |
99 | |
100 void | |
101 win_resize_on() | |
102 { | |
103 OUT_STR_NF("\033[12{"); | |
104 } | |
105 | |
106 void | |
107 win_resize_off() | |
108 { | |
109 OUT_STR_NF("\033[12}"); | |
110 } | |
111 | |
112 void | |
113 mch_write(p, len) | |
114 char_u *p; | |
115 int len; | |
116 { | |
117 Write(raw_out, (char *)p, (long)len); | |
118 } | |
119 | |
120 /* | |
4352 | 121 * mch_inchar(): low level input function. |
7 | 122 * Get a characters from the keyboard. |
123 * If time == 0 do not wait for characters. | |
124 * If time == n wait a short time for characters. | |
125 * If time == -1 wait forever for characters. | |
126 * | |
127 * Return number of characters read. | |
128 */ | |
129 int | |
130 mch_inchar(buf, maxlen, time, tb_change_cnt) | |
131 char_u *buf; | |
132 int maxlen; | |
133 long time; /* milli seconds */ | |
134 int tb_change_cnt; | |
135 { | |
136 int len; | |
137 long utime; | |
138 | |
139 if (time >= 0) | |
140 { | |
141 if (time == 0) | |
142 utime = 100L; /* time = 0 causes problems in DOS 1.2 */ | |
143 else | |
144 utime = time * 1000L; /* convert from milli to micro secs */ | |
145 if (WaitForChar(raw_in, utime) == 0) /* no character available */ | |
146 return 0; | |
147 } | |
148 else /* time == -1 */ | |
149 { | |
150 /* | |
151 * If there is no character available within 2 seconds (default) | |
208 | 152 * write the autoscript file to disk. Or cause the CursorHold event |
153 * to be triggered. | |
7 | 154 */ |
208 | 155 if (WaitForChar(raw_in, p_ut * 1000L) == 0) |
7 | 156 { |
157 #ifdef FEAT_AUTOCMD | |
610 | 158 if (trigger_cursorhold() && maxlen >= 3) |
7 | 159 { |
208 | 160 buf[0] = K_SPECIAL; |
161 buf[1] = KS_EXTRA; | |
162 buf[2] = (int)KE_CURSORHOLD; | |
163 return 3; | |
7 | 164 } |
165 #endif | |
371 | 166 before_blocking(); |
7 | 167 } |
168 } | |
169 | |
170 for (;;) /* repeat until we got a character */ | |
171 { | |
172 # ifdef FEAT_MBYTE | |
173 len = Read(raw_in, (char *)buf, (long)maxlen / input_conv.vc_factor); | |
174 # else | |
175 len = Read(raw_in, (char *)buf, (long)maxlen); | |
176 # endif | |
177 if (len > 0) | |
178 { | |
179 #ifdef FEAT_MBYTE | |
180 /* Convert from 'termencoding' to 'encoding'. */ | |
181 if (input_conv.vc_type != CONV_NONE) | |
182 len = convert_input(buf, len, maxlen); | |
183 #endif | |
184 return len; | |
185 } | |
186 } | |
187 } | |
188 | |
189 /* | |
190 * return non-zero if a character is available | |
191 */ | |
192 int | |
193 mch_char_avail() | |
194 { | |
195 return (WaitForChar(raw_in, 100L) != 0); | |
196 } | |
197 | |
198 /* | |
3634 | 199 * Return amount of memory still available in Kbyte. |
7 | 200 */ |
201 long_u | |
202 mch_avail_mem(special) | |
203 int special; | |
204 { | |
1030 | 205 #ifdef __amigaos4__ |
3634 | 206 return (long_u)AvailMem(MEMF_ANY) >> 10; |
1030 | 207 #else |
3634 | 208 return (long_u)(AvailMem(special ? (long)MEMF_CHIP : (long)MEMF_ANY)) >> 10; |
1030 | 209 #endif |
7 | 210 } |
211 | |
1030 | 212 /* |
213 * Waits a specified amount of time, or until input arrives if | |
214 * ignoreinput is FALSE. | |
215 */ | |
7 | 216 void |
217 mch_delay(msec, ignoreinput) | |
218 long msec; | |
219 int ignoreinput; | |
220 { | |
1228 | 221 #ifndef LATTICE /* SAS declares void Delay(ULONG) */ |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6695
diff
changeset
|
222 void Delay(long); |
7 | 223 #endif |
224 | |
225 if (msec > 0) | |
226 { | |
227 if (ignoreinput) | |
228 Delay(msec / 20L); /* Delay works with 20 msec intervals */ | |
229 else | |
230 WaitForChar(raw_in, msec * 1000L); | |
231 } | |
232 } | |
233 | |
234 /* | |
235 * We have no job control, fake it by starting a new shell. | |
236 */ | |
237 void | |
238 mch_suspend() | |
239 { | |
240 suspend_shell(); | |
241 } | |
242 | |
243 #ifndef DOS_LIBRARY | |
244 # define DOS_LIBRARY ((UBYTE *)"dos.library") | |
245 #endif | |
246 | |
247 void | |
248 mch_init() | |
249 { | |
250 static char intlibname[] = "intuition.library"; | |
251 | |
252 #ifdef AZTEC_C | |
253 Enable_Abort = 0; /* disallow vim to be aborted */ | |
254 #endif | |
255 Columns = 80; | |
256 Rows = 24; | |
257 | |
258 /* | |
259 * Set input and output channels, unless we have opened our own window | |
260 */ | |
261 if (raw_in == (BPTR)NULL) | |
262 { | |
263 raw_in = Input(); | |
264 raw_out = Output(); | |
265 /* | |
266 * If Input() is not interactive, then Output() will be (because of | |
267 * check in mch_check_win()). Used for "Vim -". | |
268 * Also check the other way around, for "Vim -h | more". | |
269 */ | |
270 if (!IsInteractive(raw_in)) | |
271 raw_in = raw_out; | |
272 else if (!IsInteractive(raw_out)) | |
273 raw_out = raw_in; | |
274 } | |
275 | |
276 out_flush(); | |
277 | |
278 wb_window = NULL; | |
1030 | 279 #ifndef __amigaos4__ |
7 | 280 if ((IntuitionBase = (struct IntuitionBase *) |
281 OpenLibrary((UBYTE *)intlibname, 0L)) == NULL) | |
282 { | |
283 mch_errmsg(_("cannot open ")); | |
284 mch_errmsg(intlibname); | |
285 mch_errmsg("!?\n"); | |
286 mch_exit(3); | |
287 } | |
1030 | 288 #endif |
7 | 289 } |
290 | |
3927 | 291 #ifndef PROTO |
292 # include <workbench/startup.h> | |
293 #endif | |
7 | 294 |
295 /* | |
296 * Check_win checks whether we have an interactive window. | |
297 * If not, a new window is opened with the newcli command. | |
298 * If we would open a window ourselves, the :sh and :! commands would not | |
299 * work properly (Why? probably because we are then running in a background | |
300 * CLI). This also is the best way to assure proper working in a next | |
301 * Workbench release. | |
302 * | |
303 * For the -f option (foreground mode) we open our own window and disable :sh. | |
304 * Otherwise the calling program would never know when editing is finished. | |
305 */ | |
306 #define BUF2SIZE 320 /* length of buffer for argument with complete path */ | |
307 | |
308 int | |
309 mch_check_win(argc, argv) | |
310 int argc; | |
311 char **argv; | |
312 { | |
313 int i; | |
314 BPTR nilfh, fh; | |
1030 | 315 char_u buf1[24]; |
7 | 316 char_u buf2[BUF2SIZE]; |
317 static char_u *(constrings[3]) = {(char_u *)"con:0/0/662/210/", | |
318 (char_u *)"con:0/0/640/200/", | |
319 (char_u *)"con:0/0/320/200/"}; | |
320 static char_u *winerr = (char_u *)N_("VIM: Can't open window!\n"); | |
321 struct WBArg *argp; | |
322 int ac; | |
323 char *av; | |
324 char_u *device = NULL; | |
325 int exitval = 4; | |
1030 | 326 #ifndef __amigaos4__ |
7 | 327 struct Library *DosBase; |
1030 | 328 #endif |
7 | 329 int usewin = FALSE; |
330 | |
331 /* | |
332 * check if we are running under DOS 2.0x or higher | |
333 */ | |
1030 | 334 #ifndef __amigaos4__ |
7 | 335 DosBase = OpenLibrary(DOS_LIBRARY, 37L); |
336 if (DosBase != NULL) | |
337 /* if (((struct Library *)DOSBase)->lib_Version >= 37) */ | |
338 { | |
339 CloseLibrary(DosBase); | |
1030 | 340 # ifdef FEAT_ARP |
7 | 341 dos2 = TRUE; |
1030 | 342 # endif |
7 | 343 } |
344 else /* without arp functions we NEED 2.0 */ | |
345 { | |
1030 | 346 # ifndef FEAT_ARP |
7 | 347 mch_errmsg(_("Need Amigados version 2.04 or later\n")); |
348 exit(3); | |
1030 | 349 # else |
7 | 350 /* need arp functions for dos 1.x */ |
351 if (!(ArpBase = (struct ArpBase *) OpenLibrary((UBYTE *)ArpName, ArpVersion))) | |
352 { | |
353 fprintf(stderr, _("Need %s version %ld\n"), ArpName, ArpVersion); | |
354 exit(3); | |
355 } | |
1030 | 356 # endif |
7 | 357 } |
1030 | 358 #endif /* __amigaos4__ */ |
7 | 359 |
360 /* | |
361 * scan argv[] for the "-f" and "-d" arguments | |
362 */ | |
363 for (i = 1; i < argc; ++i) | |
364 if (argv[i][0] == '-') | |
365 { | |
366 switch (argv[i][1]) | |
367 { | |
368 case 'f': | |
369 usewin = TRUE; | |
370 break; | |
371 | |
372 case 'd': | |
373 if (i < argc - 1 | |
374 #ifdef FEAT_DIFF | |
375 /* require using "-dev", "-d" means diff mode */ | |
376 && argv[i][2] == 'e' && argv[i][3] == 'v' | |
377 #endif | |
378 ) | |
379 device = (char_u *)argv[i + 1]; | |
380 break; | |
381 } | |
382 } | |
383 | |
384 /* | |
385 * If we were not started from workbench, do not have a "-d" or "-dev" | |
386 * argument and we have been started with an interactive window, use that | |
387 * window. | |
388 */ | |
389 if (argc != 0 | |
390 && device == NULL | |
391 && (IsInteractive(Input()) || IsInteractive(Output()))) | |
392 return OK; | |
393 | |
394 /* | |
395 * When given the "-f" argument, we open our own window. We can't use the | |
396 * newcli trick below, because the calling program (mail, rn, etc.) would not | |
397 * know when we are finished. | |
398 */ | |
399 if (usewin) | |
400 { | |
401 /* | |
402 * Try to open a window. First try the specified device. | |
403 * Then try a 24 line 80 column window. | |
404 * If that fails, try two smaller ones. | |
405 */ | |
406 for (i = -1; i < 3; ++i) | |
407 { | |
408 if (i >= 0) | |
409 device = constrings[i]; | |
410 if (device != NULL && (raw_in = Open((UBYTE *)device, | |
411 (long)MODE_NEWFILE)) != (BPTR)NULL) | |
412 break; | |
413 } | |
414 if (raw_in == (BPTR)NULL) /* all three failed */ | |
415 { | |
416 mch_errmsg(_(winerr)); | |
417 goto exit; | |
418 } | |
419 raw_out = raw_in; | |
420 close_win = TRUE; | |
421 return OK; | |
422 } | |
423 | |
424 if ((nilfh = Open((UBYTE *)"NIL:", (long)MODE_NEWFILE)) == (BPTR)NULL) | |
425 { | |
426 mch_errmsg(_("Cannot open NIL:\n")); | |
427 goto exit; | |
428 } | |
429 | |
430 /* | |
431 * Make a unique name for the temp file (which we will not delete!). | |
432 * Use a pointer on the stack (nobody else will be using it). | |
1030 | 433 * Under AmigaOS4, this assumption might change in the future, so |
434 * we use a pointer to the current task instead. This should be a | |
435 * shared structure and thus globally unique. | |
7 | 436 */ |
1030 | 437 #ifdef __amigaos4__ |
438 sprintf((char *)buf1, "t:nc%p", FindTask(0)); | |
439 #else | |
7 | 440 sprintf((char *)buf1, "t:nc%ld", (long)buf1); |
1030 | 441 #endif |
7 | 442 if ((fh = Open((UBYTE *)buf1, (long)MODE_NEWFILE)) == (BPTR)NULL) |
443 { | |
444 mch_errmsg(_("Cannot create ")); | |
445 mch_errmsg((char *)buf1); | |
446 mch_errmsg("\n"); | |
447 goto exit; | |
448 } | |
449 /* | |
450 * Write the command into the file, put quotes around the arguments that | |
451 * have a space in them. | |
452 */ | |
453 if (argc == 0) /* run from workbench */ | |
454 ac = ((struct WBStartup *)argv)->sm_NumArgs; | |
455 else | |
456 ac = argc; | |
457 for (i = 0; i < ac; ++i) | |
458 { | |
459 if (argc == 0) | |
460 { | |
461 *buf2 = NUL; | |
462 argp = &(((struct WBStartup *)argv)->sm_ArgList[i]); | |
463 if (argp->wa_Lock) | |
464 (void)lock2name(argp->wa_Lock, buf2, (long)(BUF2SIZE - 1)); | |
465 #ifdef FEAT_ARP | |
466 if (dos2) /* use 2.0 function */ | |
467 #endif | |
468 AddPart((UBYTE *)buf2, (UBYTE *)argp->wa_Name, (long)(BUF2SIZE - 1)); | |
469 #ifdef FEAT_ARP | |
470 else /* use arp function */ | |
471 TackOn((char *)buf2, argp->wa_Name); | |
472 #endif | |
473 av = (char *)buf2; | |
474 } | |
475 else | |
476 av = argv[i]; | |
477 | |
478 /* skip '-d' or "-dev" option */ | |
479 if (av[0] == '-' && av[1] == 'd' | |
480 #ifdef FEAT_DIFF | |
481 && av[2] == 'e' && av[3] == 'v' | |
482 #endif | |
483 ) | |
484 { | |
485 ++i; | |
486 continue; | |
487 } | |
488 if (vim_strchr((char_u *)av, ' ')) | |
489 Write(fh, "\"", 1L); | |
490 Write(fh, av, (long)strlen(av)); | |
491 if (vim_strchr((char_u *)av, ' ')) | |
492 Write(fh, "\"", 1L); | |
493 Write(fh, " ", 1L); | |
494 } | |
495 Write(fh, "\nendcli\n", 8L); | |
496 Close(fh); | |
497 | |
498 /* | |
499 * Try to open a new cli in a window. If "-d" or "-dev" argument was given try | |
500 * to open the specified device. Then try a 24 line 80 column window. If that | |
501 * fails, try two smaller ones. | |
502 */ | |
503 for (i = -1; i < 3; ++i) | |
504 { | |
505 if (i >= 0) | |
506 device = constrings[i]; | |
507 else if (device == NULL) | |
508 continue; | |
509 sprintf((char *)buf2, "newcli <nil: >nil: %s from %s", (char *)device, (char *)buf1); | |
510 #ifdef FEAT_ARP | |
511 if (dos2) | |
512 { | |
513 #endif | |
514 if (!SystemTags((UBYTE *)buf2, SYS_UserShell, TRUE, TAG_DONE)) | |
515 break; | |
516 #ifdef FEAT_ARP | |
517 } | |
518 else | |
519 { | |
520 if (Execute((UBYTE *)buf2, nilfh, nilfh)) | |
521 break; | |
522 } | |
523 #endif | |
524 } | |
525 if (i == 3) /* all three failed */ | |
526 { | |
527 DeleteFile((UBYTE *)buf1); | |
528 mch_errmsg(_(winerr)); | |
529 goto exit; | |
530 } | |
531 exitval = 0; /* The Execute succeeded: exit this program */ | |
532 | |
533 exit: | |
534 #ifdef FEAT_ARP | |
535 if (ArpBase) | |
536 CloseLibrary((struct Library *) ArpBase); | |
537 #endif | |
538 exit(exitval); | |
539 /* NOTREACHED */ | |
540 return FAIL; | |
541 } | |
542 | |
543 /* | |
544 * Return TRUE if the input comes from a terminal, FALSE otherwise. | |
545 * We fake there is a window, because we can always open one! | |
546 */ | |
547 int | |
548 mch_input_isatty() | |
549 { | |
550 return TRUE; | |
551 } | |
552 | |
553 /* | |
554 * fname_case(): Set the case of the file name, if it already exists. | |
1030 | 555 * This will cause the file name to remain exactly the same |
556 * if the file system ignores, but preserves case. | |
7 | 557 */ |
558 /*ARGSUSED*/ | |
559 void | |
560 fname_case(name, len) | |
561 char_u *name; | |
562 int len; /* buffer size, ignored here */ | |
563 { | |
564 struct FileInfoBlock *fib; | |
565 size_t flen; | |
566 | |
567 fib = get_fib(name); | |
568 if (fib != NULL) | |
569 { | |
570 flen = STRLEN(name); | |
1030 | 571 /* TODO: Check if this fix applies to AmigaOS < 4 too.*/ |
572 #ifdef __amigaos4__ | |
573 if (fib->fib_DirEntryType == ST_ROOT) | |
574 strcat(fib->fib_FileName, ":"); | |
575 #endif | |
7 | 576 if (flen == strlen(fib->fib_FileName)) /* safety check */ |
577 mch_memmove(name, fib->fib_FileName, flen); | |
1030 | 578 free_fib(fib); |
7 | 579 } |
580 } | |
581 | |
582 /* | |
583 * Get the FileInfoBlock for file "fname" | |
584 * The returned structure has to be free()d. | |
585 * Returns NULL on error. | |
586 */ | |
587 static struct FileInfoBlock * | |
588 get_fib(fname) | |
589 char_u *fname; | |
590 { | |
591 BPTR flock; | |
592 struct FileInfoBlock *fib; | |
593 | |
594 if (fname == NULL) /* safety check */ | |
595 return NULL; | |
1030 | 596 #ifdef __amigaos4__ |
597 fib = AllocDosObject(DOS_FIB,0); | |
598 #else | |
599 fib = (struct FileInfoBlock *)alloc(sizeof(struct FileInfoBlock)); | |
600 #endif | |
7 | 601 if (fib != NULL) |
602 { | |
603 flock = Lock((UBYTE *)fname, (long)ACCESS_READ); | |
604 if (flock == (BPTR)NULL || !Examine(flock, fib)) | |
605 { | |
1030 | 606 free_fib(fib); /* in case of an error the memory is freed here */ |
7 | 607 fib = NULL; |
608 } | |
609 if (flock) | |
610 UnLock(flock); | |
611 } | |
612 return fib; | |
613 } | |
614 | |
615 #ifdef FEAT_TITLE | |
616 /* | |
617 * set the title of our window | |
618 * icon name is not set | |
619 */ | |
620 void | |
621 mch_settitle(title, icon) | |
622 char_u *title; | |
623 char_u *icon; | |
624 { | |
625 if (wb_window != NULL && title != NULL) | |
626 SetWindowTitles(wb_window, (UBYTE *)title, (UBYTE *)-1L); | |
627 } | |
628 | |
629 /* | |
630 * Restore the window/icon title. | |
631 * which is one of: | |
632 * 1 Just restore title | |
633 * 2 Just restore icon (which we don't have) | |
634 * 3 Restore title and icon (which we don't have) | |
635 */ | |
636 void | |
637 mch_restore_title(which) | |
638 int which; | |
639 { | |
640 if (which & 1) | |
641 mch_settitle(oldwindowtitle, NULL); | |
642 } | |
643 | |
644 int | |
645 mch_can_restore_title() | |
646 { | |
647 return (wb_window != NULL); | |
648 } | |
649 | |
650 int | |
651 mch_can_restore_icon() | |
652 { | |
653 return FALSE; | |
654 } | |
655 #endif | |
656 | |
657 /* | |
658 * Insert user name in s[len]. | |
659 */ | |
660 int | |
661 mch_get_user_name(s, len) | |
662 char_u *s; | |
663 int len; | |
664 { | |
1030 | 665 /* TODO: Implement this. */ |
7 | 666 *s = NUL; |
667 return FAIL; | |
668 } | |
669 | |
670 /* | |
671 * Insert host name is s[len]. | |
672 */ | |
673 void | |
674 mch_get_host_name(s, len) | |
675 char_u *s; | |
676 int len; | |
677 { | |
1030 | 678 #if defined(__amigaos4__) && defined(__CLIB2__) |
679 gethostname(s, len); | |
680 #else | |
419 | 681 vim_strncpy(s, "Amiga", len - 1); |
1030 | 682 #endif |
7 | 683 } |
684 | |
685 /* | |
686 * return process ID | |
687 */ | |
688 long | |
689 mch_get_pid() | |
690 { | |
1030 | 691 #ifdef __amigaos4__ |
692 /* This is as close to a pid as we can come. We could use CLI numbers also, | |
693 * but then we would have two different types of process identifiers. | |
694 */ | |
695 return((long)FindTask(0)); | |
696 #else | |
7 | 697 return (long)0; |
1030 | 698 #endif |
7 | 699 } |
700 | |
701 /* | |
702 * Get name of current directory into buffer 'buf' of length 'len' bytes. | |
703 * Return OK for success, FAIL for failure. | |
704 */ | |
705 int | |
706 mch_dirname(buf, len) | |
707 char_u *buf; | |
708 int len; | |
709 { | |
710 return mch_FullName((char_u *)"", buf, len, FALSE); | |
711 } | |
712 | |
713 /* | |
714 * get absolute file name into buffer 'buf' of length 'len' bytes | |
715 * | |
716 * return FAIL for failure, OK otherwise | |
717 */ | |
718 int | |
719 mch_FullName(fname, buf, len, force) | |
720 char_u *fname, *buf; | |
721 int len; | |
722 int force; | |
723 { | |
724 BPTR l; | |
725 int retval = FAIL; | |
726 int i; | |
727 | |
728 /* Lock the file. If it exists, we can get the exact name. */ | |
729 if ((l = Lock((UBYTE *)fname, (long)ACCESS_READ)) != (BPTR)0) | |
730 { | |
731 retval = lock2name(l, buf, (long)len - 1); | |
732 UnLock(l); | |
733 } | |
734 else if (force || !mch_isFullName(fname)) /* not a full path yet */ | |
735 { | |
736 /* | |
737 * If the file cannot be locked (doesn't exist), try to lock the | |
738 * current directory and concatenate the file name. | |
739 */ | |
740 if ((l = Lock((UBYTE *)"", (long)ACCESS_READ)) != (BPTR)NULL) | |
741 { | |
742 retval = lock2name(l, buf, (long)len); | |
743 UnLock(l); | |
744 if (retval == OK) | |
745 { | |
746 i = STRLEN(buf); | |
747 /* Concatenate the fname to the directory. Don't add a slash | |
748 * if fname is empty, but do change "" to "/". */ | |
749 if (i == 0 || *fname != NUL) | |
750 { | |
751 if (i < len - 1 && (i == 0 || buf[i - 1] != ':')) | |
752 buf[i++] = '/'; | |
419 | 753 vim_strncpy(buf + i, fname, len - i - 1); |
7 | 754 } |
755 } | |
756 } | |
757 } | |
758 if (*buf == 0 || *buf == ':') | |
759 retval = FAIL; /* something failed; use the file name */ | |
760 return retval; | |
761 } | |
762 | |
763 /* | |
764 * Return TRUE if "fname" does not depend on the current directory. | |
765 */ | |
766 int | |
767 mch_isFullName(fname) | |
768 char_u *fname; | |
769 { | |
770 return (vim_strchr(fname, ':') != NULL && *fname != ':'); | |
771 } | |
772 | |
773 /* | |
774 * Get the full file name from a lock. Use 2.0 function if possible, because | |
775 * the arp function has more restrictions on the path length. | |
776 * | |
777 * return FAIL for failure, OK otherwise | |
778 */ | |
779 static int | |
780 lock2name(lock, buf, len) | |
781 BPTR lock; | |
782 char_u *buf; | |
783 long len; | |
784 { | |
785 #ifdef FEAT_ARP | |
786 if (dos2) /* use 2.0 function */ | |
787 #endif | |
788 return ((int)NameFromLock(lock, (UBYTE *)buf, len) ? OK : FAIL); | |
789 #ifdef FEAT_ARP | |
790 else /* use arp function */ | |
791 return ((int)PathName(lock, (char *)buf, (long)(len/32)) ? OK : FAIL); | |
792 #endif | |
793 } | |
794 | |
795 /* | |
796 * get file permissions for 'name' | |
797 * Returns -1 when it doesn't exist. | |
798 */ | |
799 long | |
800 mch_getperm(name) | |
801 char_u *name; | |
802 { | |
803 struct FileInfoBlock *fib; | |
804 long retval = -1; | |
805 | |
806 fib = get_fib(name); | |
807 if (fib != NULL) | |
808 { | |
809 retval = fib->fib_Protection; | |
1030 | 810 free_fib(fib); |
7 | 811 } |
812 return retval; | |
813 } | |
814 | |
815 /* | |
816 * set file permission for 'name' to 'perm' | |
817 * | |
818 * return FAIL for failure, OK otherwise | |
819 */ | |
820 int | |
821 mch_setperm(name, perm) | |
822 char_u *name; | |
823 long perm; | |
824 { | |
825 perm &= ~FIBF_ARCHIVE; /* reset archived bit */ | |
826 return (SetProtection((UBYTE *)name, (long)perm) ? OK : FAIL); | |
827 } | |
828 | |
829 /* | |
830 * Set hidden flag for "name". | |
831 */ | |
832 void | |
833 mch_hide(name) | |
834 char_u *name; | |
835 { | |
836 /* can't hide a file */ | |
837 } | |
838 | |
839 /* | |
840 * return FALSE if "name" is not a directory | |
841 * return TRUE if "name" is a directory. | |
842 * return FALSE for error. | |
843 */ | |
844 int | |
845 mch_isdir(name) | |
846 char_u *name; | |
847 { | |
848 struct FileInfoBlock *fib; | |
849 int retval = FALSE; | |
850 | |
851 fib = get_fib(name); | |
852 if (fib != NULL) | |
853 { | |
1030 | 854 #ifdef __amigaos4__ |
855 retval = (FIB_IS_DRAWER(fib)) ? TRUE : FALSE; | |
856 #else | |
7 | 857 retval = ((fib->fib_DirEntryType >= 0) ? TRUE : FALSE); |
1030 | 858 #endif |
859 free_fib(fib); | |
7 | 860 } |
861 return retval; | |
862 } | |
863 | |
864 /* | |
865 * Create directory "name". | |
866 */ | |
982 | 867 int |
7 | 868 mch_mkdir(name) |
869 char_u *name; | |
870 { | |
871 BPTR lock; | |
872 | |
873 lock = CreateDir(name); | |
874 if (lock != NULL) | |
982 | 875 { |
7 | 876 UnLock(lock); |
982 | 877 return 0; |
878 } | |
879 return -1; | |
7 | 880 } |
881 | |
882 /* | |
883 * Return 1 if "name" can be executed, 0 if not. | |
6695 | 884 * If "use_path" is FALSE only check if "name" is executable. |
7 | 885 * Return -1 if unknown. |
886 */ | |
887 int | |
6695 | 888 mch_can_exe(name, path, use_path) |
7 | 889 char_u *name; |
5782 | 890 char_u **path; |
6695 | 891 int use_path; |
7 | 892 { |
893 /* TODO */ | |
894 return -1; | |
895 } | |
896 | |
897 /* | |
898 * Check what "name" is: | |
899 * NODE_NORMAL: file or directory (or doesn't exist) | |
900 * NODE_WRITABLE: writable device, socket, fifo, etc. | |
901 * NODE_OTHER: non-writable things | |
902 */ | |
903 int | |
904 mch_nodetype(name) | |
905 char_u *name; | |
906 { | |
907 /* TODO */ | |
908 return NODE_NORMAL; | |
909 } | |
910 | |
911 void | |
912 mch_early_init() | |
913 { | |
914 } | |
915 | |
916 /* | |
917 * Careful: mch_exit() may be called before mch_init()! | |
918 */ | |
919 void | |
920 mch_exit(r) | |
921 int r; | |
922 { | |
923 if (raw_in) /* put terminal in 'normal' mode */ | |
924 { | |
925 settmode(TMODE_COOK); | |
926 stoptermcap(); | |
927 } | |
928 out_char('\n'); | |
929 if (raw_out) | |
930 { | |
931 if (term_console) | |
932 { | |
933 win_resize_off(); /* window resize events de-activated */ | |
934 if (size_set) | |
935 OUT_STR("\233t\233u"); /* reset window size (CSI t CSI u) */ | |
936 } | |
937 out_flush(); | |
938 } | |
939 | |
940 #ifdef FEAT_TITLE | |
941 mch_restore_title(3); /* restore window title */ | |
942 #endif | |
943 | |
944 ml_close_all(TRUE); /* remove all memfiles */ | |
945 | |
946 #ifdef FEAT_ARP | |
947 if (ArpBase) | |
948 CloseLibrary((struct Library *) ArpBase); | |
949 #endif | |
950 if (close_win) | |
951 Close(raw_in); | |
952 if (r) | |
953 printf(_("Vim exiting with %d\n"), r); /* somehow this makes :cq work!? */ | |
954 exit(r); | |
955 } | |
956 | |
957 /* | |
958 * This is a routine for setting a given stream to raw or cooked mode on the | |
959 * Amiga . This is useful when you are using Lattice C to produce programs | |
960 * that want to read single characters with the "getch()" or "fgetc" call. | |
961 * | |
962 * Written : 18-Jun-87 By Chuck McManis. | |
963 */ | |
964 | |
965 #define MP(xx) ((struct MsgPort *)((struct FileHandle *) (BADDR(xx)))->fh_Type) | |
966 | |
967 /* | |
968 * Function mch_settmode() - Convert the specified file pointer to 'raw' or | |
969 * 'cooked' mode. This only works on TTY's. | |
970 * | |
971 * Raw: keeps DOS from translating keys for you, also (BIG WIN) it means | |
972 * getch() will return immediately rather than wait for a return. You | |
973 * lose editing features though. | |
974 * | |
975 * Cooked: This function returns the designate file pointer to it's normal, | |
976 * wait for a <CR> mode. This is exactly like raw() except that | |
977 * it sends a 0 to the console to make it back into a CON: from a RAW: | |
978 */ | |
979 void | |
980 mch_settmode(tmode) | |
981 int tmode; | |
982 { | |
1030 | 983 #if defined(__AROS__) || defined(__amigaos4__) |
7 | 984 if (!SetMode(raw_in, tmode == TMODE_RAW ? 1 : 0)) |
985 #else | |
986 if (dos_packet(MP(raw_in), (long)ACTION_SCREEN_MODE, | |
987 tmode == TMODE_RAW ? -1L : 0L) == 0) | |
988 #endif | |
989 mch_errmsg(_("cannot change console mode ?!\n")); | |
990 } | |
991 | |
992 /* | |
993 * set screen mode, always fails. | |
994 */ | |
995 int | |
996 mch_screenmode(arg) | |
997 char_u *arg; | |
998 { | |
999 EMSG(_(e_screenmode)); | |
1000 return FAIL; | |
1001 } | |
1002 | |
1003 /* | |
1004 * Code for this routine came from the following : | |
1005 * | |
1006 * ConPackets.c - C. Scheppner, A. Finkel, P. Lindsay CBM | |
1007 * DOS packet example | |
1008 * Requires 1.2 | |
1009 * | |
1010 * Found on Fish Disk 56. | |
1011 * | |
1012 * Heavely modified by mool. | |
1013 */ | |
1014 | |
3927 | 1015 #ifndef PROTO |
1016 # include <devices/conunit.h> | |
1017 #endif | |
7 | 1018 |
1019 /* | |
1020 * try to get the real window size | |
1021 * return FAIL for failure, OK otherwise | |
1022 */ | |
1023 int | |
1024 mch_get_shellsize() | |
1025 { | |
1026 struct ConUnit *conUnit; | |
1030 | 1027 #ifndef __amigaos4__ |
7 | 1028 char id_a[sizeof(struct InfoData) + 3]; |
1030 | 1029 #endif |
1030 struct InfoData *id=0; | |
7 | 1031 |
1032 if (!term_console) /* not an amiga window */ | |
1030 | 1033 goto out; |
7 | 1034 |
1035 /* insure longword alignment */ | |
1030 | 1036 #ifdef __amigaos4__ |
3143 | 1037 if (!(id = AllocDosObject(DOS_INFODATA, 0))) |
1030 | 1038 goto out; |
1039 #else | |
7 | 1040 id = (struct InfoData *)(((long)id_a + 3L) & ~3L); |
1030 | 1041 #endif |
7 | 1042 |
1043 /* | |
1044 * Should make console aware of real window size, not the one we set. | |
1045 * Unfortunately, under DOS 2.0x this redraws the window and it | |
1046 * is rarely needed, so we skip it now, unless we changed the size. | |
1047 */ | |
1048 if (size_set) | |
1049 OUT_STR("\233t\233u"); /* CSI t CSI u */ | |
1050 out_flush(); | |
1051 | |
1052 #ifdef __AROS__ | |
1053 if (!Info(raw_out, id) | |
1054 || (wb_window = (struct Window *) id->id_VolumeNode) == NULL) | |
1055 #else | |
1056 if (dos_packet(MP(raw_out), (long)ACTION_DISK_INFO, ((ULONG) id) >> 2) == 0 | |
1057 || (wb_window = (struct Window *)id->id_VolumeNode) == NULL) | |
1058 #endif | |
1059 { | |
1060 /* it's not an amiga window, maybe aux device */ | |
1061 /* terminal type should be set */ | |
1062 term_console = FALSE; | |
1030 | 1063 goto out; |
7 | 1064 } |
1065 if (oldwindowtitle == NULL) | |
1066 oldwindowtitle = (char_u *)wb_window->Title; | |
1067 if (id->id_InUse == (BPTR)NULL) | |
1068 { | |
1069 mch_errmsg(_("mch_get_shellsize: not a console??\n")); | |
1070 return FAIL; | |
1071 } | |
1072 conUnit = (struct ConUnit *) ((struct IOStdReq *) id->id_InUse)->io_Unit; | |
1073 | |
1074 /* get window size */ | |
1075 Rows = conUnit->cu_YMax + 1; | |
1076 Columns = conUnit->cu_XMax + 1; | |
1077 if (Rows < 0 || Rows > 200) /* cannot be an amiga window */ | |
1078 { | |
1079 Columns = 80; | |
1080 Rows = 24; | |
1081 term_console = FALSE; | |
1082 return FAIL; | |
1083 } | |
1084 | |
1085 return OK; | |
1030 | 1086 out: |
1087 #ifdef __amigaos4__ | |
1088 FreeDosObject(DOS_INFODATA, id); /* Safe to pass NULL */ | |
1089 #endif | |
1090 | |
1091 return FAIL; | |
7 | 1092 } |
1093 | |
1094 /* | |
1095 * Try to set the real window size to Rows and Columns. | |
1096 */ | |
1097 void | |
1098 mch_set_shellsize() | |
1099 { | |
1100 if (term_console) | |
1101 { | |
1102 size_set = TRUE; | |
1103 out_char(CSI); | |
1104 out_num((long)Rows); | |
1105 out_char('t'); | |
1106 out_char(CSI); | |
1107 out_num((long)Columns); | |
1108 out_char('u'); | |
1109 out_flush(); | |
1110 } | |
1111 } | |
1112 | |
1113 /* | |
1114 * Rows and/or Columns has changed. | |
1115 */ | |
1116 void | |
1117 mch_new_shellsize() | |
1118 { | |
1119 /* Nothing to do. */ | |
1120 } | |
1121 | |
1122 /* | |
1123 * out_num - output a (big) number fast | |
1124 */ | |
1125 static void | |
1126 out_num(n) | |
1127 long n; | |
1128 { | |
1129 OUT_STR_NF(tltoa((unsigned long)n)); | |
1130 } | |
1131 | |
1030 | 1132 #if !defined(AZTEC_C) && !defined(__AROS__) && !defined(__amigaos4__) |
7 | 1133 /* |
1134 * Sendpacket.c | |
1135 * | |
1136 * An invaluable addition to your Amiga.lib file. This code sends a packet to | |
1137 * the given message port. This makes working around DOS lots easier. | |
1138 * | |
1139 * Note, I didn't write this, those wonderful folks at CBM did. I do suggest | |
1140 * however that you may wish to add it to Amiga.Lib, to do so, compile it and | |
1141 * say 'oml lib:amiga.lib -r sendpacket.o' | |
1142 */ | |
1143 | |
3927 | 1144 #ifndef PROTO |
7 | 1145 /* #include <proto/exec.h> */ |
1146 /* #include <proto/dos.h> */ | |
3927 | 1147 # include <exec/memory.h> |
1148 #endif | |
7 | 1149 |
1150 /* | |
1151 * Function - dos_packet written by Phil Lindsay, Carolyn Scheppner, and Andy | |
1152 * Finkel. This function will send a packet of the given type to the Message | |
1153 * Port supplied. | |
1154 */ | |
1155 | |
1156 static long | |
1157 dos_packet(pid, action, arg) | |
1228 | 1158 struct MsgPort *pid; /* process identifier ... (handlers message port) */ |
7 | 1159 long action, /* packet type ... (what you want handler to do) */ |
1160 arg; /* single argument */ | |
1161 { | |
1162 # ifdef FEAT_ARP | |
1163 struct MsgPort *replyport; | |
1164 struct StandardPacket *packet; | |
1165 long res1; | |
1166 | |
1167 if (dos2) | |
1168 # endif | |
1169 return DoPkt(pid, action, arg, 0L, 0L, 0L, 0L); /* use 2.0 function */ | |
1170 # ifdef FEAT_ARP | |
1171 | |
1172 replyport = (struct MsgPort *) CreatePort(NULL, 0); /* use arp function */ | |
1173 if (!replyport) | |
1174 return (0); | |
1175 | |
1176 /* Allocate space for a packet, make it public and clear it */ | |
1177 packet = (struct StandardPacket *) | |
1178 AllocMem((long) sizeof(struct StandardPacket), MEMF_PUBLIC | MEMF_CLEAR); | |
1179 if (!packet) { | |
1180 DeletePort(replyport); | |
1181 return (0); | |
1182 } | |
1183 packet->sp_Msg.mn_Node.ln_Name = (char *) &(packet->sp_Pkt); | |
1184 packet->sp_Pkt.dp_Link = &(packet->sp_Msg); | |
1185 packet->sp_Pkt.dp_Port = replyport; | |
1186 packet->sp_Pkt.dp_Type = action; | |
1187 packet->sp_Pkt.dp_Arg1 = arg; | |
1188 | |
1189 PutMsg(pid, (struct Message *)packet); /* send packet */ | |
1190 | |
1191 WaitPort(replyport); | |
1192 GetMsg(replyport); | |
1193 | |
1194 res1 = packet->sp_Pkt.dp_Res1; | |
1195 | |
1196 FreeMem(packet, (long) sizeof(struct StandardPacket)); | |
1197 DeletePort(replyport); | |
1198 | |
1199 return (res1); | |
1200 # endif | |
1201 } | |
1202 #endif /* !defined(AZTEC_C) && !defined(__AROS__) */ | |
1203 | |
1204 /* | |
1205 * Call shell. | |
1206 * Return error number for failure, 0 otherwise | |
1207 */ | |
1208 int | |
1209 mch_call_shell(cmd, options) | |
1210 char_u *cmd; | |
1211 int options; /* SHELL_*, see vim.h */ | |
1212 { | |
1213 BPTR mydir; | |
1214 int x; | |
1215 int tmode = cur_tmode; | |
1216 #ifdef AZTEC_C | |
1217 int use_execute; | |
1218 char_u *shellcmd = NULL; | |
1219 char_u *shellarg; | |
1220 #endif | |
1221 int retval = 0; | |
1222 | |
1223 if (close_win) | |
1224 { | |
1225 /* if Vim opened a window: Executing a shell may cause crashes */ | |
1226 EMSG(_("E360: Cannot execute shell with -f option")); | |
1227 return -1; | |
1228 } | |
1229 | |
1230 if (term_console) | |
1231 win_resize_off(); /* window resize events de-activated */ | |
1232 out_flush(); | |
1233 | |
1234 if (options & SHELL_COOKED) | |
1235 settmode(TMODE_COOK); /* set to normal mode */ | |
1236 mydir = Lock((UBYTE *)"", (long)ACCESS_READ); /* remember current dir */ | |
1237 | |
1238 #if !defined(AZTEC_C) /* not tested very much */ | |
1239 if (cmd == NULL) | |
1240 { | |
1241 # ifdef FEAT_ARP | |
1242 if (dos2) | |
1243 # endif | |
1244 x = SystemTags(p_sh, SYS_UserShell, TRUE, TAG_DONE); | |
1245 # ifdef FEAT_ARP | |
1246 else | |
1247 x = Execute(p_sh, raw_in, raw_out); | |
1248 # endif | |
1249 } | |
1250 else | |
1251 { | |
1252 # ifdef FEAT_ARP | |
1253 if (dos2) | |
1254 # endif | |
1255 x = SystemTags((char *)cmd, SYS_UserShell, TRUE, TAG_DONE); | |
1256 # ifdef FEAT_ARP | |
1257 else | |
1258 x = Execute((char *)cmd, 0L, raw_out); | |
1259 # endif | |
1260 } | |
1261 # ifdef FEAT_ARP | |
1262 if ((dos2 && x < 0) || (!dos2 && !x)) | |
1263 # else | |
1264 if (x < 0) | |
1265 # endif | |
1266 { | |
1267 MSG_PUTS(_("Cannot execute ")); | |
1268 if (cmd == NULL) | |
1269 { | |
1270 MSG_PUTS(_("shell ")); | |
1271 msg_outtrans(p_sh); | |
1272 } | |
1273 else | |
1274 msg_outtrans(cmd); | |
1275 msg_putchar('\n'); | |
1276 retval = -1; | |
1277 } | |
1278 # ifdef FEAT_ARP | |
1279 else if (!dos2 || x) | |
1280 # else | |
1281 else if (x) | |
1282 # endif | |
1283 { | |
1284 if ((x = IoErr()) != 0) | |
1285 { | |
1286 if (!(options & SHELL_SILENT)) | |
1287 { | |
1288 msg_putchar('\n'); | |
1289 msg_outnum((long)x); | |
1290 MSG_PUTS(_(" returned\n")); | |
1291 } | |
1292 retval = x; | |
1293 } | |
1294 } | |
1295 #else /* else part is for AZTEC_C */ | |
1296 if (p_st >= 4 || (p_st >= 2 && !(options & SHELL_FILTER))) | |
1297 use_execute = 1; | |
1298 else | |
1299 use_execute = 0; | |
1300 if (!use_execute) | |
1301 { | |
1302 /* | |
1303 * separate shell name from argument | |
1304 */ | |
1305 shellcmd = vim_strsave(p_sh); | |
1306 if (shellcmd == NULL) /* out of memory, use Execute */ | |
1307 use_execute = 1; | |
1308 else | |
1309 { | |
1310 shellarg = skiptowhite(shellcmd); /* find start of arguments */ | |
1311 if (*shellarg != NUL) | |
1312 { | |
1313 *shellarg++ = NUL; | |
1314 shellarg = skipwhite(shellarg); | |
1315 } | |
1316 } | |
1317 } | |
1318 if (cmd == NULL) | |
1319 { | |
1320 if (use_execute) | |
1321 { | |
1322 # ifdef FEAT_ARP | |
1323 if (dos2) | |
1324 # endif | |
1325 x = SystemTags((UBYTE *)p_sh, SYS_UserShell, TRUE, TAG_DONE); | |
1326 # ifdef FEAT_ARP | |
1327 else | |
1328 x = !Execute((UBYTE *)p_sh, raw_in, raw_out); | |
1329 # endif | |
1330 } | |
1331 else | |
1332 x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg, NULL); | |
1333 } | |
1334 else if (use_execute) | |
1335 { | |
1336 # ifdef FEAT_ARP | |
1337 if (dos2) | |
1338 # endif | |
1339 x = SystemTags((UBYTE *)cmd, SYS_UserShell, TRUE, TAG_DONE); | |
1340 # ifdef FEAT_ARP | |
1341 else | |
1342 x = !Execute((UBYTE *)cmd, 0L, raw_out); | |
1343 # endif | |
1344 } | |
1345 else if (p_st & 1) | |
1346 x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg, | |
1347 (char *)cmd, NULL); | |
1348 else | |
1349 x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg, | |
1350 (char *)p_shcf, (char *)cmd, NULL); | |
1351 # ifdef FEAT_ARP | |
1352 if ((dos2 && x < 0) || (!dos2 && x)) | |
1353 # else | |
1354 if (x < 0) | |
1355 # endif | |
1356 { | |
1357 MSG_PUTS(_("Cannot execute ")); | |
1358 if (use_execute) | |
1359 { | |
1360 if (cmd == NULL) | |
1361 msg_outtrans(p_sh); | |
1362 else | |
1363 msg_outtrans(cmd); | |
1364 } | |
1365 else | |
1366 { | |
1367 MSG_PUTS(_("shell ")); | |
1368 msg_outtrans(shellcmd); | |
1369 } | |
1370 msg_putchar('\n'); | |
1371 retval = -1; | |
1372 } | |
1373 else | |
1374 { | |
1375 if (use_execute) | |
1376 { | |
1377 # ifdef FEAT_ARP | |
1378 if (!dos2 || x) | |
1379 # else | |
1380 if (x) | |
1381 # endif | |
1382 x = IoErr(); | |
1383 } | |
1384 else | |
1385 x = wait(); | |
1386 if (x) | |
1387 { | |
1388 if (!(options & SHELL_SILENT) && !emsg_silent) | |
1389 { | |
1390 msg_putchar('\n'); | |
1391 msg_outnum((long)x); | |
1392 MSG_PUTS(_(" returned\n")); | |
1393 } | |
1394 retval = x; | |
1395 } | |
1396 } | |
1397 vim_free(shellcmd); | |
1398 #endif /* AZTEC_C */ | |
1399 | |
1400 if ((mydir = CurrentDir(mydir)) != 0) /* make sure we stay in the same directory */ | |
1401 UnLock(mydir); | |
1402 if (tmode == TMODE_RAW) | |
1403 settmode(TMODE_RAW); /* set to raw mode */ | |
1404 #ifdef FEAT_TITLE | |
1405 resettitle(); | |
1406 #endif | |
1407 if (term_console) | |
1408 win_resize_on(); /* window resize events activated */ | |
1409 return retval; | |
1410 } | |
1411 | |
1412 /* | |
1413 * check for an "interrupt signal" | |
1414 * We only react to a CTRL-C, but also clear the other break signals to avoid | |
1415 * trouble with lattice-c programs. | |
1416 */ | |
1417 void | |
1418 mch_breakcheck() | |
1419 { | |
1420 if (SetSignal(0L, (long)(SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D|SIGBREAKF_CTRL_E|SIGBREAKF_CTRL_F)) & SIGBREAKF_CTRL_C) | |
1421 got_int = TRUE; | |
1422 } | |
1423 | |
1424 /* this routine causes manx to use this Chk_Abort() rather than it's own */ | |
1425 /* otherwise it resets our ^C when doing any I/O (even when Enable_Abort */ | |
1426 /* is zero). Since we want to check for our own ^C's */ | |
1427 | |
1428 #ifdef _DCC | |
1429 #define Chk_Abort chkabort | |
1430 #endif | |
1431 | |
1432 #ifdef LATTICE | |
1433 void __regargs __chkabort(void); | |
1434 | |
1435 void __regargs __chkabort(void) | |
1436 {} | |
1437 | |
1438 #else | |
1439 long | |
1440 Chk_Abort(void) | |
1441 { | |
1442 return(0L); | |
1443 } | |
1444 #endif | |
1445 | |
1446 /* | |
1447 * mch_expandpath() - this code does wild-card pattern matching using the arp | |
1448 * routines. | |
1449 * | |
1450 * "pat" has backslashes before chars that are not to be expanded. | |
1451 * Returns the number of matches found. | |
1452 * | |
1453 * This is based on WildDemo2.c (found in arp1.1 distribution). | |
1454 * That code's copyright follows: | |
1455 * Copyright (c) 1987, Scott Ballantyne | |
1456 * Use and abuse as you please. | |
1457 */ | |
1458 | |
1030 | 1459 #ifdef __amigaos4__ |
1460 # define ANCHOR_BUF_SIZE 1024 | |
1461 #else | |
1462 # define ANCHOR_BUF_SIZE (512) | |
1463 # define ANCHOR_SIZE (sizeof(struct AnchorPath) + ANCHOR_BUF_SIZE) | |
1464 #endif | |
7 | 1465 |
1466 int | |
1467 mch_expandpath(gap, pat, flags) | |
1468 garray_T *gap; | |
1469 char_u *pat; | |
1470 int flags; /* EW_* flags */ | |
1471 { | |
1472 struct AnchorPath *Anchor; | |
1473 LONG Result; | |
1474 char_u *starbuf, *sp, *dp; | |
1475 int start_len; | |
1476 int matches; | |
1030 | 1477 #ifdef __amigaos4__ |
1478 struct TagItem AnchorTags[] = { | |
1479 {ADO_Strlen, ANCHOR_BUF_SIZE}, | |
1480 {ADO_Flags, APF_DODOT|APF_DOWILD|APF_MultiAssigns}, | |
1481 {TAG_DONE, 0L} | |
1482 }; | |
1483 #endif | |
7 | 1484 |
1485 start_len = gap->ga_len; | |
1486 | |
1487 /* Get our AnchorBase */ | |
1030 | 1488 #ifdef __amigaos4__ |
1489 Anchor = AllocDosObject(DOS_ANCHORPATH, AnchorTags); | |
1490 #else | |
7 | 1491 Anchor = (struct AnchorPath *)alloc_clear((unsigned)ANCHOR_SIZE); |
1030 | 1492 #endif |
7 | 1493 if (Anchor == NULL) |
1494 return 0; | |
1495 | |
1030 | 1496 #ifndef __amigaos4__ |
7 | 1497 Anchor->ap_Strlen = ANCHOR_BUF_SIZE; /* ap_Length not supported anymore */ |
1030 | 1498 # ifdef APF_DODOT |
7 | 1499 Anchor->ap_Flags = APF_DODOT | APF_DOWILD; /* allow '.' for current dir */ |
1030 | 1500 # else |
7 | 1501 Anchor->ap_Flags = APF_DoDot | APF_DoWild; /* allow '.' for current dir */ |
1030 | 1502 # endif |
7 | 1503 #endif |
1504 | |
1505 #ifdef FEAT_ARP | |
1506 if (dos2) | |
1507 { | |
1508 #endif | |
1509 /* hack to replace '*' by '#?' */ | |
1510 starbuf = alloc((unsigned)(2 * STRLEN(pat) + 1)); | |
1511 if (starbuf == NULL) | |
1512 goto Return; | |
1513 for (sp = pat, dp = starbuf; *sp; ++sp) | |
1514 { | |
1515 if (*sp == '*') | |
1516 { | |
1517 *dp++ = '#'; | |
1518 *dp++ = '?'; | |
1519 } | |
1520 else | |
1521 *dp++ = *sp; | |
1522 } | |
1523 *dp = NUL; | |
1524 Result = MatchFirst((UBYTE *)starbuf, Anchor); | |
1525 vim_free(starbuf); | |
1526 #ifdef FEAT_ARP | |
1527 } | |
1528 else | |
1529 Result = FindFirst((char *)pat, Anchor); | |
1530 #endif | |
1531 | |
1532 /* | |
1533 * Loop to get all matches. | |
1534 */ | |
1535 while (Result == 0) | |
1536 { | |
1030 | 1537 #ifdef __amigaos4__ |
1538 addfile(gap, (char_u *)Anchor->ap_Buffer, flags); | |
1539 #else | |
7 | 1540 addfile(gap, (char_u *)Anchor->ap_Buf, flags); |
1030 | 1541 #endif |
7 | 1542 #ifdef FEAT_ARP |
1543 if (dos2) | |
1544 #endif | |
1545 Result = MatchNext(Anchor); | |
1546 #ifdef FEAT_ARP | |
1547 else | |
1548 Result = FindNext(Anchor); | |
1549 #endif | |
1550 } | |
1551 matches = gap->ga_len - start_len; | |
1552 | |
1553 if (Result == ERROR_BUFFER_OVERFLOW) | |
1554 EMSG(_("ANCHOR_BUF_SIZE too small.")); | |
1555 else if (matches == 0 && Result != ERROR_OBJECT_NOT_FOUND | |
1556 && Result != ERROR_DEVICE_NOT_MOUNTED | |
1557 && Result != ERROR_NO_MORE_ENTRIES) | |
1558 EMSG(_("I/O ERROR")); | |
1559 | |
1560 /* | |
1561 * Sort the files for this pattern. | |
1562 */ | |
1563 if (matches) | |
1564 qsort((void *)(((char_u **)gap->ga_data) + start_len), | |
1565 (size_t)matches, sizeof(char_u *), sortcmp); | |
1566 | |
1567 /* Free the wildcard stuff */ | |
1568 #ifdef FEAT_ARP | |
1569 if (dos2) | |
1570 #endif | |
1571 MatchEnd(Anchor); | |
1572 #ifdef FEAT_ARP | |
1573 else | |
1574 FreeAnchorChain(Anchor); | |
1575 #endif | |
1576 | |
1577 Return: | |
1030 | 1578 #ifdef __amigaos4__ |
1579 FreeDosObject(DOS_ANCHORPATH, Anchor); | |
1580 #else | |
7 | 1581 vim_free(Anchor); |
1030 | 1582 #endif |
7 | 1583 |
1584 return matches; | |
1585 } | |
1586 | |
1587 static int | |
1588 sortcmp(a, b) | |
1589 const void *a, *b; | |
1590 { | |
1591 char *s = *(char **)a; | |
1592 char *t = *(char **)b; | |
1593 | |
39 | 1594 return pathcmp(s, t, -1); |
7 | 1595 } |
1596 | |
1597 /* | |
1598 * Return TRUE if "p" has wildcards that can be expanded by mch_expandpath(). | |
1599 */ | |
1600 int | |
1601 mch_has_exp_wildcard(p) | |
1602 char_u *p; | |
1603 { | |
39 | 1604 for ( ; *p; mb_ptr_adv(p)) |
7 | 1605 { |
1606 if (*p == '\\' && p[1] != NUL) | |
1607 ++p; | |
1608 else if (vim_strchr((char_u *)"*?[(#", *p) != NULL) | |
1609 return TRUE; | |
1610 } | |
1611 return FALSE; | |
1612 } | |
1613 | |
1614 int | |
1615 mch_has_wildcard(p) | |
1616 char_u *p; | |
1617 { | |
39 | 1618 for ( ; *p; mb_ptr_adv(p)) |
7 | 1619 { |
1620 if (*p == '\\' && p[1] != NUL) | |
1621 ++p; | |
1622 else | |
1623 if (vim_strchr((char_u *) | |
1624 # ifdef VIM_BACKTICK | |
1625 "*?[(#$`" | |
1626 # else | |
1627 "*?[(#$" | |
1628 # endif | |
1629 , *p) != NULL | |
1630 || (*p == '~' && p[1] != NUL)) | |
1631 return TRUE; | |
1632 } | |
1633 return FALSE; | |
1634 } | |
1635 | |
1636 /* | |
1637 * With AmigaDOS 2.0 support for reading local environment variables | |
1638 * | |
1639 * Two buffers are allocated: | |
1640 * - A big one to do the expansion into. It is freed before returning. | |
1641 * - A small one to hold the return value. It is kept until the next call. | |
1642 */ | |
1643 char_u * | |
1644 mch_getenv(var) | |
1645 char_u *var; | |
1646 { | |
1647 int len; | |
1648 UBYTE *buf; /* buffer to expand in */ | |
1649 char_u *retval; /* return value */ | |
1650 static char_u *alloced = NULL; /* allocated memory */ | |
1651 | |
1652 #ifdef FEAT_ARP | |
1653 if (!dos2) | |
1654 retval = (char_u *)getenv((char *)var); | |
1655 else | |
1656 #endif | |
1657 { | |
1658 vim_free(alloced); | |
1659 alloced = NULL; | |
1660 retval = NULL; | |
1661 | |
1662 buf = alloc(IOSIZE); | |
1663 if (buf == NULL) | |
1664 return NULL; | |
1665 | |
1666 len = GetVar((UBYTE *)var, buf, (long)(IOSIZE - 1), (long)0); | |
1667 if (len >= 0) | |
1668 { | |
1669 retval = vim_strsave((char_u *)buf); | |
1670 alloced = retval; | |
1671 } | |
1672 | |
1673 vim_free(buf); | |
1674 } | |
1675 | |
1676 /* if $VIM is not defined, use "vim:" instead */ | |
1677 if (retval == NULL && STRCMP(var, "VIM") == 0) | |
1678 retval = (char_u *)"vim:"; | |
1679 | |
1680 return retval; | |
1681 } | |
1682 | |
1683 /* | |
1684 * Amiga version of setenv() with AmigaDOS 2.0 support. | |
1685 */ | |
1686 /* ARGSUSED */ | |
1687 int | |
1688 mch_setenv(var, value, x) | |
1689 char *var; | |
1690 char *value; | |
1691 int x; | |
1692 { | |
1693 #ifdef FEAT_ARP | |
1694 if (!dos2) | |
1695 return setenv(var, value); | |
1696 #endif | |
1697 | |
1698 if (SetVar((UBYTE *)var, (UBYTE *)value, (LONG)-1, (ULONG)GVF_LOCAL_ONLY)) | |
1699 return 0; /* success */ | |
1700 return -1; /* failure */ | |
1701 } |