]> git.saurik.com Git - wxWidgets.git/blob - src/msdos/utilsdos.cpp
fix should have been mac only
[wxWidgets.git] / src / msdos / utilsdos.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msdos/utils.cpp
3 // Purpose: DOS implementations of utility functions
4 // Author: Vaclav Slavik, M.J.Wetherell
5 // Id: $Id$
6 // Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
7 // (c) 2005 M.J.Wetherell
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // For compilers that support precompilation, includes "wx.h".
12 #include "wx/wxprec.h"
13
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #include "wx/utils.h"
19
20 #ifndef WX_PRECOMP
21 #include "wx/string.h"
22 #include "wx/intl.h"
23 #include "wx/log.h"
24 #include "wx/app.h"
25 #endif
26
27 #include "wx/apptrait.h"
28 #include "wx/process.h"
29 #include "wx/confbase.h" // for wxExpandEnvVars()
30 #include "wx/cmdline.h"
31 #include "wx/filename.h"
32 #include "wx/wfstream.h"
33
34 #include <stdarg.h>
35 #include <string.h>
36 #include <sys/stat.h>
37 #include <sys/types.h>
38 #include <unistd.h>
39 #include <signal.h>
40 #include <time.h>
41 #include <dos.h>
42 #include <process.h>
43
44 //----------------------------------------------------------------------------
45 // Sleep
46 //----------------------------------------------------------------------------
47
48 void wxSleep(int nSecs)
49 {
50 wxMilliSleep(1000 * nSecs);
51 }
52
53 void wxMilliSleep(unsigned long milliseconds)
54 {
55 #if HAVE_USLEEP || defined __DJGPP__
56 usleep(milliseconds * 1000);
57 #elif defined __WATCOMC__
58 delay(milliseconds);
59 #else
60 clock_t start = clock();
61 while ((clock() - start) * 1000 / CLOCKS_PER_SEC < (clock_t)milliseconds)
62 {
63 // yield if in a multitasking environment
64 // "Release Current Virtual Machine's Time Slice" in DPMI 1.0
65 REGS r;
66 memset(&r, 0, sizeof(r));
67 r.x.ax = 0x1680;
68 int386(0x2f, &r, &r);
69 }
70 #endif
71 }
72
73 void wxMicroSleep(unsigned long microseconds)
74 {
75 #if HAVE_USLEEP || defined __DJGPP__
76 usleep(microseconds);
77 #else
78 wxMilliSleep(microseconds/1000);
79 #endif
80 }
81
82 //----------------------------------------------------------------------------
83 // Get/Set environment variables
84 //----------------------------------------------------------------------------
85
86 bool wxGetEnv(const wxString& var, wxString *value)
87 {
88 // wxGetenv is defined as getenv()
89 wxChar *p = wxGetenv(var);
90 if ( !p )
91 return false;
92
93 if ( value )
94 *value = p;
95
96 return true;
97 }
98
99 static bool wxDoSetEnv(const wxString& variable, const char *value)
100 {
101 wxString s = variable;
102 if ( value )
103 s << _T('=') << value;
104
105 // transform to ANSI
106 const char *p = s.mb_str();
107
108 // the string will be free()d by libc
109 char *buf = (char *)malloc(strlen(p) + 1);
110 strcpy(buf, p);
111
112 return putenv(buf) == 0;
113 }
114
115 bool wxSetEnv(const wxString& variable, const wxString& value)
116 {
117 return wxDoSetEnv(variable, value.mb_str());
118 }
119
120 bool wxUnsetEnv(const wxString& variable)
121 {
122 return wxDoSetEnv(variable, NULL);
123 }
124
125
126 //----------------------------------------------------------------------------
127 // Hostname, username, home directory
128 //----------------------------------------------------------------------------
129
130 // Based on the MSW implementation
131 //
132 // Respects the following environment variables in this order: %HomeDrive% +
133 // %HomePath%, %UserProfile%, $HOME. Otherwise takes program's directory if
134 // wxApp has been initialised, otherwise returns ".".
135 //
136 const wxChar* wxGetHomeDir(wxString *home)
137 {
138 wxString& strDir = *home;
139
140 strDir.clear();
141
142 // try HOMEDRIVE/PATH
143 const wxChar *szHome = wxGetenv(wxT("HOMEDRIVE"));
144 if ( szHome != NULL )
145 strDir << szHome;
146 szHome = wxGetenv(wxT("HOMEPATH"));
147
148 if ( szHome != NULL )
149 {
150 strDir << szHome;
151
152 // the idea is that under NT these variables have default values of
153 // "%systemdrive%:" and "\\". As we don't want to create our config
154 // files in the root directory of the system drive, we will create it
155 // in our program's dir. However, if the user took care to set
156 // HOMEPATH to something other than "\\", we suppose that he knows
157 // what he is doing and use the supplied value.
158 if ( wxStrcmp(szHome, wxT("\\")) == 0 )
159 strDir.clear();
160 }
161
162 if ( strDir.empty() )
163 {
164 // If we have a valid USERPROFILE directory, as is the case in
165 // Windows NT, 2000 and XP, we should use that as our home directory.
166 szHome = wxGetenv(wxT("USERPROFILE"));
167
168 if ( szHome != NULL )
169 strDir = szHome;
170 }
171
172 if ( strDir.empty() )
173 {
174 // If we have a valid HOME directory, as is used on many machines
175 // that have unix utilities on them, we should use that.
176 szHome = wxGetenv(wxT("HOME"));
177
178 if ( szHome != NULL )
179 {
180 strDir = szHome;
181 // when msys sets %HOME% it uses '/' (cygwin uses '\\')
182 strDir.Replace(_T("/"), _T("\\"));
183 }
184 }
185
186 if ( !strDir.empty() )
187 {
188 // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
189 // value once again, it shouldn't hurt anyhow
190 strDir = wxExpandEnvVars(strDir);
191 }
192 else // fall back to the program directory
193 {
194 if ( wxTheApp )
195 {
196 wxString prog(wxTheApp->argv[0]);
197 #ifdef __DJGPP__
198 // djgpp startup code switches the slashes around, so restore them
199 prog.Replace(_T("/"), _T("\\"));
200 #endif
201 // it needs to be a full path to be usable
202 if ( prog.compare(1, 2, _T(":\\")) == 0 )
203 wxSplitPath(prog, &strDir, NULL, NULL);
204 }
205 if ( strDir.empty() )
206 {
207 strDir = _T(".");
208 }
209 }
210
211 return strDir.c_str();
212 }
213
214 wxString wxGetUserHome(const wxString& user)
215 {
216 wxString home;
217
218 if (user.empty() || user == wxGetUserId())
219 wxGetHomeDir(&home);
220
221 return home;
222 }
223
224 // returns %UserName%, $USER or just "user"
225 //
226 bool wxGetUserId(wxChar *buf, int n)
227 {
228 const wxChar *user = wxGetenv(_T("UserName"));
229
230 if (!user)
231 user = wxGetenv(_T("USER"));
232
233 if (!user)
234 user = _T("user");
235
236 wxStrncpy(buf, user, n);
237 return true;
238 }
239
240 bool wxGetUserName(wxChar *buf, int n)
241 {
242 return wxGetUserId(buf, n);
243 }
244
245 // returns %ComputerName%, or $HOSTNAME, or "host"
246 //
247 bool wxGetHostName(wxChar *buf, int n)
248 {
249 const wxChar *host = wxGetenv(_T("ComputerName"));
250
251 if (!host)
252 host = wxGetenv(_T("HOSTNAME"));
253
254 if (!host)
255 host = _T("host");
256
257 wxStrncpy(buf, host, n);
258 return true;
259 }
260
261 // adds %UserDnsDomain% to wxGetHostName()
262 //
263 bool wxGetFullHostName(wxChar *buf, int n)
264 {
265 wxGetHostName(buf, n);
266
267 const wxChar *domain = wxGetenv(_T("UserDnsDomain"));
268
269 if (domain)
270 wxStrncat(wxStrncat(buf, _T("."), n), domain, n);
271
272 return true;
273 }
274
275 //----------------------------------------------------------------------------
276 // Processes
277 //----------------------------------------------------------------------------
278
279 unsigned long wxGetProcessId()
280 {
281 return (unsigned long)getpid();
282 }
283
284 int wxKill(long pid, wxSignal sig, wxKillError *rc, int WXUNUSED(flags))
285 {
286 int result = -1;
287
288 if (pid != (long)wxGetProcessId())
289 {
290 result = raise(sig);
291 if (rc)
292 *rc = result == 0 ? wxKILL_OK : wxKILL_BAD_SIGNAL;
293 }
294 else
295 {
296 wxLogDebug(_T("wxKill can only send signals to the current process under MSDOS"));
297 if (rc)
298 *rc = wxKILL_NO_PROCESS;
299 }
300
301 return result;
302 }
303
304 bool wxShell(const wxString& command /*=wxEmptyString*/)
305 {
306 // FIXME: suspend/resume gui
307 int result = system(command);
308
309 if (result == -1)
310 wxLogSysError(_("can't execute '%s'"), command.c_str());
311
312 return result == 0;
313 }
314
315 long wxExecute(const wxString& command, int flags, wxProcess *process)
316 {
317 // FIXME: shouldn't depend on wxCmdLineParser
318 wxArrayString args(wxCmdLineParser::ConvertStringToArgs(command));
319 size_t n = args.size();
320 wxChar **argv = new wxChar*[n + 1];
321
322 argv[n] = NULL;
323 while (n-- > 0)
324 argv[n] = wx_const_cast(wxChar*, (const char *)args[n].c_str());
325
326 long result = wxExecute(argv, flags, process);
327
328 delete [] argv;
329 return result;
330 }
331
332 #if wxUSE_STREAMS
333
334 // A wxFFileInputStream that deletes the file in it's destructor
335 //
336 class wxTempFileInStream : public wxFFileInputStream
337 {
338 public:
339 wxTempFileInStream(const wxString& name)
340 : wxFFileInputStream(name, _T("rt"))
341 { }
342
343 virtual ~wxTempFileInStream()
344 {
345 m_file->Close();
346 wxRemoveFile(m_file->GetName());
347 }
348 };
349
350 // A file descriptor that can be redirected to a file
351 //
352 class wxRedirectableFd
353 {
354 public:
355 wxRedirectableFd(int fd) : m_fd(fd), m_dup(-1) { }
356 ~wxRedirectableFd();
357
358 // Redirect the descriptor to a file, similar to ANSI C's freopen, but
359 // for low level descriptors. The desctructor un-redirects. If O_CREAT
360 // is in the flags then the destructor will delete the file unless it is
361 // given away with Release().
362 bool Reopen(const wxString& name, int flags);
363
364 // un-redirect the redirected file descriptor, closing the file, and give
365 // away the filename without deleting it
366 wxString Release();
367
368 private:
369 // un-redirect the descriptor, closing the file
370 void Restore();
371
372 int m_fd;
373 int m_dup;
374 wxString m_name;
375 };
376
377 wxRedirectableFd::~wxRedirectableFd()
378 {
379 Restore();
380 if (!m_name.empty())
381 wxRemoveFile(m_name);
382 }
383
384 bool wxRedirectableFd::Reopen(const wxString& name, int flags)
385 {
386 wxASSERT(m_dup == -1);
387 bool result = false;
388
389 // save a duplicate so that the descriptor can be closed now and
390 // restored later
391 m_dup = dup(m_fd);
392
393 if (m_dup != -1)
394 {
395 int tmp = open(name.mb_str(), flags);
396
397 if (tmp != -1)
398 {
399 close(m_fd);
400
401 if (flags & O_CREAT)
402 m_name = name;
403
404 result = dup2(tmp, m_fd) == m_fd;
405 close(tmp);
406 }
407 }
408
409 if (!result)
410 wxLogSysError(_("error opening '%s'"), name.c_str());
411
412 return result;
413 }
414
415 void wxRedirectableFd::Restore()
416 {
417 if (m_dup != -1)
418 {
419 close(m_fd);
420 dup2(m_dup, m_fd);
421 close(m_dup);
422 m_dup = -1;
423 }
424 }
425
426 wxString wxRedirectableFd::Release()
427 {
428 Restore();
429 wxString name = m_name;
430 m_name.clear();
431 return name;
432 }
433
434 #endif // wxUSE_STREAMS
435
436 // wxExecute implementation
437 //
438 long wxExecute(wxChar **argv, int flags, wxProcess *process)
439 {
440 #if wxUSE_STREAMS
441 const int STDIN = 0;
442 const int STDOUT = 1;
443 const int STDERR = 2;
444
445 wxRedirectableFd in(STDIN), out(STDOUT), err(STDERR);
446 bool redirect = process && process->IsRedirected() && (flags & wxEXEC_SYNC);
447
448 if (redirect)
449 {
450 // close stdin/out/err and reopen them as files
451 if (!in.Reopen(_T("NUL"), O_RDONLY | O_TEXT))
452 return -1;
453
454 if (!out.Reopen(wxFileName::CreateTempFileName(_T("out")),
455 O_CREAT | O_WRONLY | O_TRUNC | O_TEXT))
456 return -1;
457
458 if (!err.Reopen(wxFileName::CreateTempFileName(_T("err")),
459 O_CREAT | O_WRONLY | O_TRUNC | O_TEXT))
460 return -1;
461 }
462 #endif // wxUSE_STREAMS
463
464 // FIXME: suspend/resume gui
465 int mode = flags & wxEXEC_SYNC ? P_WAIT : P_NOWAIT;
466 int result = spawnvp(mode, argv[0], argv);
467
468 if (result == -1)
469 wxLogSysError(_("can't execute '%s'"), argv[0]);
470
471 #if wxUSE_STREAMS
472 if (redirect)
473 process->SetPipeStreams(new wxTempFileInStream(out.Release()),
474 new wxFFileOutputStream(_T("NUL"), _T("wt")),
475 new wxTempFileInStream(err.Release()));
476 #endif // wxUSE_STREAMS
477
478 return result;
479 }
480
481
482 //----------------------------------------------------------------------------
483 // OS-related
484 //----------------------------------------------------------------------------
485
486 wxString wxGetOsDescription()
487 {
488 wxString osname(_T("DOS"));
489 return osname;
490 }
491
492 wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
493 {
494 if ( verMaj )
495 *verMaj = _osmajor;
496 if ( verMin )
497 *verMin = _osminor;
498
499 return wxOS_DOS;
500 }
501
502 bool wxIsPlatform64Bit()
503 {
504 return false;
505 }
506