|
7
|
1 /* vi:set ts=8 sts=4 sw=4:
|
|
|
2 *
|
|
|
3 * VIM - Vi IMproved by Bram Moolenaar
|
|
|
4 * VMS port by Henk Elbers
|
|
|
5 * VMS deport by Zoltan Arpadffy
|
|
|
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 * See README.txt for an overview of the Vim source code.
|
|
|
10 */
|
|
|
11
|
|
|
12 #include "vim.h"
|
|
|
13
|
|
|
14 typedef struct
|
|
|
15 {
|
|
|
16 char class;
|
|
|
17 char type;
|
|
|
18 short width;
|
|
|
19 union
|
|
|
20 {
|
|
|
21 struct
|
|
|
22 {
|
|
|
23 char _basic[3];
|
|
|
24 char length;
|
|
|
25 } y;
|
|
|
26 int basic;
|
|
|
27 } x;
|
|
|
28 int extended;
|
|
|
29 } TT_MODE;
|
|
|
30
|
|
|
31 typedef struct
|
|
|
32 {
|
|
|
33 short buflen;
|
|
|
34 short itemcode;
|
|
|
35 char *bufadrs;
|
|
|
36 int *retlen;
|
|
|
37 } ITEM;
|
|
|
38
|
|
|
39 typedef struct
|
|
|
40 {
|
|
|
41 ITEM equ;
|
|
|
42 int nul;
|
|
|
43 } ITMLST1;
|
|
|
44
|
|
|
45 typedef struct
|
|
|
46 {
|
|
|
47 ITEM index;
|
|
|
48 ITEM string;
|
|
|
49 int nul;
|
|
|
50 } ITMLST2;
|
|
|
51
|
|
|
52 static TT_MODE orgmode;
|
|
|
53 static short iochan; /* TTY I/O channel */
|
|
|
54 static short iosb[4]; /* IO status block */
|
|
|
55
|
|
|
56 static int vms_match_num = 0;
|
|
|
57 static int vms_match_free = 0;
|
|
|
58 static char_u **vms_fmatch = NULL;
|
|
|
59 static char *Fspec_Rms; /* rms file spec, passed implicitly between routines */
|
|
|
60
|
|
|
61
|
|
|
62
|
|
|
63 static TT_MODE get_tty __ARGS((void));
|
|
|
64 static void set_tty __ARGS((int row, int col));
|
|
|
65
|
|
|
66 #define EXPL_ALLOC_INC 64
|
|
|
67
|
|
|
68 #define EQN(S1,S2,LN) (strncmp(S1,S2,LN) == 0)
|
|
|
69 #define SKIP_FOLLOWING_SLASHES(Str) while (Str[1] == '/') ++Str
|
|
|
70
|
|
|
71
|
|
|
72 /*
|
|
|
73 * vul_desc vult een descriptor met een string en de lengte
|
|
|
74 * hier van.
|
|
|
75 */
|
|
|
76 static void
|
|
|
77 vul_desc(DESC *des, char *str)
|
|
|
78 {
|
|
|
79 des->dsc$b_dtype = DSC$K_DTYPE_T;
|
|
|
80 des->dsc$b_class = DSC$K_CLASS_S;
|
|
|
81 des->dsc$a_pointer = str;
|
|
|
82 des->dsc$w_length = str ? strlen(str) : 0;
|
|
|
83 }
|
|
|
84
|
|
|
85 /*
|
|
|
86 * vul_item vult een item met een aantal waarden
|
|
|
87 */
|
|
|
88 static void
|
|
|
89 vul_item(ITEM *itm, short len, short cod, char *adr, int *ret)
|
|
|
90 {
|
|
|
91 itm->buflen = len;
|
|
|
92 itm->itemcode = cod;
|
|
|
93 itm->bufadrs = adr;
|
|
|
94 itm->retlen = ret;
|
|
|
95 }
|
|
|
96
|
|
|
97 void
|
|
|
98 mch_settmode(int tmode)
|
|
|
99 {
|
|
|
100 int status;
|
|
|
101
|
|
|
102 if ( tmode == TMODE_RAW )
|
|
|
103 set_tty(0, 0);
|
|
|
104 else{
|
|
|
105 switch (orgmode.width)
|
|
|
106 {
|
|
|
107 case 132: OUT_STR_NF((char_u *)"\033[?3h\033>"); break;
|
|
|
108 case 80: OUT_STR_NF((char_u *)"\033[?3l\033>"); break;
|
|
|
109 default: break;
|
|
|
110 }
|
|
|
111 out_flush();
|
|
|
112 status = sys$qiow(0, iochan, IO$_SETMODE, iosb, 0, 0,
|
|
|
113 &orgmode, sizeof(TT_MODE), 0,0,0,0);
|
|
|
114 if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
|
|
|
115 return;
|
|
|
116 (void)sys$dassgn(iochan);
|
|
|
117 iochan = 0;
|
|
|
118 }
|
|
|
119 }
|
|
|
120
|
|
|
121 static void
|
|
|
122 set_tty(int row, int col)
|
|
|
123 {
|
|
|
124 int status;
|
|
|
125 TT_MODE newmode; /* New TTY mode bits */
|
|
|
126 static short first_time = TRUE;
|
|
|
127
|
|
|
128 if (first_time)
|
|
|
129 {
|
|
|
130 orgmode = get_tty();
|
|
|
131 first_time = FALSE;
|
|
|
132 }
|
|
|
133 newmode = get_tty();
|
|
|
134 if (col)
|
|
|
135 newmode.width = col;
|
|
|
136 if (row)
|
|
|
137 newmode.x.y.length = row;
|
|
|
138 newmode.x.basic |= (TT$M_NOECHO | TT$M_HOSTSYNC);
|
|
|
139 newmode.x.basic &= ~TT$M_TTSYNC;
|
|
|
140 newmode.extended |= TT2$M_PASTHRU;
|
|
|
141 status = sys$qiow(0, iochan, IO$_SETMODE, iosb, 0, 0,
|
|
|
142 &newmode, sizeof(newmode), 0, 0, 0, 0);
|
|
|
143 if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
|
|
|
144 return;
|
|
|
145 }
|
|
|
146
|
|
|
147 static TT_MODE
|
|
|
148 get_tty(void)
|
|
|
149 {
|
|
|
150
|
|
|
151 static $DESCRIPTOR(odsc,"SYS$OUTPUT"); /* output descriptor */
|
|
|
152
|
|
|
153 int status;
|
|
|
154 TT_MODE tt_mode;
|
|
|
155
|
|
|
156 if (!iochan)
|
|
|
157 status = sys$assign(&odsc,&iochan,0,0);
|
|
|
158
|
|
|
159 status = sys$qiow(0, iochan, IO$_SENSEMODE, iosb, 0, 0,
|
|
|
160 &tt_mode, sizeof(tt_mode), 0, 0, 0, 0);
|
|
|
161 if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL)
|
|
|
162 {
|
|
|
163 tt_mode.width = 0;
|
|
|
164 tt_mode.type = 0;
|
|
|
165 tt_mode.class = 0;
|
|
|
166 tt_mode.x.basic = 0;
|
|
|
167 tt_mode.x.y.length = 0;
|
|
|
168 tt_mode.extended = 0;
|
|
|
169 }
|
|
|
170 return(tt_mode);
|
|
|
171 }
|
|
|
172
|
|
|
173 /*
|
|
|
174 * Get the current window size in Rows and Columns.
|
|
|
175 */
|
|
|
176 int
|
|
|
177 mch_get_shellsize(void)
|
|
|
178 {
|
|
|
179 TT_MODE tmode;
|
|
|
180
|
|
|
181 tmode = get_tty(); /* get size from VMS */
|
|
|
182 Columns = tmode.width;
|
|
|
183 Rows = tmode.x.y.length;
|
|
|
184 return OK;
|
|
|
185 }
|
|
|
186
|
|
|
187 /*
|
|
|
188 * Try to set the window size to Rows and new_Columns.
|
|
|
189 */
|
|
|
190 void
|
|
|
191 mch_set_shellsize(void)
|
|
|
192 {
|
|
|
193 set_tty(Rows, Columns);
|
|
|
194 switch (Columns)
|
|
|
195 {
|
|
|
196 case 132: OUT_STR_NF((char_u *)"\033[?3h\033>"); break;
|
|
|
197 case 80: OUT_STR_NF((char_u *)"\033[?3l\033>"); break;
|
|
|
198 default: break;
|
|
|
199 }
|
|
|
200 out_flush();
|
|
|
201 screen_start();
|
|
|
202 }
|
|
|
203
|
|
|
204 char_u *
|
|
|
205 mch_getenv(char_u *lognam)
|
|
|
206 {
|
|
|
207 DESC d_file_dev, d_lognam ;
|
|
|
208 static char buffer[LNM$C_NAMLENGTH+1];
|
|
|
209 char_u *cp = NULL;
|
|
|
210 unsigned long attrib;
|
|
|
211 int lengte = 0, dum = 0, idx = 0;
|
|
|
212 ITMLST2 itmlst;
|
|
|
213 char *sbuf = NULL;
|
|
|
214
|
|
|
215 vul_desc(&d_lognam, (char *)lognam);
|
|
|
216 vul_desc(&d_file_dev, "LNM$FILE_DEV");
|
|
|
217 attrib = LNM$M_CASE_BLIND;
|
|
|
218 vul_item(&itmlst.index, sizeof(int), LNM$_INDEX, (char *)&idx, &dum);
|
|
|
219 vul_item(&itmlst.string, LNM$C_NAMLENGTH, LNM$_STRING, buffer, &lengte);
|
|
|
220 itmlst.nul = 0;
|
|
|
221 if (sys$trnlnm(&attrib, &d_file_dev, &d_lognam, NULL,&itmlst) == SS$_NORMAL)
|
|
|
222 {
|
|
|
223 buffer[lengte] = '\0';
|
|
|
224 if (cp = (char_u *)alloc((unsigned)(lengte+1)))
|
|
|
225 strcpy((char *)cp, buffer);
|
|
|
226 return(cp);
|
|
|
227 }
|
|
|
228 else if ((sbuf = getenv((char *)lognam)))
|
|
|
229 {
|
|
|
230 lengte = strlen(sbuf) + 1;
|
|
|
231 cp = (char_u *)malloc((size_t)lengte);
|
|
|
232 if (cp)
|
|
|
233 strcpy((char *)cp, sbuf);
|
|
|
234 return cp;
|
|
|
235 }
|
|
|
236 else
|
|
|
237 return(NULL);
|
|
|
238 }
|
|
|
239
|
|
|
240 /*
|
|
|
241 * mch_setenv VMS version of setenv()
|
|
|
242 */
|
|
|
243 int
|
|
|
244 mch_setenv(char *var, char *value, int x)
|
|
|
245 {
|
|
|
246 int res, dum;
|
|
|
247 long attrib = 0L;
|
|
|
248 char acmode = PSL$C_SUPER; /* needs SYSNAM privilege */
|
|
|
249 DESC tabnam, lognam;
|
|
|
250 ITMLST1 itmlst;
|
|
|
251
|
|
|
252 vul_desc(&tabnam, "LNM$JOB");
|
|
|
253 vul_desc(&lognam, var);
|
|
|
254 vul_item(&itmlst.equ, value ? strlen(value) : 0, value ? LNM$_STRING : 0,
|
|
|
255 value, &dum);
|
|
|
256 itmlst.nul = 0;
|
|
|
257 res = sys$crelnm(&attrib, &tabnam, &lognam, &acmode, &itmlst);
|
|
|
258 return((res == 1) ? 0 : -1);
|
|
|
259 }
|
|
|
260
|
|
|
261 int
|
|
|
262 vms_sys(char *cmd, char *out, char *inp)
|
|
|
263 {
|
|
|
264 DESC cdsc, odsc, idsc;
|
|
|
265 long status;
|
|
|
266
|
|
|
267 if (cmd)
|
|
|
268 vul_desc(&cdsc, cmd);
|
|
|
269 if (out)
|
|
|
270 vul_desc(&odsc, out);
|
|
|
271 if (inp)
|
|
|
272 vul_desc(&idsc, inp);
|
|
|
273
|
|
|
274 lib$spawn(cmd ? &cdsc : NULL, /* command string */
|
|
|
275 inp ? &idsc : NULL, /* input file */
|
|
|
276 out ? &odsc : NULL, /* output file */
|
|
|
277 0, 0, 0, &status, 0, 0, 0, 0, 0, 0);
|
|
|
278 return status;
|
|
|
279 }
|
|
|
280
|
|
|
281 /*
|
|
|
282 * Convert VMS system() or lib$spawn() return code to Unix-like exit value.
|
|
|
283 */
|
|
|
284 int
|
|
|
285 vms_sys_status(int status)
|
|
|
286 {
|
|
|
287 if (status != SS$_NORMAL && (status & STS$M_SUCCESS) == 0)
|
|
|
288 return status; /* Command failed. */
|
|
|
289 return 0;
|
|
|
290 }
|
|
|
291
|
|
|
292 /*
|
|
|
293 * vms_read()
|
|
|
294 * function for low level char input
|
|
|
295 *
|
|
|
296 * Returns: input length
|
|
|
297 */
|
|
|
298 int
|
|
|
299 vms_read(char *inbuf, size_t nbytes)
|
|
|
300 {
|
|
775
|
301 int status, function, len;
|
|
|
302 TT_MODE tt_mode;
|
|
|
303 ITEM itmlst[2]; /* terminates on everything */
|
|
7
|
304 static long trm_mask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
|
|
|
305
|
|
|
306 /* whatever happened earlier we need an iochan here */
|
|
|
307 if (!iochan)
|
|
775
|
308 tt_mode = get_tty();
|
|
7
|
309
|
|
694
|
310 /* important: clean the inbuf */
|
|
7
|
311 memset(inbuf, 0, nbytes);
|
|
|
312
|
|
694
|
313 /* set up the itemlist for the first read */
|
|
|
314 vul_item(&itmlst[0], 0, TRM$_MODIFIERS,
|
|
775
|
315 (char *)( TRM$M_TM_NOECHO | TRM$M_TM_NOEDIT |
|
|
|
316 TRM$M_TM_NOFILTR | TRM$M_TM_TRMNOECHO |
|
|
|
317 TRM$M_TM_NORECALL) , 0);
|
|
694
|
318 vul_item(&itmlst[1], sizeof(trm_mask), TRM$_TERM, (char *)&trm_mask, 0);
|
|
|
319
|
|
|
320 /* wait forever for a char */
|
|
|
321 function = (IO$_READLBLK | IO$M_EXTEND);
|
|
|
322 status = sys$qiow(0, iochan, function, &iosb, 0, 0,
|
|
775
|
323 inbuf, nbytes-1, 0, 0, &itmlst, sizeof(itmlst));
|
|
694
|
324 len = strlen(inbuf); /* how many chars we got? */
|
|
|
325
|
|
1197
|
326 /* read immediately the rest in the IO queue */
|
|
694
|
327 function = (IO$_READLBLK | IO$M_TIMED | IO$M_ESCAPE | IO$M_NOECHO | IO$M_NOFILTR);
|
|
|
328 status = sys$qiow(0, iochan, function, &iosb, 0, 0,
|
|
775
|
329 inbuf+len, nbytes-1-len, 0, 0, 0, 0);
|
|
694
|
330
|
|
|
331 len = strlen(inbuf); /* return the total length */
|
|
|
332
|
|
7
|
333 return len;
|
|
|
334 }
|
|
|
335
|
|
|
336 /*
|
|
|
337 * vms_wproc() is called for each matching filename by decc$to_vms().
|
|
|
338 * We want to save each match for later retrieval.
|
|
|
339 *
|
|
|
340 * Returns: 1 - continue finding matches
|
|
1197
|
341 * 0 - stop trying to find any further matches
|
|
7
|
342 */
|
|
|
343 static int
|
|
|
344 vms_wproc(char *name, int val)
|
|
|
345 {
|
|
|
346 int i;
|
|
|
347 int nlen;
|
|
|
348 static int vms_match_alloced = 0;
|
|
|
349
|
|
1197
|
350 if (val != DECC$K_FILE) /* Directories and foreign non VMS files are not
|
|
|
351 counting */
|
|
7
|
352 return 1;
|
|
|
353
|
|
|
354 if (vms_match_num == 0) {
|
|
|
355 /* first time through, setup some things */
|
|
|
356 if (NULL == vms_fmatch) {
|
|
|
357 vms_fmatch = (char_u **)alloc(EXPL_ALLOC_INC * sizeof(char *));
|
|
|
358 if (!vms_fmatch)
|
|
|
359 return 0;
|
|
|
360 vms_match_alloced = EXPL_ALLOC_INC;
|
|
|
361 vms_match_free = EXPL_ALLOC_INC;
|
|
|
362 }
|
|
|
363 else {
|
|
|
364 /* re-use existing space */
|
|
|
365 vms_match_free = vms_match_alloced;
|
|
|
366 }
|
|
|
367 }
|
|
|
368
|
|
|
369 vms_remove_version(name);
|
|
|
370
|
|
|
371 /* convert filename to lowercase */
|
|
|
372 nlen = strlen(name);
|
|
|
373 for (i = 0; i < nlen; i++)
|
|
|
374 name[i] = TOLOWER_ASC(name[i]);
|
|
|
375
|
|
|
376 /* if name already exists, don't add it */
|
|
|
377 for (i = 0; i<vms_match_num; i++) {
|
|
|
378 if (0 == STRCMP((char_u *)name,vms_fmatch[i]))
|
|
|
379 return 1;
|
|
|
380 }
|
|
|
381 if (--vms_match_free == 0) {
|
|
|
382 /* add more space to store matches */
|
|
|
383 vms_match_alloced += EXPL_ALLOC_INC;
|
|
|
384 vms_fmatch = (char_u **)realloc(vms_fmatch,
|
|
|
385 sizeof(char **) * vms_match_alloced);
|
|
|
386 if (!vms_fmatch)
|
|
|
387 return 0;
|
|
|
388 vms_match_free = EXPL_ALLOC_INC;
|
|
|
389 }
|
|
|
390 vms_fmatch[vms_match_num] = vim_strsave((char_u *)name);
|
|
|
391
|
|
|
392 ++vms_match_num;
|
|
|
393 return 1;
|
|
|
394 }
|
|
|
395
|
|
|
396 /*
|
|
|
397 * mch_expand_wildcards this code does wild-card pattern
|
|
|
398 * matching NOT using the shell
|
|
|
399 *
|
|
|
400 * return OK for success, FAIL for error (you may loose some
|
|
|
401 * memory) and put an error message in *file.
|
|
|
402 *
|
|
|
403 * num_pat number of input patterns
|
|
|
404 * pat array of pointers to input patterns
|
|
|
405 * num_file pointer to number of matched file names
|
|
|
406 * file pointer to array of pointers to matched file names
|
|
|
407 *
|
|
|
408 */
|
|
|
409 int
|
|
|
410 mch_expand_wildcards(int num_pat, char_u **pat, int *num_file, char_u ***file, int flags)
|
|
|
411 {
|
|
|
412 int i, j = 0, cnt = 0;
|
|
|
413 char *cp;
|
|
|
414 char_u buf[MAXPATHL];
|
|
|
415 int dir;
|
|
|
416 int files_alloced, files_free;
|
|
|
417
|
|
|
418 *num_file = 0; /* default: no files found */
|
|
|
419 files_alloced = EXPL_ALLOC_INC;
|
|
|
420 files_free = EXPL_ALLOC_INC;
|
|
|
421 *file = (char_u **) alloc(sizeof(char_u **) * files_alloced);
|
|
|
422 if (*file == NULL)
|
|
|
423 {
|
|
|
424 *num_file = 0;
|
|
|
425 return FAIL;
|
|
|
426 }
|
|
|
427 for (i = 0; i < num_pat; i++)
|
|
|
428 {
|
|
|
429 /* expand environment var or home dir */
|
|
|
430 if (vim_strchr(pat[i],'$') || vim_strchr(pat[i],'~'))
|
|
|
431 expand_env(pat[i],buf,MAXPATHL);
|
|
|
432 else
|
|
|
433 STRCPY(buf,pat[i]);
|
|
|
434
|
|
|
435 vms_match_num = 0; /* reset collection counter */
|
|
|
436 cnt = decc$to_vms(decc$translate_vms(vms_fixfilename(buf)), vms_wproc, 1, 0);
|
|
|
437 /* allow wild, no dir */
|
|
|
438 if (cnt > 0)
|
|
|
439 cnt = vms_match_num;
|
|
|
440
|
|
|
441 if (cnt < 1)
|
|
|
442 continue;
|
|
|
443
|
|
|
444 for (i = 0; i < cnt; i++)
|
|
|
445 {
|
|
|
446 /* files should exist if expanding interactively */
|
|
|
447 if (!(flags & EW_NOTFOUND) && mch_getperm(vms_fmatch[i]) < 0)
|
|
|
448 continue;
|
|
715
|
449
|
|
7
|
450 /* do not include directories */
|
|
|
451 dir = (mch_isdir(vms_fmatch[i]));
|
|
|
452 if (( dir && !(flags & EW_DIR)) || (!dir && !(flags & EW_FILE)))
|
|
|
453 continue;
|
|
715
|
454
|
|
|
455 /* Skip files that are not executable if we check for that. */
|
|
|
456 if (!dir && (flags & EW_EXEC) && !mch_can_exe(vms_fmatch[i]))
|
|
|
457 continue;
|
|
|
458
|
|
7
|
459 /* allocate memory for pointers */
|
|
|
460 if (--files_free < 1)
|
|
|
461 {
|
|
|
462 files_alloced += EXPL_ALLOC_INC;
|
|
|
463 *file = (char_u **)realloc(*file,
|
|
|
464 sizeof(char_u **) * files_alloced);
|
|
|
465 if (*file == NULL)
|
|
|
466 {
|
|
|
467 *file = (char_u **)"";
|
|
|
468 *num_file = 0;
|
|
|
469 return(FAIL);
|
|
|
470 }
|
|
|
471 files_free = EXPL_ALLOC_INC;
|
|
|
472 }
|
|
|
473
|
|
|
474 (*file)[*num_file++] = vms_fmatch[i];
|
|
|
475 }
|
|
|
476 }
|
|
|
477 return OK;
|
|
|
478 }
|
|
|
479
|
|
|
480 int
|
|
|
481 mch_expandpath(garray_T *gap, char_u *path, int flags)
|
|
|
482 {
|
|
|
483 int i,cnt = 0;
|
|
|
484 char *cp;
|
|
|
485 vms_match_num = 0;
|
|
|
486
|
|
|
487 cnt = decc$to_vms(decc$translate_vms(vms_fixfilename(path)), vms_wproc, 1, 0);
|
|
|
488 /* allow wild, no dir */
|
|
|
489 if (cnt > 0)
|
|
|
490 cnt = vms_match_num;
|
|
|
491 for (i = 0; i < cnt; i++)
|
|
|
492 {
|
|
|
493 if (mch_getperm(vms_fmatch[i]) >= 0) /* add existing file */
|
|
|
494 addfile(gap, vms_fmatch[i], flags);
|
|
|
495 }
|
|
|
496 return cnt;
|
|
|
497 }
|
|
|
498
|
|
|
499 /*
|
|
|
500 * attempt to translate a mixed unix-vms file specification to pure vms
|
|
|
501 */
|
|
|
502 static void
|
|
|
503 vms_unix_mixed_filespec(char *in, char *out)
|
|
|
504 {
|
|
|
505 char *lastcolon;
|
|
|
506 char *end_of_dir;
|
|
|
507 char ch;
|
|
|
508 int len;
|
|
|
509
|
|
|
510 /* copy vms filename portion up to last colon
|
|
|
511 * (node and/or disk)
|
|
|
512 */
|
|
|
513 lastcolon = strrchr(in, ':'); /* find last colon */
|
|
|
514 if (lastcolon != NULL) {
|
|
|
515 len = lastcolon - in + 1;
|
|
|
516 strncpy(out, in, len);
|
|
|
517 out += len;
|
|
|
518 in += len;
|
|
|
519 }
|
|
|
520
|
|
|
521 end_of_dir = NULL; /* default: no directory */
|
|
|
522
|
|
|
523 /* start of directory portion */
|
|
|
524 ch = *in;
|
|
694
|
525 if ((ch == '[') || (ch == '/') || (ch == '<')) { /* start of directory(s) ? */
|
|
7
|
526 ch = '[';
|
|
|
527 SKIP_FOLLOWING_SLASHES(in);
|
|
|
528 } else if (EQN(in, "../", 3)) { /* Unix parent directory? */
|
|
|
529 *out++ = '[';
|
|
|
530 *out++ = '-';
|
|
|
531 end_of_dir = out;
|
|
|
532 ch = '.';
|
|
|
533 in += 2;
|
|
|
534 SKIP_FOLLOWING_SLASHES(in);
|
|
|
535 } else { /* not a special character */
|
|
|
536 while (EQN(in, "./", 2)) { /* Ignore Unix "current dir" */
|
|
|
537 in += 2;
|
|
|
538 SKIP_FOLLOWING_SLASHES(in);
|
|
|
539 }
|
|
|
540 if (strchr(in, '/') == NULL) { /* any more Unix directories ? */
|
|
|
541 strcpy(out, in); /* No - get rest of the spec */
|
|
|
542 return;
|
|
|
543 } else {
|
|
|
544 *out++ = '['; /* Yes, denote a Vms subdirectory */
|
|
|
545 ch = '.';
|
|
|
546 --in;
|
|
|
547 }
|
|
|
548 }
|
|
|
549
|
|
|
550 /* if we get here, there is a directory part of the filename */
|
|
|
551
|
|
|
552 /* initialize output file spec */
|
|
|
553 *out++ = ch;
|
|
|
554 ++in;
|
|
|
555
|
|
|
556 while (*in != '\0') {
|
|
|
557 ch = *in;
|
|
|
558 if ((ch == ']') || (ch == '/') || (ch == '>') ) { /* end of (sub)directory ? */
|
|
|
559 end_of_dir = out;
|
|
|
560 ch = '.';
|
|
|
561 SKIP_FOLLOWING_SLASHES(in);
|
|
|
562 }
|
|
|
563 else if (EQN(in, "../", 3)) { /* Unix parent directory? */
|
|
|
564 *out++ = '-';
|
|
|
565 end_of_dir = out;
|
|
|
566 ch = '.';
|
|
|
567 in += 2;
|
|
|
568 SKIP_FOLLOWING_SLASHES(in);
|
|
|
569 }
|
|
|
570 else {
|
|
|
571 while (EQN(in, "./", 2)) { /* Ignore Unix "current dir" */
|
|
|
572 end_of_dir = out;
|
|
|
573 in += 2;
|
|
|
574 SKIP_FOLLOWING_SLASHES(in);
|
|
|
575 ch = *in;
|
|
|
576 }
|
|
|
577 }
|
|
|
578
|
|
|
579 /* Place next character into output file spec */
|
|
|
580 *out++ = ch;
|
|
|
581 ++in;
|
|
|
582 }
|
|
|
583
|
|
|
584 *out = '\0'; /* Terminate output file spec */
|
|
|
585
|
|
|
586 if (end_of_dir != NULL) /* Terminate directory portion */
|
|
|
587 *end_of_dir = ']';
|
|
|
588 }
|
|
|
589
|
|
|
590
|
|
|
591 /*
|
|
|
592 * for decc$to_vms in vms_fixfilename
|
|
|
593 */
|
|
|
594 static int
|
|
|
595 vms_fspec_proc(char *fil, int val)
|
|
|
596 {
|
|
|
597 strcpy(Fspec_Rms,fil);
|
|
|
598 return(1);
|
|
|
599 }
|
|
|
600
|
|
|
601 /*
|
|
|
602 * change unix and mixed filenames to VMS
|
|
|
603 */
|
|
|
604 void *
|
|
|
605 vms_fixfilename(void *instring)
|
|
|
606 {
|
|
|
607 static char *buf = NULL;
|
|
|
608 static size_t buflen = 0;
|
|
|
609 size_t len;
|
|
|
610
|
|
|
611 /* get a big-enough buffer */
|
|
|
612 len = strlen(instring) + 1;
|
|
|
613 if (len > buflen)
|
|
|
614 {
|
|
|
615 buflen = len + 128;
|
|
|
616 if (buf)
|
|
|
617 buf = (char *)realloc(buf, buflen);
|
|
|
618 else
|
|
|
619 buf = (char *)calloc(buflen, sizeof(char));
|
|
|
620 }
|
|
|
621
|
|
|
622 #ifdef DEBUG
|
|
|
623 char *tmpbuf = NULL;
|
|
|
624 tmpbuf = (char *)calloc(buflen, sizeof(char));
|
|
|
625 strcpy(tmpbuf, instring);
|
|
|
626 #endif
|
|
|
627
|
|
|
628 Fspec_Rms = buf; /* for decc$to_vms */
|
|
|
629
|
|
1121
|
630 if (strchr(instring,'/') == NULL)
|
|
7
|
631 /* It is already a VMS file spec */
|
|
|
632 strcpy(buf, instring);
|
|
1121
|
633 else if (strchr(instring,'"') == NULL) /* password in the path? */
|
|
|
634 {
|
|
7
|
635 /* Seems it is a regular file, let guess that it is pure Unix fspec */
|
|
1121
|
636 if (decc$to_vms(instring, vms_fspec_proc, 0, 0) <= 0)
|
|
7
|
637 /* No... it must be mixed */
|
|
|
638 vms_unix_mixed_filespec(instring, buf);
|
|
|
639 }
|
|
|
640 else
|
|
|
641 /* we have a password in the path */
|
|
|
642 /* decc$ functions can not handle */
|
|
|
643 /* this is our only hope to resolv */
|
|
|
644 vms_unix_mixed_filespec(instring, buf);
|
|
|
645
|
|
|
646 return buf;
|
|
|
647 }
|
|
1121
|
648
|
|
7
|
649 /*
|
|
|
650 * Remove version number from file name
|
|
|
651 * we need it in some special cases as:
|
|
|
652 * creating swap file name and writing new file
|
|
|
653 */
|
|
|
654 void
|
|
|
655 vms_remove_version(void * fname)
|
|
|
656 {
|
|
|
657 char_u *cp;
|
|
|
658 char_u *fp;
|
|
|
659
|
|
|
660 if ((cp = vim_strchr( fname, ';')) != NULL) /* remove version */
|
|
|
661 *cp = '\0';
|
|
|
662 else if ((cp = vim_strrchr( fname, '.')) != NULL )
|
|
|
663 {
|
|
|
664 if ((fp = vim_strrchr( fname, ']')) != NULL ) {;}
|
|
|
665 else if ((fp = vim_strrchr( fname, '>')) != NULL ) {;}
|
|
|
666 else fp = fname;
|
|
|
667
|
|
|
668 while ( *fp != '\0' && fp < cp )
|
|
|
669 if ( *fp++ == '.' )
|
|
|
670 *cp = '\0';
|
|
|
671 }
|
|
|
672 return ;
|
|
|
673 }
|
