/[jscoverage]/trunk/js/config/nsinstall_win.c
ViewVC logotype

Contents of /trunk/js/config/nsinstall_win.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 507 - (show annotations)
Sun Jan 10 07:23:34 2010 UTC (9 years, 10 months ago) by siliconforks
File MIME type: text/plain
File size: 20222 byte(s)
Update SpiderMonkey from Firefox 3.6rc1.

1 /*
2 * The nsinstall command for Win32
3 *
4 * Our gmake makefiles use the nsinstall command to create the
5 * object directories or installing headers and libs. This code was originally
6 * taken from shmsdos.c
7 */
8
9 #include <direct.h>
10 #include <stdio.h>
11 #include <string.h>
12 #include <assert.h>
13 #include <windows.h>
14 #pragma hdrstop
15
16 /*
17 * sh_FileFcn --
18 *
19 * A function that operates on a file. The pathname is either
20 * absolute or relative to the current directory, and contains
21 * no wildcard characters such as * and ?. Additional arguments
22 * can be passed to the function via the arg pointer.
23 */
24
25 typedef BOOL (*sh_FileFcn)(
26 wchar_t *pathName,
27 WIN32_FIND_DATA *fileData,
28 void *arg);
29
30 static int shellCp (wchar_t **pArgv);
31 static int shellNsinstall (wchar_t **pArgv);
32 static int shellMkdir (wchar_t **pArgv);
33 static BOOL sh_EnumerateFiles(const wchar_t *pattern, const wchar_t *where,
34 sh_FileFcn fileFcn, void *arg, int *nFiles);
35 static const char *sh_GetLastErrorMessage(void);
36 static BOOL sh_DoCopy(wchar_t *srcFileName, DWORD srcFileAttributes,
37 wchar_t *dstFileName, DWORD dstFileAttributes,
38 int force, int recursive);
39
40 #define LONGPATH_PREFIX L"\\\\?\\"
41 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
42 #define STR_LEN(a) (ARRAY_LEN(a) - 1)
43
44 /* changes all forward slashes in token to backslashes */
45 void changeForwardSlashesToBackSlashes ( wchar_t *arg )
46 {
47 if ( arg == NULL )
48 return;
49
50 while ( *arg ) {
51 if ( *arg == '/' )
52 *arg = '\\';
53 arg++;
54 }
55 }
56
57 int wmain(int argc, wchar_t *argv[ ])
58 {
59 return shellNsinstall ( argv + 1 );
60 }
61
62 static int
63 shellNsinstall (wchar_t **pArgv)
64 {
65 int retVal = 0; /* exit status */
66 int dirOnly = 0; /* 1 if and only if -D is specified */
67 wchar_t **pSrc;
68 wchar_t **pDst;
69
70 /*
71 * Process the command-line options. We ignore the
72 * options except for -D. Some options, such as -m,
73 * are followed by an argument. We need to skip the
74 * argument too.
75 */
76 while ( *pArgv && **pArgv == '-' ) {
77 wchar_t c = (*pArgv)[1]; /* The char after '-' */
78
79 if ( c == 'D' ) {
80 dirOnly = 1;
81 } else if ( c == 'm' ) {
82 pArgv++; /* skip the next argument */
83 }
84 pArgv++;
85 }
86
87 if ( !dirOnly ) {
88 /* There are files to install. Get source files */
89 if ( *pArgv ) {
90 pSrc = pArgv++;
91 } else {
92 fprintf( stderr, "nsinstall: not enough arguments\n");
93 return 3;
94 }
95 }
96
97 /* Get to last token to find destination directory */
98 if ( *pArgv ) {
99 pDst = pArgv++;
100 if ( dirOnly && *pArgv ) {
101 fprintf( stderr, "nsinstall: too many arguments with -D\n");
102 return 3;
103 }
104 } else {
105 fprintf( stderr, "nsinstall: not enough arguments\n");
106 return 3;
107 }
108 while ( *pArgv )
109 pDst = pArgv++;
110
111 retVal = shellMkdir ( pDst );
112 if ( retVal )
113 return retVal;
114 if ( !dirOnly )
115 retVal = shellCp ( pSrc );
116 return retVal;
117 }
118
119 static int
120 shellMkdir (wchar_t **pArgv)
121 {
122 int retVal = 0; /* assume valid return */
123 wchar_t *arg;
124 wchar_t *pArg;
125 wchar_t path[_MAX_PATH];
126 wchar_t tmpPath[_MAX_PATH];
127 wchar_t *pTmpPath = tmpPath;
128
129 /* All the options are simply ignored in this implementation */
130 while ( *pArgv && **pArgv == '-' ) {
131 if ( (*pArgv)[1] == 'm' ) {
132 pArgv++; /* skip the next argument (mode) */
133 }
134 pArgv++;
135 }
136
137 while ( *pArgv ) {
138 arg = *pArgv;
139 changeForwardSlashesToBackSlashes ( arg );
140 pArg = arg;
141 pTmpPath = tmpPath;
142 while ( 1 ) {
143 /* create part of path */
144 while ( *pArg ) {
145 *pTmpPath++ = *pArg++;
146 if ( *pArg == '\\' )
147 break;
148 }
149 *pTmpPath = '\0';
150
151 /* check if directory already exists */
152 _wgetcwd ( path, _MAX_PATH );
153 if ( _wchdir ( tmpPath ) != -1 ) {
154 _wchdir ( path );
155 } else {
156 if ( _wmkdir ( tmpPath ) == -1 ) {
157 printf ( "%ls: ", tmpPath );
158 perror ( "Could not create the directory" );
159 retVal = 3;
160 break;
161 }
162 }
163 if ( *pArg == '\0' ) /* complete path? */
164 break;
165 /* loop for next directory */
166 }
167
168 pArgv++;
169 }
170 return retVal;
171 }
172
173 static const char *
174 sh_GetLastErrorMessage()
175 {
176 static char buf[128];
177
178 FormatMessageA(
179 FORMAT_MESSAGE_FROM_SYSTEM,
180 NULL,
181 GetLastError(),
182 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* default language */
183 buf,
184 sizeof(buf),
185 NULL
186 );
187 return buf;
188 }
189
190 /*
191 * struct sh_FileData --
192 *
193 * A pointer to the sh_FileData structure is passed into sh_RecordFileData,
194 * which will fill in the fields.
195 */
196
197 struct sh_FileData {
198 wchar_t pathName[_MAX_PATH];
199 DWORD dwFileAttributes;
200 };
201
202 /*
203 * sh_RecordFileData --
204 *
205 * Record the pathname and attributes of the file in
206 * the sh_FileData structure pointed to by arg.
207 *
208 * Always return TRUE (successful completion).
209 *
210 * This function is intended to be passed into sh_EnumerateFiles
211 * to see if a certain pattern expands to exactly one file/directory,
212 * and if so, record its pathname and attributes.
213 */
214
215 static BOOL
216 sh_RecordFileData(wchar_t *pathName, WIN32_FIND_DATA *findData, void *arg)
217 {
218 struct sh_FileData *fData = (struct sh_FileData *) arg;
219
220 wcscpy(fData->pathName, pathName);
221 fData->dwFileAttributes = findData->dwFileAttributes;
222 return TRUE;
223 }
224
225 static BOOL
226 sh_DoCopy(wchar_t *srcFileName,
227 DWORD srcFileAttributes,
228 wchar_t *dstFileName,
229 DWORD dstFileAttributes,
230 int force,
231 int recursive
232 )
233 {
234 if (dstFileAttributes != 0xFFFFFFFF) {
235 if ((dstFileAttributes & FILE_ATTRIBUTE_READONLY) && force) {
236 dstFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
237 SetFileAttributes(dstFileName, dstFileAttributes);
238 }
239 }
240
241 if (srcFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
242 fprintf(stderr, "nsinstall: %ls is a directory\n",
243 srcFileName);
244 return FALSE;
245 } else {
246 DWORD r;
247 wchar_t longSrc[1004] = LONGPATH_PREFIX;
248 wchar_t longDst[1004] = LONGPATH_PREFIX;
249 r = GetFullPathName(srcFileName, 1000, longSrc + STR_LEN(LONGPATH_PREFIX), NULL);
250 if (!r) {
251 fprintf(stderr, "nsinstall: couldn't get full path of %ls: %s\n",
252 srcFileName, sh_GetLastErrorMessage());
253 return FALSE;
254 }
255 r = GetFullPathName(dstFileName, 1000, longDst + ARRAY_LEN(LONGPATH_PREFIX) - 1, NULL);
256 if (!r) {
257 fprintf(stderr, "nsinstall: couldn't get full path of %ls: %s\n",
258 dstFileName, sh_GetLastErrorMessage());
259 return FALSE;
260 }
261
262 if (!CopyFile(longSrc, longDst, FALSE)) {
263 fprintf(stderr, "nsinstall: cannot copy %ls to %ls: %s\n",
264 srcFileName, dstFileName, sh_GetLastErrorMessage());
265 return FALSE;
266 }
267 }
268 return TRUE;
269 }
270
271 /*
272 * struct sh_CpCmdArg --
273 *
274 * A pointer to the sh_CpCmdArg structure is passed into sh_CpFileCmd.
275 * The sh_CpCmdArg contains information about the cp command, and
276 * provide a buffer for constructing the destination file name.
277 */
278
279 struct sh_CpCmdArg {
280 int force; /* -f option, ok to overwrite an existing
281 * read-only destination file */
282 int recursive; /* -r or -R option, recursively copy
283 * directories. Note: this field is not used
284 * by nsinstall and should always be 0. */
285 wchar_t *dstFileName; /* a buffer for constructing the destination
286 * file name */
287 wchar_t *dstFileNameMarker; /* points to where in the dstFileName buffer
288 * we should write the file component of the
289 * destination file */
290 };
291
292 /*
293 * sh_CpFileCmd --
294 *
295 * Copy a file to the destination directory
296 *
297 * This function is intended to be passed into sh_EnumerateFiles to
298 * copy all the files specified by the pattern to the destination
299 * directory.
300 *
301 * Return TRUE if the file is successfully copied, and FALSE otherwise.
302 */
303
304 static BOOL
305 sh_CpFileCmd(wchar_t *pathName, WIN32_FIND_DATA *findData, void *cpArg)
306 {
307 BOOL retVal = TRUE;
308 struct sh_CpCmdArg *arg = (struct sh_CpCmdArg *) cpArg;
309
310 wcscpy(arg->dstFileNameMarker, findData->cFileName);
311 return sh_DoCopy(pathName, findData->dwFileAttributes,
312 arg->dstFileName, GetFileAttributes(arg->dstFileName),
313 arg->force, arg->recursive);
314 }
315
316 static int
317 shellCp (wchar_t **pArgv)
318 {
319 int retVal = 0;
320 wchar_t **pSrc;
321 wchar_t **pDst;
322 struct sh_CpCmdArg arg;
323 struct sh_FileData dstData;
324 int dstIsDir = 0;
325 int n;
326
327 arg.force = 0;
328 arg.recursive = 0;
329 arg.dstFileName = dstData.pathName;
330 arg.dstFileNameMarker = 0;
331
332 while (*pArgv && **pArgv == '-') {
333 wchar_t *p = *pArgv;
334
335 while (*(++p)) {
336 if (*p == 'f') {
337 arg.force = 1;
338 }
339 }
340 pArgv++;
341 }
342
343 /* the first source file */
344 if (*pArgv) {
345 pSrc = pArgv++;
346 } else {
347 fprintf(stderr, "nsinstall: not enough arguments\n");
348 return 3;
349 }
350
351 /* get to the last token to find destination */
352 if (*pArgv) {
353 pDst = pArgv++;
354 } else {
355 fprintf(stderr, "nsinstall: not enough arguments\n");
356 return 3;
357 }
358 while (*pArgv) {
359 pDst = pArgv++;
360 }
361
362 /*
363 * The destination pattern must unambiguously expand to exactly
364 * one file or directory.
365 */
366
367 changeForwardSlashesToBackSlashes(*pDst);
368 sh_EnumerateFiles(*pDst, *pDst, sh_RecordFileData, &dstData, &n);
369 assert(n >= 0);
370 if (n == 1) {
371 /*
372 * Is the destination a file or directory?
373 */
374
375 if (dstData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
376 dstIsDir = 1;
377 }
378 } else if (n > 1) {
379 fprintf(stderr, "nsinstall: %ls: ambiguous destination file "
380 "or directory\n", *pDst);
381 return 3;
382 } else {
383 /*
384 * n == 0, meaning that destination file or directory does
385 * not exist. In this case the destination file directory
386 * name must be fully specified.
387 */
388
389 wchar_t *p;
390
391 for (p = *pDst; *p; p++) {
392 if (*p == '*' || *p == '?') {
393 fprintf(stderr, "nsinstall: %ls: No such file or directory\n",
394 *pDst);
395 return 3;
396 }
397 }
398
399 /*
400 * Do not include the trailing \, if any, unless it is a root
401 * directory (\ or X:\).
402 */
403
404 if (p > *pDst && p[-1] == '\\' && p != *pDst + 1 && p[-2] != ':') {
405 p[-1] = '\0';
406 }
407 wcscpy(dstData.pathName, *pDst);
408 dstData.dwFileAttributes = 0xFFFFFFFF;
409 }
410
411 /*
412 * If there are two or more source files, the destination has
413 * to be a directory.
414 */
415
416 if (pDst - pSrc > 1 && !dstIsDir) {
417 fprintf(stderr, "nsinstall: cannot copy more than"
418 " one file to the same destination file\n");
419 return 3;
420 }
421
422 if (dstIsDir) {
423 arg.dstFileNameMarker = arg.dstFileName + wcslen(arg.dstFileName);
424
425 /*
426 * Now arg.dstFileNameMarker is pointing to the null byte at the
427 * end of string. We want to make sure that there is a \ at the
428 * end of string, and arg.dstFileNameMarker should point right
429 * after that \.
430 */
431
432 if (arg.dstFileNameMarker[-1] != '\\') {
433 *(arg.dstFileNameMarker++) = '\\';
434 }
435 }
436
437 if (!dstIsDir) {
438 struct sh_FileData srcData;
439
440 assert(pDst - pSrc == 1);
441 changeForwardSlashesToBackSlashes(*pSrc);
442 sh_EnumerateFiles(*pSrc, *pSrc, sh_RecordFileData, &srcData, &n);
443 if (n == 0) {
444 fprintf(stderr, "nsinstall: %ls: No such file or directory\n",
445 *pSrc);
446 retVal = 3;
447 } else if (n > 1) {
448 fprintf(stderr, "nsinstall: cannot copy more than one file or "
449 "directory to the same destination\n");
450 retVal = 3;
451 } else {
452 assert(n == 1);
453 if (sh_DoCopy(srcData.pathName, srcData.dwFileAttributes,
454 dstData.pathName, dstData.dwFileAttributes,
455 arg.force, arg.recursive) == FALSE) {
456 retVal = 3;
457 }
458 }
459 return retVal;
460 }
461
462 for ( ; *pSrc != *pDst; pSrc++) {
463 BOOL rv;
464
465 changeForwardSlashesToBackSlashes(*pSrc);
466 rv = sh_EnumerateFiles(*pSrc, *pSrc, sh_CpFileCmd, &arg, &n);
467 if (rv == FALSE) {
468 retVal = 3;
469 } else {
470 if (n == 0) {
471 fprintf(stderr, "nsinstall: %ls: No such file or directory\n",
472 *pSrc);
473 retVal = 3;
474 }
475 }
476 }
477
478 return retVal;
479 }
480
481 /*
482 * sh_EnumerateFiles --
483 *
484 * Enumerate all the files in the specified pattern, which is a pathname
485 * containing possibly wildcard characters such as * and ?. fileFcn
486 * is called on each file, passing the expanded file name, a pointer
487 * to the file's WIN32_FILE_DATA, and the arg pointer.
488 *
489 * It is assumed that there are no wildcard characters before the
490 * character pointed to by 'where'.
491 *
492 * On return, *nFiles stores the number of files enumerated. *nFiles is
493 * set to this number whether sh_EnumerateFiles or 'fileFcn' succeeds
494 * or not.
495 *
496 * Return TRUE if the files are successfully enumerated and all
497 * 'fileFcn' invocations succeeded. Return FALSE if something went
498 * wrong.
499 */
500
501 static BOOL sh_EnumerateFiles(
502 const wchar_t *pattern,
503 const wchar_t *where,
504 sh_FileFcn fileFcn,
505 void *arg,
506 int *nFiles
507 )
508 {
509 WIN32_FIND_DATA fileData;
510 HANDLE hSearch;
511 const wchar_t *src;
512 wchar_t *dst;
513 wchar_t fileName[_MAX_PATH];
514 wchar_t *fileNameMarker = fileName;
515 wchar_t *oldFileNameMarker;
516 BOOL hasWildcard = FALSE;
517 BOOL retVal = TRUE;
518 BOOL patternEndsInDotStar = FALSE;
519 BOOL patternEndsInDot = FALSE; /* a special case of
520 * patternEndsInDotStar */
521 int numDotsInPattern;
522 int len;
523
524 /*
525 * Windows expands patterns ending in ".", ".*", ".**", etc.
526 * differently from the glob expansion on Unix. For example,
527 * both "foo." and "foo.*" match "foo", and "*.*" matches
528 * everything, including filenames with no dots. So we need
529 * to throw away extra files returned by the FindNextFile()
530 * function. We require that a matched filename have at least
531 * the number of dots in the pattern.
532 */
533 len = wcslen(pattern);
534 if (len >= 2) {
535 /* Start from the end of pattern and go backward */
536 const wchar_t *p = &pattern[len - 1];
537
538 /* We can have zero or more *'s */
539 while (p >= pattern && *p == '*') {
540 p--;
541 }
542 if (p >= pattern && *p == '.') {
543 patternEndsInDotStar = TRUE;
544 if (p == &pattern[len - 1]) {
545 patternEndsInDot = TRUE;
546 }
547 p--;
548 numDotsInPattern = 1;
549 while (p >= pattern && *p != '\\') {
550 if (*p == '.') {
551 numDotsInPattern++;
552 }
553 p--;
554 }
555 }
556 }
557
558 *nFiles = 0;
559
560 /*
561 * Copy pattern to fileName, but only up to and not including
562 * the first \ after the first wildcard letter.
563 *
564 * Make fileNameMarker point to one of the following:
565 * - the start of fileName, if fileName does not contain any \.
566 * - right after the \ before the first wildcard letter, if there is
567 * a wildcard character.
568 * - right after the last \, if there is no wildcard character.
569 */
570
571 dst = fileName;
572 src = pattern;
573 while (src < where) {
574 if (*src == '\\') {
575 oldFileNameMarker = fileNameMarker;
576 fileNameMarker = dst + 1;
577 }
578 *(dst++) = *(src++);
579 }
580
581 while (*src && *src != '*' && *src != '?') {
582 if (*src == '\\') {
583 oldFileNameMarker = fileNameMarker;
584 fileNameMarker = dst + 1;
585 }
586 *(dst++) = *(src++);
587 }
588
589 if (*src) {
590 /*
591 * Must have seen the first wildcard letter
592 */
593
594 hasWildcard = TRUE;
595 while (*src && *src != '\\') {
596 *(dst++) = *(src++);
597 }
598 }
599
600 /* Now src points to either null or \ */
601
602 assert(*src == '\0' || *src == '\\');
603 assert(hasWildcard || *src == '\0');
604 *dst = '\0';
605
606 /*
607 * If the pattern does not contain any wildcard characters, then
608 * we don't need to go the FindFirstFile route.
609 */
610
611 if (!hasWildcard) {
612 /*
613 * See if it is the root directory, \, or X:\.
614 */
615
616 assert(!wcscmp(fileName, pattern));
617 assert(wcslen(fileName) >= 1);
618 if (dst[-1] == '\\' && (dst == fileName + 1 || dst[-2] == ':')) {
619 fileData.cFileName[0] = '\0';
620 } else {
621 /*
622 * Do not include the trailing \, if any
623 */
624
625 if (dst[-1] == '\\') {
626 assert(*fileNameMarker == '\0');
627 dst[-1] = '\0';
628 fileNameMarker = oldFileNameMarker;
629 }
630 wcscpy(fileData.cFileName, fileNameMarker);
631 }
632 fileData.dwFileAttributes = GetFileAttributes(fileName);
633 if (fileData.dwFileAttributes == 0xFFFFFFFF) {
634 return TRUE;
635 }
636 *nFiles = 1;
637 return (*fileFcn)(fileName, &fileData, arg);
638 }
639
640 hSearch = FindFirstFile(fileName, &fileData);
641 if (hSearch == INVALID_HANDLE_VALUE) {
642 return retVal;
643 }
644
645 do {
646 if (!wcscmp(fileData.cFileName, L".")
647 || !wcscmp(fileData.cFileName, L"..")) {
648 /*
649 * Skip over . and ..
650 */
651
652 continue;
653 }
654
655 if (patternEndsInDotStar) {
656 int nDots = 0;
657 wchar_t *p = fileData.cFileName;
658 while (*p) {
659 if (*p == '.') {
660 nDots++;
661 }
662 p++;
663 }
664 /* Now p points to the null byte at the end of file name */
665 if (patternEndsInDot && (p == fileData.cFileName
666 || p[-1] != '.')) {
667 /*
668 * File name does not end in dot. Skip this file.
669 * Note: windows file name probably cannot end in dot,
670 * but we do this check anyway.
671 */
672 continue;
673 }
674 if (nDots < numDotsInPattern) {
675 /*
676 * Not enough dots in file name. Must be an extra
677 * file in matching .* pattern. Skip this file.
678 */
679 continue;
680 }
681 }
682
683 wcscpy(fileNameMarker, fileData.cFileName);
684 if (*src && *(src + 1)) {
685 /*
686 * More to go. Recurse.
687 */
688
689 int n;
690
691 assert(*src == '\\');
692 where = fileName + wcslen(fileName);
693 wcscat(fileName, src);
694 sh_EnumerateFiles(fileName, where, fileFcn, arg, &n);
695 *nFiles += n;
696 } else {
697 assert(wcschr(fileName, '*') == NULL);
698 assert(wcschr(fileName, '?') == NULL);
699 (*nFiles)++;
700 if ((*fileFcn)(fileName, &fileData, arg) == FALSE) {
701 retVal = FALSE;
702 }
703 }
704 } while (FindNextFile(hSearch, &fileData));
705
706 FindClose(hSearch);
707 return retVal;
708 }

  ViewVC Help
Powered by ViewVC 1.1.24