?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Save the variable buffer content, not a potentially old pointer to it.
[make.git] / vmsify.c
blob237ee86d7a8b18b1b523cb8fa1221918f96b4fb4
1 /* vmsify.c -- Module for vms <-> unix file name conversion
2 Copyright (C) 1996-2012 Free Software Foundation, Inc.
3 This file is part of GNU Make.
4
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
8 version.
9
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License along with
15 this program. If not, see <http://www.gnu.org/licenses/>. */
16
17 /* Written by Klaus Kämpf (kkaempf@progis.de)
18 of proGIS Software, Aachen, Germany */
19
20
21 #include <stdio.h>
22 #include <string.h>
23 #include <ctype.h>
24
25 #if VMS
26 #include <unixlib.h>
27 #include <stdlib.h>
28 #include <jpidef.h>
29 #include <descrip.h>
30 #include <uaidef.h>
31 #include <ssdef.h>
32 #include <starlet.h>
33 #include <lib$routines.h>
34 /* Initialize a string descriptor (struct dsc$descriptor_s) for an
35 arbitrary string. ADDR is a pointer to the first character
36 of the string, and LEN is the length of the string. */
37
38 #define INIT_DSC_S(dsc, addr, len) do { \
39 (dsc).dsc$b_dtype = DSC$K_DTYPE_T; \
40 (dsc).dsc$b_class = DSC$K_CLASS_S; \
41 (dsc).dsc$w_length = (len); \
42 (dsc).dsc$a_pointer = (addr); \
43 } while (0)
44
45 /* Initialize a string descriptor (struct dsc$descriptor_s) for a
46 NUL-terminated string. S is a pointer to the string; the length
47 is determined by calling strlen(). */
48
49 #define INIT_DSC_CSTRING(dsc, s) INIT_DSC_S(dsc, s, strlen(s))
50 #endif
51
52 /*
53 copy 'from' to 'to' up to but not including 'upto'
54 return 0 if eos on from
55 return 1 if upto found
56
57 return 'to' at last char + 1
58 return 'from' at match + 1 or eos if no match
59
60 if as_dir == 1, change all '.' to '_'
61 else change all '.' but the last to '_'
62 */
63
64 static int
65 copyto (char **to, const char **from, char upto, int as_dir)
66 {
67 const char *s;
68
69 s = strrchr (*from, '.');
70
71 while (**from)
72 {
73 if (**from == upto)
74 {
75 do
76 {
77 (*from)++;
78 }
79 while (**from == upto);
80 return 1;
81 }
82 if (**from == '.')
83 {
84 if ((as_dir == 1)
85 || (*from != s))
86 **to = '_';
87 else
88 **to = '.';
89 }
90 else
91 {
92 #ifdef HAVE_CASE_INSENSITIVE_FS
93 if (isupper ((unsigned char)**from))
94 **to = tolower ((unsigned char)**from);
95 else
96 #endif
97 **to = **from;
98 }
99 (*to)++;
100 (*from)++;
101 }
102
103 return 0;
104 }
105
106
107 /*
108 get translation of logical name
109
110 */
111
112 static char *
113 trnlog (const char *name)
114 {
115 int stat;
116 static char reslt[1024];
117 $DESCRIPTOR (reslt_dsc, reslt);
118 short resltlen;
119 struct dsc$descriptor_s name_dsc;
120 char *s;
121
122 /*
123 * the string isn't changed, but there is no string descriptor with
124 * "const char *dsc$a_pointer"
125 */
126 INIT_DSC_CSTRING (name_dsc, (char *)name);
127
128 stat = lib$sys_trnlog (&name_dsc, &resltlen, &reslt_dsc);
129
130 if ((stat&1) == 0)
131 {
132 return "";
133 }
134 if (stat == SS$_NOTRAN)
135 {
136 return "";
137 }
138 reslt[resltlen] = '\0';
139
140 s = malloc (resltlen+1);
141 if (s == 0)
142 return "";
143 strcpy (s, reslt);
144 return s;
145 }
146
147 static char *
148 showall (char *s)
149 {
150 static char t[512];
151 char *pt;
152
153 pt = t;
154 if (strchr (s, '\\') == 0)
155 return s;
156 while (*s)
157 {
158 if (*s == '\\')
159 {
160 *pt++ = *s;
161 }
162 *pt++ = *s++;
163 }
164 return pt;
165 }
166
167
168 enum namestate { N_START, N_DEVICE, N_OPEN, N_DOT, N_CLOSED, N_DONE };
169
170 /*
171 convert unix style name to vms style
172 type = 0 -> name is a full name (directory and filename part)
173 type = 1 -> name is a directory
174 type = 2 -> name is a filename without directory
175
176 The following conversions are applied
177 (0) (1) (2)
178 input full name dir name file name
179
180 1 ./ <cwd> [] <current directory>.dir
181 2 ../ <home of cwd> <home of cwd> <home of cwd>.dir
182
183 3 // <dev of cwd>: <dev of cwd>:[000000] <dev of cwd>:000000.dir
184 4 //a a: a: a:
185 5 //a/ a: a: a:000000.dir
186
187 9 / [000000] [000000] 000000.dir
188 10 /a [000000]a [a] [000000]a
189 11 /a/ [a] [a] [000000]a.dir
190 12 /a/b [a]b [a.b] [a]b
191 13 /a/b/ [a.b] [a.b] [a]b.dir
192 14 /a/b/c [a.b]c [a.b.c] [a.b]c
193 15 /a/b/c/ [a.b.c] [a.b.c] [a.b]c.dir
194
195 16 a a [.a] a
196 17 a/ [.a] [.a] a.dir
197 18 a/b [.a]b [.a.b] [.a]b
198 19 a/b/ [.a.b] [.a.b] [.a]b.dir
199 20 a/b/c [.a.b]c [.a.b.c] [.a.b]c
200 21 a/b/c/ [.a.b.c] [.a.b.c] [.a.b]c.dir
201
202 22 a.b.c a_b.c [.a_b_c] a_b_c.dir
203
204 23 [x][y]z [x.y]z [x.y]z [x.y]z
205 24 [x][.y]z [x.y]z [x.y]z [x.y]z
206
207 25 filenames with '$' are left unchanged if they contain no '/'
208 25 filenames with ':' are left unchanged
209 26 filenames with a single pair of '[' ']' are left unchanged
210
211 The input string is not written to. The result is also const because
212 it's a static buffer; we don't want to change it.
213 */
214
215 const char *
216 vmsify (const char *name, int type)
217 {
218 /* max 255 device
219 max 39 directory
220 max 39 filename
221 max 39 filetype
222 max 5 version
223 */
224 #define MAXPATHLEN 512
225
226 enum namestate nstate;
227 static char vmsname[MAXPATHLEN+1];
228 const char *fptr;
229 const char *t;
230 char *vptr;
231 int as_dir;
232 int count;
233 const char *s;
234 const char *s1;
235 const char *s2;
236
237 if (name == 0)
238 return 0;
239 fptr = name;
240 vptr = vmsname;
241 nstate = N_START;
242
243 /* case 25a */
244 t = strpbrk (name, "$:");
245
246 if (t != 0)
247 {
248 // const char *s1;
249 // const char *s2;
250
251 if (type == 1)
252 {
253 s1 = strchr (t+1, '[');
254 s2 = strchr (t+1, ']');
255 }
256
257 if (*t == '$')
258 {
259 if (strchr (name, '/') == 0)
260 {
261 strcpy (vmsname, name);
262 if ((type == 1) && (s1 != 0) && (s2 == 0))
263 strcat (vmsname, "]");
264 return vmsname;
265 }
266 }
267 else
268 {
269 strcpy (vmsname, name);
270 if ((type == 1) && (s1 != 0) && (s2 == 0))
271 strcat (vmsname, "]");
272 return vmsname;
273 }
274 }
275
276 /* case 26 */
277 t = strchr (name, '[');
278
279 if (t != 0)
280 {
281 // const char *s;
282 // const char *s1 = strchr (t+1, '[');
283 s1 = strchr (t+1, '[');
284 if (s1 == 0)
285 {
286 strcpy (vmsname, name);
287 if ((type == 1) && (strchr (t+1, ']') == 0))
288 strcat (vmsname, "]");
289 return vmsname;
290 }
291 s1--;
292 if (*s1 != ']')
293 {
294 strcpy (vmsname, name);
295 return vmsname; /* not ][, keep unchanged */
296 }
297
298 /* we have ][ */
299
300 s = name;
301
302 /* s -> starting char
303 s1 -> ending ']' */
304 do
305 {
306 strncpy (vptr, s, s1-s); /* copy up to but not including ']' */
307 vptr += s1-s;
308 if (*s1 == 0)
309 break;
310 s = s1 + 1; /* s -> char behind ']' */
311 if (*s != '[') /* was '][' ? */
312 break; /* no, last ] found, exit */
313 s++;
314 if (*s != '.')
315 *vptr++ = '.';
316 s1 = strchr (s, ']');
317 if (s1 == 0) /* no closing ] */
318 s1 = s + strlen (s);
319 }
320 while (1);
321
322 *vptr++ = ']';
323
324 fptr = s;
325
326 }
327 else /* no [ in name */
328 {
329 int state = 0;
330 int rooted = 1; /* flag if logical is rooted, else insert [000000] */
331
332 do
333 {
334 switch (state)
335 {
336 case 0: /* start of loop */
337 if (*fptr == '/')
338 {
339 fptr++;
340 state = 1;
341 }
342 else if (*fptr == '.')
343 {
344 fptr++;
345 state = 10;
346 }
347 else
348 state = 2;
349 break;
350
351 case 1: /* '/' at start */
352 if (*fptr == '/')
353 {
354 fptr++;
355 state = 3;
356 }
357 else
358 state = 4;
359 break;
360
361 case 2: /* no '/' at start */
362 {
363 const char *s = strchr (fptr, '/');
364 if (s == 0) /* no '/' (16) */
365 {
366 if (type == 1)
367 {
368 strcpy (vptr, "[.");
369 vptr += 2;
370 }
371 copyto (&vptr, &fptr, 0, (type==1));
372 if (type == 1)
373 *vptr++ = ']';
374 state = -1;
375 }
376 else /* found '/' (17..21) */
377 {
378 if ((type == 2)
379 && (*(s+1) == 0)) /* 17(2) */
380 {
381 copyto (&vptr, &fptr, '/', 1);
382 state = 7;
383 }
384 else
385 {
386 strcpy (vptr, "[.");
387 vptr += 2;
388 copyto (&vptr, &fptr, '/', 1);
389 nstate = N_OPEN;
390 state = 9;
391 }
392 }
393 break;
394 }
395
396 case 3: /* '//' at start */
397 {
398 // const char *s;
399 // const char *s1;
400 char *vp;
401 while (*fptr == '/') /* collapse all '/' */
402 fptr++;
403 if (*fptr == 0) /* just // */
404 {
405 char cwdbuf[MAXPATHLEN+1];
406
407 s1 = getcwd(cwdbuf, MAXPATHLEN);
408 if (s1 == 0)
409 {
410 vmsname[0] = '\0';
411 return vmsname; /* FIXME, err getcwd */
412 }
413 s = strchr (s1, ':');
414 if (s == 0)
415 {
416 vmsname[0] = '\0';
417 return vmsname; /* FIXME, err no device */
418 }
419 strncpy (vptr, s1, s-s1+1);
420 vptr += s-s1+1;
421 state = -1;
422 break;
423 }
424
425 s = vptr;
426
427 if (copyto (&vptr, &fptr, '/', 1) == 0) /* copy device part */
428 {
429 *vptr++ = ':';
430 state = -1;
431 break;
432 }
433 *vptr = ':';
434 nstate = N_DEVICE;
435 if (*fptr == 0) /* just '//a/' */
436 {
437 strcpy (vptr+1, "[000000]");
438 vptr += 9;
439 state = -1;
440 break;
441 }
442 *vptr = 0;
443 /* check logical for [000000] insertion */
444 vp = trnlog (s);
445 if (*vp != '\0')
446 { /* found translation */
447 for (;;) /* loop over all nested logicals */
448 {
449 char *vp2 = vp + strlen (vp) - 1;
450 if (*vp2 == ':') /* translation ends in ':' */
451 {
452 vp2 = trnlog (vp);
453 free (vp);
454 if (*vp2 == 0)
455 {
456 rooted = 0;
457 break;
458 }
459 vp = vp2;
460 continue; /* next iteration */
461 }
462 if (*vp2 == ']') /* translation ends in ']' */
463 {
464 if (*(vp2-1) == '.') /* ends in '.]' */
465 {
466 if (strncmp (fptr, "000000", 6) != 0)
467 rooted = 0;
468 }
469 else
470 {
471 strcpy (vmsname, s1);
472 vp = strchr (vmsname, ']');
473 *vp = '.';
474 nstate = N_DOT;
475 vptr = vp;
476 }
477 }
478 break;
479 }
480 free (vp);
481 }
482 else
483 rooted = 0;
484
485 if (*vptr == 0)
486 {
487 nstate = N_DEVICE;
488 *vptr++ = ':';
489 }
490 else
491 vptr++;
492
493 if (rooted == 0)
494 {
495 nstate = N_DOT;
496 strcpy (vptr, "[000000.");
497 vptr += 8;
498 vp = vptr-1;
499 }
500 else
501 vp = 0;
502
503 /* vp-> '.' after 000000 or NULL */
504
505 s = strchr (fptr, '/');
506 if (s == 0)
507 { /* no next '/' */
508 if (*(vptr-1) == '.')
509 *(vptr-1) = ']';
510 else if (rooted == 0)
511 *vptr++ = ']';
512 copyto (&vptr, &fptr, 0, (type == 1));
513 state = -1;
514 break;
515 }
516 else
517 {
518 while (*(s+1) == '/') /* skip multiple '/' */
519 s++;
520 }
521
522 if ((rooted != 0)
523 && (*(vptr-1) != '.'))
524 {
525 *vptr++ = '[';
526 nstate = N_DOT;
527 }
528 else
529 if ((nstate == N_DOT)
530 && (vp != 0)
531 && (*(s+1) == 0))
532 {
533 if (type == 2)
534 {
535 *vp = ']';
536 nstate = N_CLOSED;
537 }
538 }
539 state = 9;
540 break;
541 }
542 case 4: /* single '/' at start (9..15) */
543 if (*fptr == 0)
544 state = 5;
545 else
546 state = 6;
547 break;
548
549 case 5: /* just '/' at start (9) */
550 if (type != 2)
551 {
552 *vptr++ = '[';
553 nstate = N_OPEN;
554 }
555 strcpy (vptr, "000000");
556 vptr += 6;
557 if (type == 2)
558 state = 7;
559 else
560 state = 8;
561 break;
562
563 case 6: /* chars following '/' at start 10..15 */
564 {
565 const char *s;
566 *vptr++ = '[';
567 nstate = N_OPEN;
568 s = strchr (fptr, '/');
569 if (s == 0) /* 10 */
570 {
571 if (type != 1)
572 {
573 strcpy (vptr, "000000]");
574 vptr += 7;
575 }
576 copyto (&vptr, &fptr, 0, (type == 1));
577 if (type == 1)
578 {
579 *vptr++ = ']';
580 }
581 state = -1;
582 }
583 else /* 11..15 */
584 {
585 if ( (type == 2)
586 && (*(s+1) == 0)) /* 11(2) */
587 {
588 strcpy (vptr, "000000]");
589 nstate = N_CLOSED;
590 vptr += 7;
591 }
592 copyto (&vptr, &fptr, '/', (*(vptr-1) != ']'));
593 state = 9;
594 }
595 break;
596 }
597
598 case 7: /* add '.dir' and exit */
599 if ((nstate == N_OPEN)
600 || (nstate == N_DOT))
601 {
602 char *vp = vptr-1;
603 while (vp > vmsname)
604 {
605 if (*vp == ']')
606 {
607 break;
608 }
609 if (*vp == '.')
610 {
611 *vp = ']';
612 break;
613 }
614 vp--;
615 }
616 }
617 strcpy (vptr, ".dir");
618 vptr += 4;
619 state = -1;
620 break;
621
622 case 8: /* add ']' and exit */
623 *vptr++ = ']';
624 state = -1;
625 break;
626
627 case 9: /* 17..21, fptr -> 1st '/' + 1 */
628 {
629 const char *s;
630 if (*fptr == 0)
631 {
632 if (type == 2)
633 {
634 state = 7;
635 }
636 else
637 state = 8;
638 break;
639 }
640 s = strchr (fptr, '/');
641 if (s == 0)
642 {
643 if (type != 1)
644 {
645 if (nstate == N_OPEN)
646 {
647 *vptr++ = ']';
648 nstate = N_CLOSED;
649 }
650 as_dir = 0;
651 }
652 else
653 {
654 if (nstate == N_OPEN)
655 {
656 *vptr++ = '.';
657 nstate = N_DOT;
658 }
659 as_dir = 1;
660 }
661 }
662 else
663 {
664 while (*(s+1) == '/')
665 s++;
666 if ( (type == 2)
667 && (*(s+1) == 0)) /* 19(2), 21(2)*/
668 {
669 if (nstate != N_CLOSED)
670 {
671 *vptr++ = ']';
672 nstate = N_CLOSED;
673 }
674 as_dir = 1;
675 }
676 else
677 {
678 if (nstate == N_OPEN)
679 {
680 *vptr++ = '.';
681 nstate = N_DOT;
682 }
683 as_dir = 1;
684 }
685 }
686 if ( (*fptr == '.') /* check for '..' or '../' */
687 && (*(fptr+1) == '.')
688 && ((*(fptr+2) == '/')
689 || (*(fptr+2) == 0)) )
690 {
691 char *vp;
692 fptr += 2;
693 if (*fptr == '/')
694 {
695 do
696 {
697 fptr++;
698 }
699 while (*fptr == '/');
700 }
701 else if (*fptr == 0)
702 type = 1;
703 vptr--; /* vptr -> '.' or ']' */
704 vp = vptr;
705 for (;;)
706 {
707 vp--;
708 if (*vp == '.') /* one back */
709 {
710 vptr = vp;
711 nstate = N_OPEN;
712 break;
713 }
714 if (*vp == '[') /* top level reached */
715 {
716 if (*fptr == 0)
717 {
718 strcpy (vp, "[000000]");
719 vptr = vp + 8;
720 nstate = N_CLOSED;
721 s = 0;
722 break;
723 }
724 else
725 {
726 vptr = vp+1;
727 nstate = N_OPEN;
728 break;
729 }
730 }
731 }
732 }
733 else
734 {
735 copyto (&vptr, &fptr, '/', as_dir);
736 if (nstate == N_DOT)
737 nstate = N_OPEN;
738 }
739 if (s == 0)
740 { /* 18,20 */
741 if (type == 1)
742 *vptr++ = ']';
743 state = -1;
744 }
745 else
746 {
747 if (*(s+1) == 0)
748 {
749 if (type == 2) /* 19,21 */
750 {
751 state = 7;
752 }
753 else
754 {
755 *vptr++ = ']';
756 state = -1;
757 }
758 }
759 }
760 break;
761 }
762
763 case 10: /* 1,2 first is '.' */
764 if (*fptr == '.')
765 {
766 fptr++;
767 state = 11;
768 }
769 else
770 state = 12;
771 break;
772
773 case 11: /* 2, '..' at start */
774 count = 1;
775 if (*fptr != 0)
776 {
777 if (*fptr != '/') /* got ..xxx */
778 {
779 strcpy (vmsname, name);
780 return vmsname;
781 }
782 do /* got ../ */
783 {
784 fptr++;
785 while (*fptr == '/') fptr++;
786 if (*fptr != '.')
787 break;
788 if (*(fptr+1) != '.')
789 break;
790 fptr += 2;
791 if ((*fptr == 0)
792 || (*fptr == '/'))
793 count++;
794 }
795 while (*fptr == '/');
796 }
797 { /* got '..' or '../' */
798 char *vp;
799 char cwdbuf[MAXPATHLEN+1];
800
801 vp = getcwd(cwdbuf, MAXPATHLEN);
802 if (vp == 0)
803 {
804 vmsname[0] = '\0';
805 return vmsname; /* FIXME, err getcwd */
806 }
807 strcpy (vptr, vp);
808 vp = strchr (vptr, ']');
809 if (vp != 0)
810 {
811 nstate = N_OPEN;
812 while (vp > vptr)
813 {
814 vp--;
815 if (*vp == '[')
816 {
817 vp++;
818 strcpy (vp, "000000]");
819 state = -1;
820 break;
821 }
822 else if (*vp == '.')
823 {
824 if (--count == 0)
825 {
826 if (*fptr == 0) /* had '..' or '../' */
827 {
828 *vp++ = ']';
829 state = -1;
830 }
831 else /* had '../xxx' */
832 {
833 state = 9;
834 }
835 *vp = '\0';
836 break;
837 }
838 }
839 }
840 }
841 vptr += strlen (vptr);
842 }
843 break;
844
845 case 12: /* 1, '.' at start */
846 if (*fptr != 0)
847 {
848 if (*fptr != '/')
849 {
850 strcpy (vmsname, name);
851 return vmsname;
852 }
853 while (*fptr == '/')
854 fptr++;
855 }
856
857 {
858 char *vp;
859 char cwdbuf[MAXPATHLEN+1];
860
861 vp = getcwd(cwdbuf, MAXPATHLEN);
862 if (vp == 0)
863 {
864 vmsname[0] = '\0';
865 return vmsname; /*FIXME, err getcwd */
866 }
867 strcpy (vptr, vp);
868 }
869 if (*fptr == 0)
870 {
871 state = -1;
872 break;
873 }
874 else
875 {
876 char *vp = strchr (vptr, ']');
877 if (vp == 0)
878 {
879 state = -1;
880 break;
881 }
882 *vp = '\0';
883 nstate = N_OPEN;
884 vptr += strlen (vptr);
885 state = 9;
886 }
887 break;
888 }
889
890 }
891 while (state > 0);
892
893
894 }
895
896
897 /* directory conversion done
898 fptr -> filename part of input string
899 vptr -> free space in vmsname
900 */
901
902 *vptr++ = 0;
903
904 return vmsname;
905 }
906
907
908
909 /*
910 convert from vms-style to unix-style
911
912 dev:[dir1.dir2] //dev/dir1/dir2/
913 */
914
915 const char *
916 unixify (const char *name)
917 {
918 static char piece[512];
919 const char *s;
920 char *p;
921
922 if (strchr (name, '/') != 0) /* already in unix style */
923 {
924 strcpy (piece, name);
925 return piece;
926 }
927
928 p = piece;
929 *p = 0;
930
931 /* device part */
932
933 s = strchr (name, ':');
934
935 if (s != 0)
936 {
937 int l = s - name;
938 *p++ = '/';
939 *p++ = '/';
940 strncpy (p, name, l);
941 p += l;
942 }
943
944 /* directory part */
945
946 *p++ = '/';
947 s = strchr (name, '[');
948
949 if (s != 0)
950 {
951 s++;
952 switch (*s)
953 {
954 case ']': /* [] */
955 strcat (p, "./");
956 break;
957 case '-': /* [- */
958 strcat (p, "../");
959 break;
960 case '.':
961 strcat (p, "./"); /* [. */
962 break;
963 default:
964 s--;
965 break;
966 }
967 s++;
968 while (*s)
969 {
970 if (*s == '.')
971 *p++ = '/';
972 else
973 *p++ = *s;
974 s++;
975 if (*s == ']')
976 {
977 s++;
978 break;
979 }
980 }
981 if (*s != 0) /* more after ']' ?? */
982 {
983 if (*(p-1) != '/')
984 *p++ = '/';
985 strcpy (p, s); /* copy it anyway */
986 }
987 }
988
989 else /* no '[' anywhere */
990
991 {
992 *p++ = 0;
993 }
994
995 /* force end with '/' */
996
997 if (*(p-1) != '/')
998 *p++ = '/';
999 *p = 0;
1000
1001 return piece;
1002 }
1003
1004 /* EOF */
GNU Make CVS Git mirror (updated by hand)