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 {
|
|
301 int status, function, len;
|
|
302 TT_MODE tt_mode;
|
|
303 ITEM itmlst[2];
|
|
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)
|
|
308 tt_mode = get_tty();
|
|
309
|
|
310 vul_item(&itmlst[0], 0, TRM$_MODIFIERS,
|
|
311 (char *)(TRM$M_TM_ESCAPE | TRM$M_TM_NOECHO | TRM$M_TM_NOEDIT |
|
|
312 TRM$M_TM_NOFILTR | TRM$M_TM_NORECALL | TRM$M_TM_TRMNOECHO), 0);
|
|
313 vul_item(&itmlst[1], sizeof(trm_mask), TRM$_TERM, (char *)&trm_mask, 0);
|
|
314
|
|
315 function = (IO$_READLBLK | IO$M_EXTEND);
|
|
316 memset(inbuf, 0, nbytes);
|
|
317
|
|
318 while (1)
|
|
319 {
|
|
320 status = sys$qiow(0, iochan, function, &iosb, 0, 0, inbuf, nbytes - 1,
|
|
321 0, 0, &itmlst, sizeof(itmlst));
|
|
322 len = strlen(inbuf);
|
|
323 if (len > 0)
|
|
324 break;
|
|
325 }
|
|
326 return len;
|
|
327 }
|
|
328
|
|
329 /*
|
|
330 * vms_wproc() is called for each matching filename by decc$to_vms().
|
|
331 * We want to save each match for later retrieval.
|
|
332 *
|
|
333 * Returns: 1 - continue finding matches
|
|
334 * 0 - stop trying to find any further mathces
|
|
335 */
|
|
336 static int
|
|
337 vms_wproc(char *name, int val)
|
|
338 {
|
|
339 int i;
|
|
340 int nlen;
|
|
341 static int vms_match_alloced = 0;
|
|
342
|
|
343 if (val != DECC$K_FILE) /* Directories and foreing non VMS files are not counting */
|
|
344 return 1;
|
|
345
|
|
346 if (vms_match_num == 0) {
|
|
347 /* first time through, setup some things */
|
|
348 if (NULL == vms_fmatch) {
|
|
349 vms_fmatch = (char_u **)alloc(EXPL_ALLOC_INC * sizeof(char *));
|
|
350 if (!vms_fmatch)
|
|
351 return 0;
|
|
352 vms_match_alloced = EXPL_ALLOC_INC;
|
|
353 vms_match_free = EXPL_ALLOC_INC;
|
|
354 }
|
|
355 else {
|
|
356 /* re-use existing space */
|
|
357 vms_match_free = vms_match_alloced;
|
|
358 }
|
|
359 }
|
|
360
|
|
361 vms_remove_version(name);
|
|
362
|
|
363 /* convert filename to lowercase */
|
|
364 nlen = strlen(name);
|
|
365 for (i = 0; i < nlen; i++)
|
|
366 name[i] = TOLOWER_ASC(name[i]);
|
|
367
|
|
368 /* if name already exists, don't add it */
|
|
369 for (i = 0; i<vms_match_num; i++) {
|
|
370 if (0 == STRCMP((char_u *)name,vms_fmatch[i]))
|
|
371 return 1;
|
|
372 }
|
|
373 if (--vms_match_free == 0) {
|
|
374 /* add more space to store matches */
|
|
375 vms_match_alloced += EXPL_ALLOC_INC;
|
|
376 vms_fmatch = (char_u **)realloc(vms_fmatch,
|
|
377 sizeof(char **) * vms_match_alloced);
|
|
378 if (!vms_fmatch)
|
|
379 return 0;
|
|
380 vms_match_free = EXPL_ALLOC_INC;
|
|
381 }
|
|
382 vms_fmatch[vms_match_num] = vim_strsave((char_u *)name);
|
|
383
|
|
384 ++vms_match_num;
|
|
385 return 1;
|
|
386 }
|
|
387
|
|
388 /*
|
|
389 * mch_expand_wildcards this code does wild-card pattern
|
|
390 * matching NOT using the shell
|
|
391 *
|
|
392 * return OK for success, FAIL for error (you may loose some
|
|
393 * memory) and put an error message in *file.
|
|
394 *
|
|
395 * num_pat number of input patterns
|
|
396 * pat array of pointers to input patterns
|
|
397 * num_file pointer to number of matched file names
|
|
398 * file pointer to array of pointers to matched file names
|
|
399 *
|
|
400 */
|
|
401 int
|
|
402 mch_expand_wildcards(int num_pat, char_u **pat, int *num_file, char_u ***file, int flags)
|
|
403 {
|
|
404 int i, j = 0, cnt = 0;
|
|
405 char *cp;
|
|
406 char_u buf[MAXPATHL];
|
|
407 int dir;
|
|
408 int files_alloced, files_free;
|
|
409
|
|
410 *num_file = 0; /* default: no files found */
|
|
411 files_alloced = EXPL_ALLOC_INC;
|
|
412 files_free = EXPL_ALLOC_INC;
|
|
413 *file = (char_u **) alloc(sizeof(char_u **) * files_alloced);
|
|
414 if (*file == NULL)
|
|
415 {
|
|
416 *num_file = 0;
|
|
417 return FAIL;
|
|
418 }
|
|
419 for (i = 0; i < num_pat; i++)
|
|
420 {
|
|
421 /* expand environment var or home dir */
|
|
422 if (vim_strchr(pat[i],'$') || vim_strchr(pat[i],'~'))
|
|
423 expand_env(pat[i],buf,MAXPATHL);
|
|
424 else
|
|
425 STRCPY(buf,pat[i]);
|
|
426
|
|
427 vms_match_num = 0; /* reset collection counter */
|
|
428 cnt = decc$to_vms(decc$translate_vms(vms_fixfilename(buf)), vms_wproc, 1, 0);
|
|
429 /* allow wild, no dir */
|
|
430 if (cnt > 0)
|
|
431 cnt = vms_match_num;
|
|
432
|
|
433 if (cnt < 1)
|
|
434 continue;
|
|
435
|
|
436 for (i = 0; i < cnt; i++)
|
|
437 {
|
|
438 /* files should exist if expanding interactively */
|
|
439 if (!(flags & EW_NOTFOUND) && mch_getperm(vms_fmatch[i]) < 0)
|
|
440 continue;
|
|
441 /* do not include directories */
|
|
442 dir = (mch_isdir(vms_fmatch[i]));
|
|
443 if (( dir && !(flags & EW_DIR)) || (!dir && !(flags & EW_FILE)))
|
|
444 continue;
|
|
445 /* allocate memory for pointers */
|
|
446 if (--files_free < 1)
|
|
447 {
|
|
448 files_alloced += EXPL_ALLOC_INC;
|
|
449 *file = (char_u **)realloc(*file,
|
|
450 sizeof(char_u **) * files_alloced);
|
|
451 if (*file == NULL)
|
|
452 {
|
|
453 *file = (char_u **)"";
|
|
454 *num_file = 0;
|
|
455 return(FAIL);
|
|
456 }
|
|
457 files_free = EXPL_ALLOC_INC;
|
|
458 }
|
|
459
|
|
460 (*file)[*num_file++] = vms_fmatch[i];
|
|
461 }
|
|
462 }
|
|
463 return OK;
|
|
464 }
|
|
465
|
|
466 int
|
|
467 mch_expandpath(garray_T *gap, char_u *path, int flags)
|
|
468 {
|
|
469 int i,cnt = 0;
|
|
470 char *cp;
|
|
471 vms_match_num = 0;
|
|
472
|
|
473 cnt = decc$to_vms(decc$translate_vms(vms_fixfilename(path)), vms_wproc, 1, 0);
|
|
474 /* allow wild, no dir */
|
|
475 if (cnt > 0)
|
|
476 cnt = vms_match_num;
|
|
477 for (i = 0; i < cnt; i++)
|
|
478 {
|
|
479 if (mch_getperm(vms_fmatch[i]) >= 0) /* add existing file */
|
|
480 addfile(gap, vms_fmatch[i], flags);
|
|
481 }
|
|
482 return cnt;
|
|
483 }
|
|
484
|
|
485 /*
|
|
486 * attempt to translate a mixed unix-vms file specification to pure vms
|
|
487 */
|
|
488 static void
|
|
489 vms_unix_mixed_filespec(char *in, char *out)
|
|
490 {
|
|
491 char *lastcolon;
|
|
492 char *end_of_dir;
|
|
493 char ch;
|
|
494 int len;
|
|
495
|
|
496 /* copy vms filename portion up to last colon
|
|
497 * (node and/or disk)
|
|
498 */
|
|
499 lastcolon = strrchr(in, ':'); /* find last colon */
|
|
500 if (lastcolon != NULL) {
|
|
501 len = lastcolon - in + 1;
|
|
502 strncpy(out, in, len);
|
|
503 out += len;
|
|
504 in += len;
|
|
505 }
|
|
506
|
|
507 end_of_dir = NULL; /* default: no directory */
|
|
508
|
|
509 /* start of directory portion */
|
|
510 ch = *in;
|
|
511 if ((ch == '[') || (ch == '/') || (ch == '<') ) { /* start of directory(s) ? */
|
|
512 ch = '[';
|
|
513 SKIP_FOLLOWING_SLASHES(in);
|
|
514 } else if (EQN(in, "../", 3)) { /* Unix parent directory? */
|
|
515 *out++ = '[';
|
|
516 *out++ = '-';
|
|
517 end_of_dir = out;
|
|
518 ch = '.';
|
|
519 in += 2;
|
|
520 SKIP_FOLLOWING_SLASHES(in);
|
|
521 } else { /* not a special character */
|
|
522 while (EQN(in, "./", 2)) { /* Ignore Unix "current dir" */
|
|
523 in += 2;
|
|
524 SKIP_FOLLOWING_SLASHES(in);
|
|
525 }
|
|
526 if (strchr(in, '/') == NULL) { /* any more Unix directories ? */
|
|
527 strcpy(out, in); /* No - get rest of the spec */
|
|
528 return;
|
|
529 } else {
|
|
530 *out++ = '['; /* Yes, denote a Vms subdirectory */
|
|
531 ch = '.';
|
|
532 --in;
|
|
533 }
|
|
534 }
|
|
535
|
|
536 /* if we get here, there is a directory part of the filename */
|
|
537
|
|
538 /* initialize output file spec */
|
|
539 *out++ = ch;
|
|
540 ++in;
|
|
541
|
|
542 while (*in != '\0') {
|
|
543 ch = *in;
|
|
544 if ((ch == ']') || (ch == '/') || (ch == '>') ) { /* end of (sub)directory ? */
|
|
545 end_of_dir = out;
|
|
546 ch = '.';
|
|
547 SKIP_FOLLOWING_SLASHES(in);
|
|
548 }
|
|
549 else if (EQN(in, "../", 3)) { /* Unix parent directory? */
|
|
550 *out++ = '-';
|
|
551 end_of_dir = out;
|
|
552 ch = '.';
|
|
553 in += 2;
|
|
554 SKIP_FOLLOWING_SLASHES(in);
|
|
555 }
|
|
556 else {
|
|
557 while (EQN(in, "./", 2)) { /* Ignore Unix "current dir" */
|
|
558 end_of_dir = out;
|
|
559 in += 2;
|
|
560 SKIP_FOLLOWING_SLASHES(in);
|
|
561 ch = *in;
|
|
562 }
|
|
563 }
|
|
564
|
|
565 /* Place next character into output file spec */
|
|
566 *out++ = ch;
|
|
567 ++in;
|
|
568 }
|
|
569
|
|
570 *out = '\0'; /* Terminate output file spec */
|
|
571
|
|
572 if (end_of_dir != NULL) /* Terminate directory portion */
|
|
573 *end_of_dir = ']';
|
|
574 }
|
|
575
|
|
576
|
|
577 /*
|
|
578 * for decc$to_vms in vms_fixfilename
|
|
579 */
|
|
580 static int
|
|
581 vms_fspec_proc(char *fil, int val)
|
|
582 {
|
|
583 strcpy(Fspec_Rms,fil);
|
|
584 return(1);
|
|
585 }
|
|
586
|
|
587 /*
|
|
588 * change unix and mixed filenames to VMS
|
|
589 */
|
|
590 void *
|
|
591 vms_fixfilename(void *instring)
|
|
592 {
|
|
593 static char *buf = NULL;
|
|
594 static size_t buflen = 0;
|
|
595 size_t len;
|
|
596
|
|
597 /* get a big-enough buffer */
|
|
598 len = strlen(instring) + 1;
|
|
599 if (len > buflen)
|
|
600 {
|
|
601 buflen = len + 128;
|
|
602 if (buf)
|
|
603 buf = (char *)realloc(buf, buflen);
|
|
604 else
|
|
605 buf = (char *)calloc(buflen, sizeof(char));
|
|
606 }
|
|
607
|
|
608 #ifdef DEBUG
|
|
609 char *tmpbuf = NULL;
|
|
610 tmpbuf = (char *)calloc(buflen, sizeof(char));
|
|
611 strcpy(tmpbuf, instring);
|
|
612 #endif
|
|
613
|
|
614 Fspec_Rms = buf; /* for decc$to_vms */
|
|
615
|
|
616 if ( strchr(instring,'/') == NULL )
|
|
617 /* It is already a VMS file spec */
|
|
618 strcpy(buf, instring);
|
|
619 else if ( strchr(instring,'"') == NULL ){ /* password in the path ? */
|
|
620 /* Seems it is a regular file, let guess that it is pure Unix fspec */
|
|
621 if ( decc$to_vms(instring, vms_fspec_proc, 0, 0) <= 0 )
|
|
622 /* No... it must be mixed */
|
|
623 vms_unix_mixed_filespec(instring, buf);
|
|
624 }
|
|
625 else
|
|
626 /* we have a password in the path */
|
|
627 /* decc$ functions can not handle */
|
|
628 /* this is our only hope to resolv */
|
|
629 vms_unix_mixed_filespec(instring, buf);
|
|
630
|
|
631 return buf;
|
|
632 }
|
|
633 /*
|
|
634 * Remove version number from file name
|
|
635 * we need it in some special cases as:
|
|
636 * creating swap file name and writing new file
|
|
637 */
|
|
638 void
|
|
639 vms_remove_version(void * fname)
|
|
640 {
|
|
641 char_u *cp;
|
|
642 char_u *fp;
|
|
643
|
|
644 if ((cp = vim_strchr( fname, ';')) != NULL) /* remove version */
|
|
645 *cp = '\0';
|
|
646 else if ((cp = vim_strrchr( fname, '.')) != NULL )
|
|
647 {
|
|
648 if ((fp = vim_strrchr( fname, ']')) != NULL ) {;}
|
|
649 else if ((fp = vim_strrchr( fname, '>')) != NULL ) {;}
|
|
650 else fp = fname;
|
|
651
|
|
652 while ( *fp != '\0' && fp < cp )
|
|
653 if ( *fp++ == '.' )
|
|
654 *cp = '\0';
|
|
655 }
|
|
656 return ;
|
|
657 }
|