annotate src/nt.c @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14
author cvs
date Mon, 13 Aug 2007 11:20:41 +0200
parents de805c49cfc1
children 41dbb7a9d5f2
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1 /* Utility and Unix shadow routines for XEmacs on Windows NT.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
2 Copyright (C) 1994, 1995 Free Software Foundation, Inc.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
3
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
4 This file is part of XEmacs.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
5
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
6 XEmacs is free software; you can redistribute it and/or modify it
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
7 under the terms of the GNU General Public License as published by the
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
8 Free Software Foundation; either version 2, or (at your option) any
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
9 later version.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
10
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
14 for more details.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
15
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
16 You should have received a copy of the GNU General Public License
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
17 along with XEmacs; see the file COPYING. If not, write to the Free
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
19 02111-1307, USA.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
20
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
21
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
22 Geoff Voelker (voelker@cs.washington.edu) 7-29-94 */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
23
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
24 /* Adapted for XEmacs by David Hobley <david@spook-le0.cia.com.au> */
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
25 /* Sync'ed with Emacs 19.34.6 by Marc Paquette <marcpa@cam.org> */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
26
290
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
27 #include <config.h>
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
28
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
29 #undef signal
290
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
30 #define getwd _getwd
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
31 #include "lisp.h"
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
32 #undef getwd
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
33
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
34 #include "systime.h"
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
35 #include "syssignal.h"
239
41f2f0e326e9 Import from CVS: tag r20-5b18
cvs
parents: 223
diff changeset
36 #include "sysproc.h"
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
37 #include "sysfile.h"
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
38
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
39 #include <ctype.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
40 #include <direct.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
41 #include <errno.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
42 #include <fcntl.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
43 #include <io.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
44 #include <pwd.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
45 #include <signal.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
46 #include <stddef.h> /* for offsetof */
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
47 #include <string.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
48 #include <stdlib.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
49 #include <stdio.h>
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
50
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
51 #include <windows.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
52 #ifndef __MINGW32__
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
53 #include <mmsystem.h>
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
54 #else
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
55 typedef void (CALLBACK TIMECALLBACK)(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2);
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
56
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
57 typedef TIMECALLBACK FAR *LPTIMECALLBACK;
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
58 DWORD WINAPI timeGetTime(void);
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
59 MMRESULT WINAPI timeSetEvent(UINT uDelay, UINT uResolution,
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
60 LPTIMECALLBACK fptc, DWORD dwUser, UINT fuEvent);
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
61 MMRESULT WINAPI timeKillEvent(UINT uTimerID);
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
62 MMRESULT WINAPI timeGetDevCaps(TIMECAPS* ptc, UINT cbtc);
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
63 MMRESULT WINAPI timeBeginPeriod(UINT uPeriod);
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
64 MMRESULT WINAPI timeEndPeriod(UINT uPeriod);
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
65 #endif
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
66
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
67 #include "nt.h"
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
68 #include <sys/dir.h>
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
69 #include "ntheap.h"
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
70
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
71
263
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
72 extern Lisp_Object Vmswindows_downcase_file_names;
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
73 #if 0
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
74 extern Lisp_Object Vwin32_generate_fake_inodes;
263
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
75 #endif
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
76 extern Lisp_Object Vmswindows_get_true_file_attributes;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
77
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
78 extern char *get_home_directory(void);
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
79
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
80 static char startup_dir[ MAXPATHLEN ];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
81
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
82 /* Get the current working directory. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
83 char *
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
84 getwd (char *dir)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
85 {
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
86 #if 0
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
87 if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
88 return dir;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
89 return NULL;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
90 #else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
91 /* Emacs doesn't actually change directory itself, and we want to
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
92 force our real wd to be where emacs.exe is to avoid unnecessary
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
93 conflicts when trying to rename or delete directories. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
94 strcpy (dir, startup_dir);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
95 return dir;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
96 #endif
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
97 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
98
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
99 /* Emulate getloadavg. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
100 int
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
101 getloadavg (double loadavg[], int nelem)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
102 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
103 int i;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
104
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
105 /* A faithful emulation is going to have to be saved for a rainy day. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
106 for (i = 0; i < nelem; i++)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
107 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
108 loadavg[i] = 0.0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
109 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
110 return i;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
111 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
112
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
113 /* Emulate getpwuid, getpwnam and others. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
114
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
115 #define PASSWD_FIELD_SIZE 256
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
116
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
117 static char the_passwd_name[PASSWD_FIELD_SIZE];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
118 static char the_passwd_passwd[PASSWD_FIELD_SIZE];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
119 static char the_passwd_gecos[PASSWD_FIELD_SIZE];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
120 static char the_passwd_dir[PASSWD_FIELD_SIZE];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
121 static char the_passwd_shell[PASSWD_FIELD_SIZE];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
122
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
123 static struct passwd the_passwd =
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
124 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
125 the_passwd_name,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
126 the_passwd_passwd,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
127 0,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
128 0,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
129 0,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
130 the_passwd_gecos,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
131 the_passwd_dir,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
132 the_passwd_shell,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
133 };
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
134
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
135 int
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
136 getuid ()
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
137 {
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
138 return the_passwd.pw_uid;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
139 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
140
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
141 int
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
142 geteuid ()
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
143 {
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
144 /* I could imagine arguing for checking to see whether the user is
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
145 in the Administrators group and returning a UID of 0 for that
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
146 case, but I don't know how wise that would be in the long run. */
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
147 return getuid ();
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
148 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
149
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
150 int
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
151 getgid ()
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
152 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
153 return the_passwd.pw_gid;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
154 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
155
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
156 int
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
157 getegid ()
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
158 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
159 return getgid ();
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
160 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
161
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
162 struct passwd *
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
163 getpwuid (int uid)
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
164 {
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
165 if (uid == the_passwd.pw_uid)
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
166 return &the_passwd;
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
167 return NULL;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
168 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
169
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
170 struct passwd *
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
171 getpwnam (const char *name)
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
172 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
173 struct passwd *pw;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
174
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
175 pw = getpwuid (getuid ());
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
176 if (!pw)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
177 return pw;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
178
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
179 if (stricmp (name, pw->pw_name))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
180 return NULL;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
181
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
182 return pw;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
183 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
184
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
185 void
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
186 init_user_info ()
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
187 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
188 /* Find the user's real name by opening the process token and
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
189 looking up the name associated with the user-sid in that token.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
190
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
191 Use the relative portion of the identifier authority value from
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
192 the user-sid as the user id value (same for group id using the
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
193 primary group sid from the process token). */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
194
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
195 char user_sid[256], name[256], domain[256];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
196 DWORD length = sizeof (name), dlength = sizeof (domain), trash;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
197 HANDLE token = NULL;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
198 SID_NAME_USE user_type;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
199
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
200 if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &token)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
201 && GetTokenInformation (token, TokenUser,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
202 (PVOID) user_sid, sizeof (user_sid), &trash)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
203 && LookupAccountSid (NULL, *((PSID *) user_sid), name, &length,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
204 domain, &dlength, &user_type))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
205 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
206 strcpy (the_passwd.pw_name, name);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
207 /* Determine a reasonable uid value. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
208 if (stricmp ("administrator", name) == 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
209 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
210 the_passwd.pw_uid = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
211 the_passwd.pw_gid = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
212 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
213 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
214 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
215 SID_IDENTIFIER_AUTHORITY * pSIA;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
216
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
217 pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
218 /* I believe the relative portion is the last 4 bytes (of 6)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
219 with msb first. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
220 the_passwd.pw_uid = ((pSIA->Value[2] << 24) +
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
221 (pSIA->Value[3] << 16) +
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
222 (pSIA->Value[4] << 8) +
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
223 (pSIA->Value[5] << 0));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
224 /* restrict to conventional uid range for normal users */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
225 the_passwd.pw_uid = the_passwd.pw_uid % 60001;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
226
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
227 /* Get group id */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
228 if (GetTokenInformation (token, TokenPrimaryGroup,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
229 (PVOID) user_sid, sizeof (user_sid), &trash))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
230 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
231 SID_IDENTIFIER_AUTHORITY * pSIA;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
232
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
233 pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
234 the_passwd.pw_gid = ((pSIA->Value[2] << 24) +
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
235 (pSIA->Value[3] << 16) +
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
236 (pSIA->Value[4] << 8) +
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
237 (pSIA->Value[5] << 0));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
238 /* I don't know if this is necessary, but for safety... */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
239 the_passwd.pw_gid = the_passwd.pw_gid % 60001;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
240 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
241 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
242 the_passwd.pw_gid = the_passwd.pw_uid;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
243 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
244 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
245 /* If security calls are not supported (presumably because we
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
246 are running under Windows 95), fallback to this. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
247 else if (GetUserName (name, &length))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
248 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
249 strcpy (the_passwd.pw_name, name);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
250 if (stricmp ("administrator", name) == 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
251 the_passwd.pw_uid = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
252 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
253 the_passwd.pw_uid = 123;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
254 the_passwd.pw_gid = the_passwd.pw_uid;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
255 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
256 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
257 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
258 strcpy (the_passwd.pw_name, "unknown");
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
259 the_passwd.pw_uid = 123;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
260 the_passwd.pw_gid = 123;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
261 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
262
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
263 /* Ensure HOME and SHELL are defined. */
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
264 #if 0
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
265 /*
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
266 * With XEmacs, setting $HOME is deprecated.
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
267 */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
268 if (getenv ("HOME") == NULL)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
269 putenv ("HOME=c:/");
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
270 #endif
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
271 if (getenv ("SHELL") == NULL)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
272 putenv ((GetVersion () & 0x80000000) ? "SHELL=command" : "SHELL=cmd");
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
273
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
274 /* Set dir and shell from environment variables. */
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
275 strcpy (the_passwd.pw_dir, get_home_directory());
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
276 strcpy (the_passwd.pw_shell, getenv ("SHELL"));
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
277
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
278 if (token)
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
279 CloseHandle (token);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
280 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
281
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
282 /* Normalize filename by converting all path separators to
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
283 the specified separator. Also conditionally convert upper
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
284 case path name components to lower case. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
285
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
286 static void
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
287 normalize_filename (fp, path_sep)
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
288 REGISTER char *fp;
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
289 char path_sep;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
290 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
291 char sep;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
292 char *elem;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
293
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
294 /* Always lower-case drive letters a-z, even if the filesystem
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
295 preserves case in filenames.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
296 This is so filenames can be compared by string comparison
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
297 functions that are case-sensitive. Even case-preserving filesystems
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
298 do not distinguish case in drive letters. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
299 if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
300 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
301 *fp += 'a' - 'A';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
302 fp += 2;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
303 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
304
263
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
305 if (NILP (Vmswindows_downcase_file_names))
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
306 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
307 while (*fp)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
308 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
309 if (*fp == '/' || *fp == '\\')
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
310 *fp = path_sep;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
311 fp++;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
312 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
313 return;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
314 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
315
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
316 sep = path_sep; /* convert to this path separator */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
317 elem = fp; /* start of current path element */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
318
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
319 do {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
320 if (*fp >= 'a' && *fp <= 'z')
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
321 elem = 0; /* don't convert this element */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
322
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
323 if (*fp == 0 || *fp == ':')
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
324 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
325 sep = *fp; /* restore current separator (or 0) */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
326 *fp = '/'; /* after conversion of this element */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
327 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
328
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
329 if (*fp == '/' || *fp == '\\')
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
330 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
331 if (elem && elem != fp)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
332 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
333 *fp = 0; /* temporary end of string */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
334 _strlwr (elem); /* while we convert to lower case */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
335 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
336 *fp = sep; /* convert (or restore) path separator */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
337 elem = fp + 1; /* next element starts after separator */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
338 sep = path_sep;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
339 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
340 } while (*fp++);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
341 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
342
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
343 /* Destructively turn backslashes into slashes. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
344 void
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
345 dostounix_filename (p)
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
346 REGISTER char *p;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
347 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
348 normalize_filename (p, '/');
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
349 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
350
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
351 /* Destructively turn slashes into backslashes. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
352 void
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
353 unixtodos_filename (p)
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
354 REGISTER char *p;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
355 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
356 normalize_filename (p, '\\');
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
357 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
358
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
359 /* Remove all CR's that are followed by a LF.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
360 (From msdos.c...probably should figure out a way to share it,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
361 although this code isn't going to ever change.) */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
362 int
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
363 crlf_to_lf (n, buf, lf_count)
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
364 REGISTER int n;
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
365 REGISTER unsigned char *buf;
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
366 REGISTER unsigned *lf_count;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
367 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
368 unsigned char *np = buf;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
369 unsigned char *startp = buf;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
370 unsigned char *endp = buf + n;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
371
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
372 if (n == 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
373 return n;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
374 while (buf < endp - 1)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
375 {
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
376 if (*buf == 0x0a)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
377 (*lf_count)++;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
378 if (*buf == 0x0d)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
379 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
380 if (*(++buf) != 0x0a)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
381 *np++ = 0x0d;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
382 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
383 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
384 *np++ = *buf++;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
385 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
386 if (buf < endp)
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
387 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
388 if (*buf == 0x0a)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
389 (*lf_count)++;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
390 *np++ = *buf++;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
391 }
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
392 return np - startp;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
393 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
394
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
395 /* Parse the root part of file name, if present. Return length and
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
396 optionally store pointer to char after root. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
397 static int
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
398 parse_root (char * name, char ** pPath)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
399 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
400 char * start = name;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
401
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
402 if (name == NULL)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
403 return 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
404
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
405 /* find the root name of the volume if given */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
406 if (isalpha (name[0]) && name[1] == ':')
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
407 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
408 /* skip past drive specifier */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
409 name += 2;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
410 if (IS_DIRECTORY_SEP (name[0]))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
411 name++;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
412 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
413 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
414 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
415 int slashes = 2;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
416 name += 2;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
417 do
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
418 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
419 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
420 break;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
421 name++;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
422 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
423 while ( *name );
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
424 if (IS_DIRECTORY_SEP (name[0]))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
425 name++;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
426 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
427
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
428 if (pPath)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
429 *pPath = name;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
430
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
431 return name - start;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
432 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
433
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
434 /* Get long base name for name; name is assumed to be absolute. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
435 static int
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
436 get_long_basename (char * name, char * buf, int size)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
437 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
438 WIN32_FIND_DATA find_data;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
439 HANDLE dir_handle;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
440 int len = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
441 #ifdef PIGSFLY
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
442 char *p;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
443
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
444 /* If the last component of NAME has a wildcard character,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
445 return it as the basename. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
446 p = name + strlen (name);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
447 while (*p != '\\' && *p != ':' && p > name) p--;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
448 if (p > name) p++;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
449 if (strchr (p, '*') || strchr (p, '?'))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
450 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
451 if ((len = strlen (p)) < size)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
452 memcpy (buf, p, len + 1);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
453 else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
454 len = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
455 return len;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
456 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
457 #endif
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
458
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
459 dir_handle = FindFirstFile (name, &find_data);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
460 if (dir_handle != INVALID_HANDLE_VALUE)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
461 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
462 if ((len = strlen (find_data.cFileName)) < size)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
463 memcpy (buf, find_data.cFileName, len + 1);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
464 else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
465 len = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
466 FindClose (dir_handle);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
467 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
468 return len;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
469 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
470
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
471 /* Get long name for file, if possible (assumed to be absolute). */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
472 BOOL
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
473 win32_get_long_filename (char * name, char * buf, int size)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
474 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
475 char * o = buf;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
476 char * p;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
477 char * q;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
478 char full[ MAX_PATH ];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
479 int len;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
480
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
481 len = strlen (name);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
482 if (len >= MAX_PATH)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
483 return FALSE;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
484
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
485 /* Use local copy for destructive modification. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
486 memcpy (full, name, len+1);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
487 unixtodos_filename (full);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
488
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
489 /* Copy root part verbatim. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
490 len = parse_root (full, &p);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
491 memcpy (o, full, len);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
492 o += len;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
493 size -= len;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
494
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
495 do
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
496 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
497 q = p;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
498 p = strchr (q, '\\');
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
499 if (p) *p = '\0';
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
500 len = get_long_basename (full, o, size);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
501 if (len > 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
502 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
503 o += len;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
504 size -= len;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
505 if (p != NULL)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
506 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
507 *p++ = '\\';
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
508 if (size < 2)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
509 return FALSE;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
510 *o++ = '\\';
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
511 size--;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
512 *o = '\0';
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
513 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
514 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
515 else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
516 return FALSE;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
517 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
518 while (p != NULL && *p);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
519
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
520 return TRUE;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
521 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
522
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
523
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
524 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
525
239
41f2f0e326e9 Import from CVS: tag r20-5b18
cvs
parents: 223
diff changeset
526 #if 0 /* #### We do not need those, do we? -kkm */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
527 int
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
528 unrequest_sigio (void)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
529 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
530 return 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
531 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
532
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
533 int
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
534 request_sigio (void)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
535 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
536 return 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
537 }
239
41f2f0e326e9 Import from CVS: tag r20-5b18
cvs
parents: 223
diff changeset
538 #endif /* 0 */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
539
213
78f53ef88e17 Import from CVS: tag r20-4b5
cvs
parents: 211
diff changeset
540 #define REG_ROOT "SOFTWARE\\GNU\\XEmacs"
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
541
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
542 LPBYTE
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
543 nt_get_resource (key, lpdwtype)
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
544 char *key;
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
545 LPDWORD lpdwtype;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
546 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
547 LPBYTE lpvalue;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
548 HKEY hrootkey = NULL;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
549 DWORD cbData;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
550
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
551 /* Check both the current user and the local machine to see if
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
552 we have any resources. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
553
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
554 if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
555 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
556 lpvalue = NULL;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
557
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
558 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
559 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
560 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
561 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
562 return (lpvalue);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
563 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
564
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
565 if (lpvalue) xfree (lpvalue);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
566
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
567 RegCloseKey (hrootkey);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
568 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
569
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
570 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
571 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
572 lpvalue = NULL;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
573
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
574 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS &&
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
575 (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL &&
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
576 RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
577 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
578 return (lpvalue);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
579 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
580
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
581 if (lpvalue) xfree (lpvalue);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
582
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
583 RegCloseKey (hrootkey);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
584 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
585
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
586 return (NULL);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
587 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
588
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
589 void
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
590 init_environment ()
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
591 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
592 /* Check for environment variables and use registry if they don't exist */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
593 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
594 int i;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
595 LPBYTE lpval;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
596 DWORD dwType;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
597
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
598 static char * env_vars[] =
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
599 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
600 "HOME",
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
601 "emacs_dir",
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
602 "EMACSLOADPATH",
298
70ad99077275 Import from CVS: tag r21-0b47
cvs
parents: 290
diff changeset
603 "EMACSDEBUGPATHS",
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
604 "SHELL",
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
605 "CMDPROXY",
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
606 "EMACSDATA",
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
607 "EMACSPATH",
298
70ad99077275 Import from CVS: tag r21-0b47
cvs
parents: 290
diff changeset
608 "EMACSPACKAGEPATH",
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
609 "EMACSLOCKDIR",
298
70ad99077275 Import from CVS: tag r21-0b47
cvs
parents: 290
diff changeset
610 "INFOPATH"
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
611 };
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
612
272
c5d627a313b1 Import from CVS: tag r21-0b34
cvs
parents: 263
diff changeset
613 for (i = 0; i < countof (env_vars); i++)
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
614 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
615 if (!getenv (env_vars[i]) &&
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
616 (lpval = nt_get_resource (env_vars[i], &dwType)) != NULL)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
617 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
618 if (dwType == REG_EXPAND_SZ)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
619 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
620 char buf1[500], buf2[500];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
621
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
622 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, 500);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
623 _snprintf (buf2, 499, "%s=%s", env_vars[i], buf1);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
624 putenv (strdup (buf2));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
625 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
626 else if (dwType == REG_SZ)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
627 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
628 char buf[500];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
629
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
630 _snprintf (buf, 499, "%s=%s", env_vars[i], lpval);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
631 putenv (strdup (buf));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
632 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
633
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
634 xfree (lpval);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
635 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
636 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
637 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
638
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
639 /* Another special case: on NT, the PATH variable is actually named
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
640 "Path" although cmd.exe (perhaps NT itself) arranges for
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
641 environment variable lookup and setting to be case insensitive.
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
642 However, Emacs assumes a fully case sensitive environment, so we
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
643 need to change "Path" to "PATH" to match the expectations of
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
644 various elisp packages. We do this by the sneaky method of
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
645 modifying the string in the C runtime environ entry.
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
646
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
647 The same applies to COMSPEC. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
648 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
649 char ** envp;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
650
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
651 for (envp = environ; *envp; envp++)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
652 if (_strnicmp (*envp, "PATH=", 5) == 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
653 memcpy (*envp, "PATH=", 5);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
654 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
655 memcpy (*envp, "COMSPEC=", 8);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
656 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
657
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
658 /* Remember the initial working directory for getwd, then make the
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
659 real wd be the location of emacs.exe to avoid conflicts when
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
660 renaming or deleting directories. (We also don't call chdir when
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
661 running subprocesses for the same reason.) */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
662 if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
663 abort ();
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
664
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
665 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
666 char *p;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
667 char modname[MAX_PATH];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
668
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
669 if (!GetModuleFileName (NULL, modname, MAX_PATH))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
670 abort ();
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
671 if ((p = strrchr (modname, '\\')) == NULL)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
672 abort ();
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
673 *p = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
674
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
675 SetCurrentDirectory (modname);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
676 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
677
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
678 init_user_info ();
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
679 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
680
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
681 #ifndef HAVE_X_WINDOWS
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
682 /* X11R6 on NT provides the single parameter version of this command. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
683
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
684 #include <sys/timeb.h>
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
685
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
686 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
687 void
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
688 gettimeofday (struct timeval *tv, struct timezone *tz)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
689 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
690 struct _timeb tb;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
691 _ftime (&tb);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
692
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
693 tv->tv_sec = tb.time;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
694 tv->tv_usec = tb.millitm * 1000L;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
695 if (tz)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
696 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
697 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
698 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
699 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
700 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
701
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
702 #endif /* HAVE_X_WINDOWS */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
703
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
704 /* ------------------------------------------------------------------------- */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
705 /* IO support and wrapper functions for Win32 API. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
706 /* ------------------------------------------------------------------------- */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
707
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
708 /* Place a wrapper around the MSVC version of ctime. It returns NULL
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
709 on network directories, so we handle that case here.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
710 (Ulrich Leodolter, 1/11/95). */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
711 char *
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
712 sys_ctime (const time_t *t)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
713 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
714 char *str = (char *) ctime (t);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
715 return (str ? str : "Sun Jan 01 00:00:00 1970");
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
716 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
717
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
718 /* Emulate sleep...we could have done this with a define, but that
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
719 would necessitate including windows.h in the files that used it.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
720 This is much easier. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
721
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
722 #ifndef HAVE_X_WINDOWS
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
723 void
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
724 sys_sleep (int seconds)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
725 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
726 Sleep (seconds * 1000);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
727 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
728 #endif
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
729
239
41f2f0e326e9 Import from CVS: tag r20-5b18
cvs
parents: 223
diff changeset
730 /* #### This is an evil dirty hack. We must get rid of it.
41f2f0e326e9 Import from CVS: tag r20-5b18
cvs
parents: 223
diff changeset
731 Word "munging" is not in XEmacs lexicon. - kkm */
41f2f0e326e9 Import from CVS: tag r20-5b18
cvs
parents: 223
diff changeset
732
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
733 /* Internal MSVC data and functions for low-level descriptor munging */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
734 #if (_MSC_VER == 900)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
735 extern char _osfile[];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
736 #endif
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
737 extern int __cdecl _set_osfhnd (int fd, long h);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
738 extern int __cdecl _free_osfhnd (int fd);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
739
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
740 /* parallel array of private info on file handles */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
741 filedesc fd_info [ MAXDESC ];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
742
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
743 typedef struct volume_info_data {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
744 struct volume_info_data * next;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
745
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
746 /* time when info was obtained */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
747 DWORD timestamp;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
748
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
749 /* actual volume info */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
750 char * root_dir;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
751 DWORD serialnum;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
752 DWORD maxcomp;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
753 DWORD flags;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
754 char * name;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
755 char * type;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
756 } volume_info_data;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
757
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
758 /* Global referenced by various functions. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
759 static volume_info_data volume_info;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
760
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
761 /* Vector to indicate which drives are local and fixed (for which cached
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
762 data never expires). */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
763 static BOOL fixed_drives[26];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
764
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
765 /* Consider cached volume information to be stale if older than 10s,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
766 at least for non-local drives. Info for fixed drives is never stale. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
767 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
768 #define VOLINFO_STILL_VALID( root_dir, info ) \
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
769 ( ( isalpha (root_dir[0]) && \
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
770 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
771 || GetTickCount () - info->timestamp < 10000 )
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
772
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
773 /* Cache support functions. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
774
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
775 /* Simple linked list with linear search is sufficient. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
776 static volume_info_data *volume_cache = NULL;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
777
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
778 static volume_info_data *
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
779 lookup_volume_info (char * root_dir)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
780 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
781 volume_info_data * info;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
782
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
783 for (info = volume_cache; info; info = info->next)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
784 if (stricmp (info->root_dir, root_dir) == 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
785 break;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
786 return info;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
787 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
788
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
789 static void
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
790 add_volume_info (char * root_dir, volume_info_data * info)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
791 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
792 info->root_dir = xstrdup (root_dir);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
793 info->next = volume_cache;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
794 volume_cache = info;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
795 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
796
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
797
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
798 /* Wrapper for GetVolumeInformation, which uses caching to avoid
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
799 performance penalty (~2ms on 486 for local drives, 7.5ms for local
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
800 cdrom drive, ~5-10ms or more for remote drives on LAN). */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
801 volume_info_data *
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
802 GetCachedVolumeInformation (char * root_dir)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
803 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
804 volume_info_data * info;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
805 char default_root[ MAX_PATH ];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
806
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
807 /* NULL for root_dir means use root from current directory. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
808 if (root_dir == NULL)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
809 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
810 if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
811 return NULL;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
812 parse_root (default_root, &root_dir);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
813 *root_dir = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
814 root_dir = default_root;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
815 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
816
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
817 /* Local fixed drives can be cached permanently. Removable drives
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
818 cannot be cached permanently, since the volume name and serial
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
819 number (if nothing else) can change. Remote drives should be
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
820 treated as if they are removable, since there is no sure way to
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
821 tell whether they are or not. Also, the UNC association of drive
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
822 letters mapped to remote volumes can be changed at any time (even
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
823 by other processes) without notice.
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
824
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
825 As a compromise, so we can benefit from caching info for remote
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
826 volumes, we use a simple expiry mechanism to invalidate cache
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
827 entries that are more than ten seconds old. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
828
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
829 #if 0
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
830 /* No point doing this, because WNetGetConnection is even slower than
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
831 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
832 GetDriveType is about the only call of this type which does not
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
833 involve network access, and so is extremely quick). */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
834
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
835 /* Map drive letter to UNC if remote. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
836 if ( isalpha( root_dir[0] ) && !fixed[ DRIVE_INDEX( root_dir[0] ) ] )
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
837 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
838 char remote_name[ 256 ];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
839 char drive[3] = { root_dir[0], ':' };
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
840
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
841 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
842 == NO_ERROR)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
843 /* do something */ ;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
844 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
845 #endif
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
846
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
847 info = lookup_volume_info (root_dir);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
848
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
849 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
850 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
851 char name[ 256 ];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
852 DWORD serialnum;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
853 DWORD maxcomp;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
854 DWORD flags;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
855 char type[ 256 ];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
856
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
857 /* Info is not cached, or is stale. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
858 if (!GetVolumeInformation (root_dir,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
859 name, sizeof (name),
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
860 &serialnum,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
861 &maxcomp,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
862 &flags,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
863 type, sizeof (type)))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
864 return NULL;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
865
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
866 /* Cache the volume information for future use, overwriting existing
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
867 entry if present. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
868 if (info == NULL)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
869 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
870 info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
871 add_volume_info (root_dir, info);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
872 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
873 else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
874 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
875 free (info->name);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
876 free (info->type);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
877 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
878
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
879 info->name = xstrdup (name);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
880 info->serialnum = serialnum;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
881 info->maxcomp = maxcomp;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
882 info->flags = flags;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
883 info->type = xstrdup (type);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
884 info->timestamp = GetTickCount ();
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
885 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
886
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
887 return info;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
888 }
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
889
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
890 /* Get information on the volume where name is held; set path pointer to
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
891 start of pathname in name (past UNC header\volume header if present). */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
892 int
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
893 get_volume_info (const char * name, const char ** pPath)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
894 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
895 char temp[MAX_PATH];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
896 char *rootname = NULL; /* default to current volume */
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
897 volume_info_data * info;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
898
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
899 if (name == NULL)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
900 return FALSE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
901
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
902 /* find the root name of the volume if given */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
903 if (isalpha (name[0]) && name[1] == ':')
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
904 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
905 rootname = temp;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
906 temp[0] = *name++;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
907 temp[1] = *name++;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
908 temp[2] = '\\';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
909 temp[3] = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
910 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
911 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
912 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
913 char *str = temp;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
914 int slashes = 4;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
915 rootname = temp;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
916 do
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
917 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
918 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
919 break;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
920 *str++ = *name++;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
921 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
922 while ( *name );
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
923
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
924 *str++ = '\\';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
925 *str = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
926 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
927
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
928 if (pPath)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
929 *pPath = name;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
930
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
931 info = GetCachedVolumeInformation (rootname);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
932 if (info != NULL)
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
933 {
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
934 /* Set global referenced by other functions. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
935 volume_info = *info;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
936 return TRUE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
937 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
938 return FALSE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
939 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
940
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
941 /* Determine if volume is FAT format (ie. only supports short 8.3
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
942 names); also set path pointer to start of pathname in name. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
943 int
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
944 is_fat_volume (const char * name, const char ** pPath)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
945 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
946 if (get_volume_info (name, pPath))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
947 return (volume_info.maxcomp == 12);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
948 return FALSE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
949 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
950
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
951 /* Map filename to a legal 8.3 name if necessary. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
952 const char *
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
953 map_win32_filename (const char * name, const char ** pPath)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
954 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
955 static char shortname[MAX_PATH];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
956 char * str = shortname;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
957 char c;
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
958 const char * path;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
959 const char * save_name = name;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
960
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
961 if (is_fat_volume (name, &path)) /* truncate to 8.3 */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
962 {
203
850242ba4a81 Import from CVS: tag r20-3b28
cvs
parents: 100
diff changeset
963 REGISTER int left = 8; /* maximum number of chars in part */
850242ba4a81 Import from CVS: tag r20-3b28
cvs
parents: 100
diff changeset
964 REGISTER int extn = 0; /* extension added? */
850242ba4a81 Import from CVS: tag r20-3b28
cvs
parents: 100
diff changeset
965 REGISTER int dots = 2; /* maximum number of dots allowed */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
966
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
967 while (name < path)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
968 *str++ = *name++; /* skip past UNC header */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
969
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
970 while ((c = *name++))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
971 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
972 switch ( c )
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
973 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
974 case '\\':
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
975 case '/':
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
976 *str++ = '\\';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
977 extn = 0; /* reset extension flags */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
978 dots = 2; /* max 2 dots */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
979 left = 8; /* max length 8 for main part */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
980 break;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
981 case ':':
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
982 *str++ = ':';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
983 extn = 0; /* reset extension flags */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
984 dots = 2; /* max 2 dots */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
985 left = 8; /* max length 8 for main part */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
986 break;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
987 case '.':
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
988 if ( dots )
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
989 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
990 /* Convert path components of the form .xxx to _xxx,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
991 but leave . and .. as they are. This allows .emacs
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
992 to be read as _emacs, for example. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
993
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
994 if (! *name ||
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
995 *name == '.' ||
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
996 IS_DIRECTORY_SEP (*name))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
997 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
998 *str++ = '.';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
999 dots--;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1000 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1001 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1002 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1003 *str++ = '_';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1004 left--;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1005 dots = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1006 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1007 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1008 else if ( !extn )
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1009 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1010 *str++ = '.';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1011 extn = 1; /* we've got an extension */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1012 left = 3; /* 3 chars in extension */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1013 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1014 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1015 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1016 /* any embedded dots after the first are converted to _ */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1017 *str++ = '_';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1018 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1019 break;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1020 case '~':
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1021 case '#': /* don't lose these, they're important */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1022 if ( ! left )
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1023 str[-1] = c; /* replace last character of part */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1024 /* FALLTHRU */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1025 default:
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1026 if ( left )
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1027 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1028 *str++ = tolower (c); /* map to lower case (looks nicer) */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1029 left--;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1030 dots = 0; /* started a path component */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1031 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1032 break;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1033 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1034 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1035 *str = '\0';
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1036 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1037 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1038 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1039 strcpy (shortname, name);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1040 unixtodos_filename (shortname);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1041 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1042
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1043 if (pPath)
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1044 *pPath = shortname + (path - save_name);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1045
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1046 return shortname;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1047 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1048
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1049
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1050 /* Emulate the Unix directory procedures opendir, closedir,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1051 and readdir. We can't use the procedures supplied in sysdep.c,
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1052 so we provide them here. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1053
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1054 struct direct dir_static; /* simulated directory contents */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1055 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1056 static int dir_is_fat;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1057 static char dir_pathname[MAXPATHLEN+1];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1058 static WIN32_FIND_DATA dir_find_data;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1059
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1060 DIR *
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1061 opendir (const char *filename)
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1062 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1063 DIR *dirp;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1064
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1065 /* Opening is done by FindFirstFile. However, a read is inherent to
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1066 this operation, so we defer the open until read time. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1067
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1068 if (!(dirp = xnew_and_zero(DIR)))
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1069 return NULL;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1070 if (dir_find_handle != INVALID_HANDLE_VALUE)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1071 return NULL;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1072
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1073 dirp->dd_fd = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1074 dirp->dd_loc = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1075 dirp->dd_size = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1076
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1077 strncpy (dir_pathname, map_win32_filename (filename, NULL), MAXPATHLEN);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1078 dir_pathname[MAXPATHLEN] = '\0';
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1079 dir_is_fat = is_fat_volume (filename, NULL);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1080
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1081 return dirp;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1082 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1083
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1084 void
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1085 closedir (DIR *dirp)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1086 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1087 /* If we have a find-handle open, close it. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1088 if (dir_find_handle != INVALID_HANDLE_VALUE)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1089 {
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1090 FindClose (dir_find_handle);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1091 dir_find_handle = INVALID_HANDLE_VALUE;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1092 }
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1093 xfree (dirp);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1094 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1095
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1096 struct direct *
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1097 readdir (DIR *dirp)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1098 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1099 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1100 if (dir_find_handle == INVALID_HANDLE_VALUE)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1101 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1102 char filename[MAXNAMLEN + 3];
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1103 int ln;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1104
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1105 strcpy (filename, dir_pathname);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1106 ln = strlen (filename) - 1;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1107 if (!IS_DIRECTORY_SEP (filename[ln]))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1108 strcat (filename, "\\");
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1109 strcat (filename, "*");
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1110
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1111 dir_find_handle = FindFirstFile (filename, &dir_find_data);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1112
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1113 if (dir_find_handle == INVALID_HANDLE_VALUE)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1114 return NULL;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1115 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1116 else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1117 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1118 if (!FindNextFile (dir_find_handle, &dir_find_data))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1119 return NULL;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1120 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1121
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1122 /* Emacs never uses this value, so don't bother making it match
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1123 value returned by stat(). */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1124 dir_static.d_ino = 1;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1125
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1126 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1127 dir_static.d_namlen - dir_static.d_namlen % 4;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1128
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1129 dir_static.d_namlen = strlen (dir_find_data.cFileName);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1130 strcpy (dir_static.d_name, dir_find_data.cFileName);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1131 if (dir_is_fat)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1132 _strlwr (dir_static.d_name);
263
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
1133 else if (!NILP (Vmswindows_downcase_file_names))
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1134 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1135 REGISTER char *p;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1136 for (p = dir_static.d_name; *p; p++)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1137 if (*p >= 'a' && *p <= 'z')
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1138 break;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1139 if (!*p)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1140 _strlwr (dir_static.d_name);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1141 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1142
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1143 return &dir_static;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1144 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1145
290
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
1146 #if 0
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
1147 /* #### Have to check if all that sad story about '95 is true - kkm */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1148 int
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1149 sys_rename (const char * oldname, const char * newname)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1150 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1151 char temp[MAX_PATH];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1152 DWORD attr;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1153
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1154 /* MoveFile on Win95 doesn't correctly change the short file name
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1155 alias in a number of circumstances (it is not easy to predict when
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1156 just by looking at oldname and newname, unfortunately). In these
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1157 cases, renaming through a temporary name avoids the problem.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1158
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1159 A second problem on Win95 is that renaming through a temp name when
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1160 newname is uppercase fails (the final long name ends up in
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1161 lowercase, although the short alias might be uppercase) UNLESS the
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1162 long temp name is not 8.3.
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1163
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1164 So, on Win95 we always rename through a temp name, and we make sure
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1165 the temp name has a long extension to ensure correct renaming. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1166
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1167 strcpy (temp, map_win32_filename (oldname, NULL));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1168
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1169 if (GetVersion () & 0x80000000)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1170 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1171 char * p;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1172
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1173 if (p = strrchr (temp, '\\'))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1174 p++;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1175 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1176 p = temp;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1177 /* Force temp name to require a manufactured 8.3 alias - this
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1178 seems to make the second rename work properly. */
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1179 strcpy (p, "_rename_temp.XXXXXX");
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1180 sys_mktemp (temp);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1181 if (rename (map_win32_filename (oldname, NULL), temp) < 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1182 return -1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1183 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1184
380
8626e4521993 Import from CVS: tag r21-2-5
cvs
parents: 371
diff changeset
1185 /* Emulate Unix behavior - newname is deleted if it already exists
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1186 (at least if it is a file; don't do this for directories).
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1187 However, don't do this if we are just changing the case of the file
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1188 name - we will end up deleting the file we are trying to rename! */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1189 newname = map_win32_filename (newname, NULL);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1190
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1191 /* TODO: Use GetInformationByHandle (on NT) to ensure newname and temp
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1192 do not refer to the same file, eg. through share aliases. */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1193 if (stricmp (newname, temp) != 0
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1194 && (attr = GetFileAttributes (newname)) != -1
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1195 && (attr & FILE_ATTRIBUTE_DIRECTORY) == 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1196 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1197 _chmod (newname, 0666);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1198 _unlink (newname);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1199 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1200
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1201 return rename (temp, newname);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1202 }
290
c9fe270a4101 Import from CVS: tag r21-0b43
cvs
parents: 288
diff changeset
1203 #endif /* 0 */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1204
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1205 static FILETIME utc_base_ft;
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1206 static long double utc_base;
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1207 static int init = 0;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1208
263
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
1209 time_t
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1210 convert_time (FILETIME ft)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1211 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1212 long double ret;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1213
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1214 if (!init)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1215 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1216 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1217 SYSTEMTIME st;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1218
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1219 st.wYear = 1970;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1220 st.wMonth = 1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1221 st.wDay = 1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1222 st.wHour = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1223 st.wMinute = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1224 st.wSecond = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1225 st.wMilliseconds = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1226
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1227 SystemTimeToFileTime (&st, &utc_base_ft);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1228 utc_base = (long double) utc_base_ft.dwHighDateTime
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1229 * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1230 init = 1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1231 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1232
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1233 if (CompareFileTime (&ft, &utc_base_ft) < 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1234 return 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1235
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1236 ret = (long double) ft.dwHighDateTime * 4096 * 1024 * 1024 + ft.dwLowDateTime;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1237 ret -= utc_base;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1238 return (time_t) (ret * 1e-7);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1239 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1240
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1241 #if 0
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1242 /* in case we ever have need of this */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1243 void
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1244 convert_from_time_t (time_t time, FILETIME * pft)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1245 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1246 long double tmp;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1247
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1248 if (!init)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1249 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1250 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1251 SYSTEMTIME st;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1252
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1253 st.wYear = 1970;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1254 st.wMonth = 1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1255 st.wDay = 1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1256 st.wHour = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1257 st.wMinute = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1258 st.wSecond = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1259 st.wMilliseconds = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1260
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1261 SystemTimeToFileTime (&st, &utc_base_ft);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1262 utc_base = (long double) utc_base_ft.dwHighDateTime
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1263 * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1264 init = 1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1265 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1266
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1267 /* time in 100ns units since 1-Jan-1601 */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1268 tmp = (long double) time * 1e7 + utc_base;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1269 pft->dwHighDateTime = (DWORD) (tmp / (4096.0 * 1024 * 1024));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1270 pft->dwLowDateTime = (DWORD) (tmp - pft->dwHighDateTime);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1271 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1272 #endif
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1273
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1274 #if 0
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1275 /* No reason to keep this; faking inode values either by hashing or even
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1276 using the file index from GetInformationByHandle, is not perfect and
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1277 so by default Emacs doesn't use the inode values on Windows.
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1278 Instead, we now determine file-truename correctly (except for
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1279 possible drive aliasing etc). */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1280
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1281 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1282 static unsigned
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1283 hashval (const unsigned char * str)
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1284 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1285 unsigned h = 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1286 while (*str)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1287 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1288 h = (h << 4) + *str++;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1289 h ^= (h >> 28);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1290 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1291 return h;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1292 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1293
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1294 /* Return the hash value of the canonical pathname, excluding the
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1295 drive/UNC header, to get a hopefully unique inode number. */
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1296 static DWORD
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1297 generate_inode_val (const char * name)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1298 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1299 char fullname[ MAX_PATH ];
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1300 char * p;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1301 unsigned hash;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1302
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1303 /* Get the truly canonical filename, if it exists. (Note: this
380
8626e4521993 Import from CVS: tag r21-2-5
cvs
parents: 371
diff changeset
1304 doesn't resolve aliasing due to subst commands, or recognize hard
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1305 links. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1306 if (!win32_get_long_filename ((char *)name, fullname, MAX_PATH))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1307 abort ();
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1308
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1309 parse_root (fullname, &p);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1310 /* Normal Win32 filesystems are still case insensitive. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1311 _strlwr (p);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1312 return hashval (p);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1313 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1314
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1315 #endif
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1316
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1317 /* MSVC stat function can't cope with UNC names and has other bugs, so
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1318 replace it with our own. This also allows us to calculate consistent
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1319 inode values without hacks in the main Emacs code. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1320 int
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1321 stat (const char * path, struct stat * buf)
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1322 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1323 char * name;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1324 WIN32_FIND_DATA wfd;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1325 HANDLE fh;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1326 DWORD fake_inode;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1327 int permission;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1328 int len;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1329 int rootdir = FALSE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1330
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1331 if (path == NULL || buf == NULL)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1332 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1333 errno = EFAULT;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1334 return -1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1335 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1336
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1337 name = (char *) map_win32_filename (path, &path);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1338 /* must be valid filename, no wild cards */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1339 if (strchr (name, '*') || strchr (name, '?'))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1340 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1341 errno = ENOENT;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1342 return -1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1343 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1344
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1345 /* Remove trailing directory separator, unless name is the root
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1346 directory of a drive or UNC volume in which case ensure there
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1347 is a trailing separator. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1348 len = strlen (name);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1349 rootdir = (path >= name + len - 1
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1350 && (IS_DIRECTORY_SEP (*path) || *path == 0));
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1351 name = strcpy (alloca (len + 2), name);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1352
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1353 if (rootdir)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1354 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1355 if (!IS_DIRECTORY_SEP (name[len-1]))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1356 strcat (name, "\\");
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1357 if (GetDriveType (name) < 2)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1358 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1359 errno = ENOENT;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1360 return -1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1361 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1362 memset (&wfd, 0, sizeof (wfd));
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1363 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1364 wfd.ftCreationTime = utc_base_ft;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1365 wfd.ftLastAccessTime = utc_base_ft;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1366 wfd.ftLastWriteTime = utc_base_ft;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1367 strcpy (wfd.cFileName, name);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1368 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1369 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1370 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1371 if (IS_DIRECTORY_SEP (name[len-1]))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1372 name[len - 1] = 0;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1373
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1374 /* (This is hacky, but helps when doing file completions on
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1375 network drives.) Optimize by using information available from
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1376 active readdir if possible. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1377 if (dir_find_handle != INVALID_HANDLE_VALUE &&
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1378 (len = strlen (dir_pathname)),
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1379 strnicmp (name, dir_pathname, len) == 0 &&
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1380 IS_DIRECTORY_SEP (name[len]) &&
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1381 stricmp (name + len + 1, dir_static.d_name) == 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1382 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1383 /* This was the last entry returned by readdir. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1384 wfd = dir_find_data;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1385 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1386 else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1387 {
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1388 fh = FindFirstFile (name, &wfd);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1389 if (fh == INVALID_HANDLE_VALUE)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1390 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1391 errno = ENOENT;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1392 return -1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1393 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1394 FindClose (fh);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1395 }
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1396 }
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1397
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1398 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1399 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1400 buf->st_mode = _S_IFDIR;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1401 buf->st_nlink = 2; /* doesn't really matter */
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1402 fake_inode = 0; /* this doesn't either I think */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1403 }
263
727739f917cb Import from CVS: tag r20-5b30
cvs
parents: 239
diff changeset
1404 else if (!NILP (Vmswindows_get_true_file_attributes))
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1405 {
380
8626e4521993 Import from CVS: tag r21-2-5
cvs
parents: 371
diff changeset
1406 /* This is more accurate in terms of getting the correct number
8626e4521993 Import from CVS: tag r21-2-5
cvs
parents: 371
diff changeset
1407 of links, but is quite slow (it is noticeable when Emacs is
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1408 making a list of file name completions). */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1409 BY_HANDLE_FILE_INFORMATION info;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1410
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1411 /* No access rights required to get info. */
211
78478c60bfcd Import from CVS: tag r20-4b4
cvs
parents: 209
diff changeset
1412 fh = CreateFile (name, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
78478c60bfcd Import from CVS: tag r20-4b4
cvs
parents: 209
diff changeset
1413 OPEN_EXISTING, 0, NULL);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1414
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1415 if (GetFileInformationByHandle (fh, &info))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1416 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1417 switch (GetFileType (fh))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1418 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1419 case FILE_TYPE_DISK:
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1420 buf->st_mode = _S_IFREG;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1421 break;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1422 case FILE_TYPE_PIPE:
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1423 buf->st_mode = _S_IFIFO;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1424 break;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1425 case FILE_TYPE_CHAR:
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1426 case FILE_TYPE_UNKNOWN:
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1427 default:
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1428 buf->st_mode = _S_IFCHR;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1429 }
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1430 buf->st_nlink = (short) info.nNumberOfLinks;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1431 /* Might as well use file index to fake inode values, but this
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1432 is not guaranteed to be unique unless we keep a handle open
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1433 all the time (even then there are situations where it is
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1434 not unique). Reputedly, there are at most 48 bits of info
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1435 (on NTFS, presumably less on FAT). */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1436 fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1437 CloseHandle (fh);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1438 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1439 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1440 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1441 errno = EACCES;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1442 return -1;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1443 }
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1444 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1445 else
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1446 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1447 /* Don't bother to make this information more accurate. */
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1448 buf->st_mode = _S_IFREG;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1449 buf->st_nlink = 1;
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1450 fake_inode = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1451 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1452
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1453 #if 0
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1454 /* Not sure if there is any point in this. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1455 if (!NILP (Vwin32_generate_fake_inodes))
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1456 fake_inode = generate_inode_val (name);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1457 else if (fake_inode == 0)
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1458 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1459 /* For want of something better, try to make everything unique. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1460 static DWORD gen_num = 0;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1461 fake_inode = ++gen_num;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1462 }
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1463 #endif
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1464
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1465 /* #### MSVC defines _ino_t to be short; other libc's might not. */
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1466 buf->st_ino = (unsigned short) (fake_inode ^ (fake_inode >> 16));
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1467
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1468 /* consider files to belong to current user */
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1469 buf->st_uid = the_passwd.pw_uid;
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1470 buf->st_gid = the_passwd.pw_gid;
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1471
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1472 /* volume_info is set indirectly by map_win32_filename */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1473 buf->st_dev = volume_info.serialnum;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1474 buf->st_rdev = volume_info.serialnum;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1475
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1476
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1477 buf->st_size = wfd.nFileSizeLow;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1478
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1479 /* Convert timestamps to Unix format. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1480 buf->st_mtime = convert_time (wfd.ftLastWriteTime);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1481 buf->st_atime = convert_time (wfd.ftLastAccessTime);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1482 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1483 buf->st_ctime = convert_time (wfd.ftCreationTime);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1484 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1485
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1486 /* determine rwx permissions */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1487 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1488 permission = _S_IREAD;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1489 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1490 permission = _S_IREAD | _S_IWRITE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1491
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1492 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1493 permission |= _S_IEXEC;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1494 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1495 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1496 char * p = strrchr (name, '.');
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1497 if (p != NULL &&
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1498 (stricmp (p, ".exe") == 0 ||
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1499 stricmp (p, ".com") == 0 ||
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1500 stricmp (p, ".bat") == 0 ||
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1501 stricmp (p, ".cmd") == 0))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1502 permission |= _S_IEXEC;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1503 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1504
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1505 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1506
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1507 return 0;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1508 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1509
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1510 /* From callproc.c */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1511 extern Lisp_Object Vbinary_process_input;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1512 extern Lisp_Object Vbinary_process_output;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1513
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1514 /* Unix pipe() has only one arg */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1515 int
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1516 sys_pipe (int * phandles)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1517 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1518 int rc;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1519 unsigned flags;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1520
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1521 /* make pipe handles non-inheritable; when we spawn a child, we
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1522 replace the relevant handle with an inheritable one. Also put
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1523 pipes into binary mode; we will do text mode translation ourselves
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1524 if required. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1525 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1526
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1527 if (rc == 0)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1528 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1529 flags = FILE_PIPE | FILE_READ;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1530 if (!NILP (Vbinary_process_output))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1531 flags |= FILE_BINARY;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1532 fd_info[phandles[0]].flags = flags;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1533
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1534 flags = FILE_PIPE | FILE_WRITE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1535 if (!NILP (Vbinary_process_input))
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1536 flags |= FILE_BINARY;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1537 fd_info[phandles[1]].flags = flags;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1538 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1539
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1540 return rc;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1541 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1542
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1543 void
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1544 term_ntproc (int unused)
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1545 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1546 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1547
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1548 void
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1549 init_ntproc ()
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1550 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1551 /* Initial preparation for subprocess support: replace our standard
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1552 handles with non-inheritable versions. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1553 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1554 HANDLE parent;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1555 HANDLE stdin_save = INVALID_HANDLE_VALUE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1556 HANDLE stdout_save = INVALID_HANDLE_VALUE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1557 HANDLE stderr_save = INVALID_HANDLE_VALUE;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1558
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1559 parent = GetCurrentProcess ();
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1560
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1561 /* ignore errors when duplicating and closing; typically the
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1562 handles will be invalid when running as a gui program. */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1563 DuplicateHandle (parent,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1564 GetStdHandle (STD_INPUT_HANDLE),
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1565 parent,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1566 &stdin_save,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1567 0,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1568 FALSE,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1569 DUPLICATE_SAME_ACCESS);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1570
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1571 DuplicateHandle (parent,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1572 GetStdHandle (STD_OUTPUT_HANDLE),
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1573 parent,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1574 &stdout_save,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1575 0,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1576 FALSE,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1577 DUPLICATE_SAME_ACCESS);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1578
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1579 DuplicateHandle (parent,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1580 GetStdHandle (STD_ERROR_HANDLE),
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1581 parent,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1582 &stderr_save,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1583 0,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1584 FALSE,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1585 DUPLICATE_SAME_ACCESS);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1586
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1587 fclose (stdin);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1588 fclose (stdout);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1589 fclose (stderr);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1590
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1591 if (stdin_save != INVALID_HANDLE_VALUE)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1592 _open_osfhandle ((long) stdin_save, O_TEXT);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1593 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1594 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1595 _fdopen (0, "r");
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1596
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1597 if (stdout_save != INVALID_HANDLE_VALUE)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1598 _open_osfhandle ((long) stdout_save, O_TEXT);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1599 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1600 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1601 _fdopen (1, "w");
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1602
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1603 if (stderr_save != INVALID_HANDLE_VALUE)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1604 _open_osfhandle ((long) stderr_save, O_TEXT);
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1605 else
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1606 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1607 _fdopen (2, "w");
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1608 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1609
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1610 /* unfortunately, atexit depends on implementation of malloc */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1611 /* atexit (term_ntproc); */
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1612 signal (SIGABRT, term_ntproc);
209
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1613
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1614 /* determine which drives are fixed, for GetCachedVolumeInformation */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1615 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1616 /* GetDriveType must have trailing backslash. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1617 char drive[] = "A:\\";
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1618
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1619 /* Loop over all possible drive letters */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1620 while ( *drive <= 'Z' )
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1621 {
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1622 /* Record if this drive letter refers to a fixed drive. */
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1623 fixed_drives[ DRIVE_INDEX (*drive) ] =
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1624 (GetDriveType (drive) == DRIVE_FIXED);
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1625
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1626 (*drive)++;
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1627 }
41ff10fd062f Import from CVS: tag r20-4b3
cvs
parents: 203
diff changeset
1628 }
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1629 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1630 #ifndef HAVE_TTY
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1631 Lisp_Object
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1632 tty_semi_canonicalize_console_connection (Lisp_Object connection,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1633 Error_behavior errb)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1634 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1635 return Vstdio_str;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1636 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1637
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1638 Lisp_Object
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1639 tty_canonicalize_console_connection (Lisp_Object connection,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1640 Error_behavior errb)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1641 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1642 return Vstdio_str;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1643 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1644
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1645 Lisp_Object
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1646 tty_semi_canonicalize_device_connection (Lisp_Object connection,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1647 Error_behavior errb)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1648 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1649 return Vstdio_str;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1650 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1651
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1652 Lisp_Object
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1653 tty_canonicalize_device_connection (Lisp_Object connection,
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1654 Error_behavior errb)
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1655 {
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1656 return Vstdio_str;
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1657 }
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1658 #endif
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1659
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1660 /*--------------------------------------------------------------------*/
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1661 /* Signal support */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1662 /*--------------------------------------------------------------------*/
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1663
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1664 /* We need MS-defined signal and raise here */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1665 #undef signal
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1666 #undef raise
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1667
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1668 #define sigmask(nsig) (1U << nsig)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1669
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1670 /* We can support as many signals as fit into word */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1671 #define SIG_MAX 32
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1672
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1673 /* Signal handlers. Initial value = 0 = SIG_DFL */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1674 static void (__cdecl *signal_handlers[SIG_MAX])(int) = {0};
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1675
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1676 /* Signal block mask: bit set to 1 means blocked */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1677 unsigned signal_block_mask = 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1678
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1679 /* Signal pending mask: bit set to 1 means sig is pending */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1680 unsigned signal_pending_mask = 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1681
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1682 msw_sighandler msw_sigset (int nsig, msw_sighandler handler)
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1683 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1684 /* We delegate some signals to the system function */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1685 if (nsig == SIGFPE || nsig == SIGABRT || nsig == SIGINT)
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1686 return signal (nsig, handler);
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1687
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1688 if (nsig < 0 || nsig > SIG_MAX)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1689 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1690 errno = EINVAL;
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1691 return NULL;
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1692 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1693
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1694 /* Store handler ptr */
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1695 {
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1696 msw_sighandler old_handler = signal_handlers[nsig];
288
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1697 signal_handlers[nsig] = handler;
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1698 return old_handler;
e11d67e05968 Import from CVS: tag r21-0b42
cvs
parents: 282
diff changeset
1699 }
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1700 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1701
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1702 int msw_sighold (int nsig)
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1703 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1704 if (nsig < 0 || nsig > SIG_MAX)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1705 return errno = EINVAL;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1706
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1707 signal_block_mask |= sigmask(nsig);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1708 return 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1709 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1710
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1711 int msw_sigrelse (int nsig)
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1712 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1713 if (nsig < 0 || nsig > SIG_MAX)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1714 return errno = EINVAL;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1715
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1716 signal_block_mask &= ~sigmask(nsig);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1717
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1718 if (signal_pending_mask & sigmask(nsig))
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1719 msw_raise (nsig);
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1720
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1721 return 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1722 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1723
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1724 int msw_sigpause (int nsig)
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1725 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1726 /* This is currently not called, because the only
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1727 call to sigpause inside XEmacs is with SIGCHLD
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1728 parameter. Just in case, we put an assert here,
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1729 so anyone who will add a call to sigpause will
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1730 be surprised (or surprise someone else...) */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1731 assert (0);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1732 return 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1733 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1734
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1735 int msw_raise (int nsig)
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1736 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1737 /* We delegate some raises to the system routine */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1738 if (nsig == SIGFPE || nsig == SIGABRT || nsig == SIGINT)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1739 return raise (nsig);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1740
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1741 if (nsig < 0 || nsig > SIG_MAX)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1742 return errno = EINVAL;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1743
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1744 /* If the signal is blocked, remember to issue later */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1745 if (signal_block_mask & sigmask(nsig))
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1746 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1747 signal_pending_mask |= sigmask(nsig);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1748 return 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1749 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1750
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1751 if (signal_handlers[nsig] == SIG_IGN)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1752 return 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1753
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1754 if (signal_handlers[nsig] != SIG_DFL)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1755 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1756 (*signal_handlers[nsig])(nsig);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1757 return 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1758 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1759
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1760 /* Default signal actions */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1761 if (nsig == SIGALRM || nsig == SIGPROF)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1762 exit (3);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1763
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1764 /* Other signals are ignored by default */
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1765 return 0;
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1766 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1767
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1768 /*--------------------------------------------------------------------*/
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1769 /* Async timers */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1770 /*--------------------------------------------------------------------*/
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1771
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1772 /* We emulate two timers, one for SIGALRM, another for SIGPROF.
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1773
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1774 itimerproc() function has an implementation limitation: it does
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1775 not allow to set *both* interval and period. If an attempt is
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1776 made to set both, and then they are unequal, the function
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1777 asserts.
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1778
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1779 Minimum timer resolution on Win32 systems varies, and is greater
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1780 than or equal than 1 ms. The resolution is always wrapped not to
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1781 attempt to get below the system defined limit.
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1782 */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1783
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1784 /* Timer precision, denominator of one fraction: for 100 ms
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1785 interval, request 10 ms precision
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1786 */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1787 const int timer_prec = 10;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1788
380
8626e4521993 Import from CVS: tag r21-2-5
cvs
parents: 371
diff changeset
1789 /* Last itimervals, as set by calls to setitimer */
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1790 static struct itimerval it_alarm;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1791 static struct itimerval it_prof;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1792
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1793 /* Timer IDs as returned by MM */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1794 MMRESULT tid_alarm = 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1795 MMRESULT tid_prof = 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1796
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1797 static void CALLBACK timer_proc (UINT uID, UINT uMsg, DWORD dwUser,
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1798 DWORD dw1, DWORD dw2)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1799 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1800 /* Just raise a signal indicated by dwUser parameter */
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1801 msw_raise (dwUser);
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1802 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1803
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1804 /* Divide time in ms specified by IT by DENOM. Return 1 ms
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1805 if division results in zero */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1806 static UINT period (const struct itimerval* it, UINT denom)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1807 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1808 static TIMECAPS time_caps;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1809
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1810 UINT res;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1811 const struct timeval* tv =
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1812 (it->it_value.tv_sec == 0 && it->it_value.tv_usec == 0)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1813 ? &it->it_interval : &it->it_value;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1814
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1815 /* Zero means stop timer */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1816 if (tv->tv_sec == 0 && tv->tv_usec == 0)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1817 return 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1818
380
8626e4521993 Import from CVS: tag r21-2-5
cvs
parents: 371
diff changeset
1819 /* Convert to ms and divide by denom */
223
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1820 res = (tv->tv_sec * 1000 + (tv->tv_usec + 500) / 1000) / denom;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1821
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1822 /* Converge to minimum timer resolution */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1823 if (time_caps.wPeriodMin == 0)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1824 timeGetDevCaps (&time_caps, sizeof(time_caps));
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1825
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1826 if (res < time_caps.wPeriodMin)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1827 res = time_caps.wPeriodMin;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1828
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1829 return res;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1830 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1831
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1832 static int setitimer_helper (const struct itimerval* itnew,
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1833 struct itimerval* itold, struct itimerval* itcurrent,
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1834 MMRESULT* tid, DWORD sigkind)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1835 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1836 UINT delay, resolution, event_type;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1837
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1838 /* First stop the old timer */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1839 if (*tid)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1840 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1841 timeKillEvent (*tid);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1842 timeEndPeriod (period (itcurrent, timer_prec));
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1843 *tid = 0;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1844 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1845
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1846 /* Return old itimerval if requested */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1847 if (itold)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1848 *itold = *itcurrent;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1849
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1850 *itcurrent = *itnew;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1851
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1852 /* Determine if to start new timer */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1853 delay = period (itnew, 1);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1854 if (delay)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1855 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1856 resolution = period (itnew, timer_prec);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1857 event_type = (itnew->it_value.tv_sec == 0 && itnew->it_value.tv_usec == 0)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1858 ? TIME_ONESHOT : TIME_PERIODIC;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1859 timeBeginPeriod (resolution);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1860 *tid = timeSetEvent (delay, resolution, timer_proc, sigkind, event_type);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1861 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1862
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1863 return !delay || *tid;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1864 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1865
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1866 int setitimer (int kind, const struct itimerval* itnew,
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1867 struct itimerval* itold)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1868 {
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1869 /* In this version, both interval and value are allowed
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1870 only if they are equal. */
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1871 assert ((itnew->it_value.tv_sec == 0 && itnew->it_value.tv_usec == 0)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1872 || (itnew->it_interval.tv_sec == 0 && itnew->it_interval.tv_usec == 0)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1873 || (itnew->it_value.tv_sec == itnew->it_interval.tv_sec &&
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1874 itnew->it_value.tv_usec == itnew->it_interval.tv_usec));
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1875
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1876 if (kind == ITIMER_REAL)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1877 return setitimer_helper (itnew, itold, &it_alarm, &tid_alarm, SIGALRM);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1878 else if (kind == ITIMER_PROF)
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1879 return setitimer_helper (itnew, itold, &it_prof, &tid_prof, SIGPROF);
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1880 else
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1881 return errno = EINVAL;
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1882 }
2c611d1463a6 Import from CVS: tag r20-4b10
cvs
parents: 213
diff changeset
1883
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1884 int
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1885 open_input_file (file_data *p_file, CONST char *filename)
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1886 {
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1887 HANDLE file;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1888 HANDLE file_mapping;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1889 void *file_base;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1890 DWORD size, upper_size;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1891
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1892 file = CreateFile (filename, GENERIC_READ, FILE_SHARE_READ, NULL,
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1893 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1894 if (file == INVALID_HANDLE_VALUE)
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1895 return FALSE;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1896
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1897 size = GetFileSize (file, &upper_size);
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1898 file_mapping = CreateFileMapping (file, NULL, PAGE_READONLY,
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1899 0, size, NULL);
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1900 if (!file_mapping)
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1901 return FALSE;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1902
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1903 file_base = MapViewOfFile (file_mapping, FILE_MAP_READ, 0, 0, size);
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1904 if (file_base == 0)
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1905 return FALSE;
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1906
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1907 p_file->name = (char*)filename;
408
501cfd01ee6d Import from CVS: tag r21-2-34
cvs
parents: 404
diff changeset
1908 p_file->size = size;
501cfd01ee6d Import from CVS: tag r21-2-34
cvs
parents: 404
diff changeset
1909 p_file->file = file;
501cfd01ee6d Import from CVS: tag r21-2-34
cvs
parents: 404
diff changeset
1910 p_file->file_mapping = file_mapping;
412
697ef44129c6 Import from CVS: tag r21-2-14
cvs
parents: 410
diff changeset
1911 p_file->file_base = file_base;
408
501cfd01ee6d Import from CVS: tag r21-2-34
cvs
parents: 404
diff changeset
1912
501cfd01ee6d Import from CVS: tag r21-2-34
cvs
parents: 404
diff changeset
1913 return TRUE;
501cfd01ee6d Import from CVS: tag r21-2-34
cvs
parents: 404
diff changeset
1914 }
501cfd01ee6d Import from CVS: tag r21-2-34
cvs
parents: 404
diff changeset
1915
398
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1916 /* Close the system structures associated with the given file. */
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1917 void
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1918 close_file_data (file_data *p_file)
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1919 {
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1920 UnmapViewOfFile (p_file->file_base);
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1921 CloseHandle (p_file->file_mapping);
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1922 CloseHandle (p_file->file);
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1923 }
74fd4e045ea6 Import from CVS: tag r21-2-29
cvs
parents: 380
diff changeset
1924
100
4be1180a9e89 Import from CVS: tag r20-1b2
cvs
parents:
diff changeset
1925 /* end of nt.c */