]> git.saurik.com Git - wxWidgets.git/blob - src/msdos/utilsdos.cpp
Improve wxTextCtrl::GetNumberOfLines() unit test and documentation.
[wxWidgets.git] / src / msdos / utilsdos.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msdos/utilsdos.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 << wxT('=') << 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(wxT("/"), wxT("\\"));
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(wxT("/"), wxT("\\"));
200 #endif
201 // it needs to be a full path to be usable
202 if ( prog.compare(1, 2, wxT(":\\")) == 0 )
203 wxFileName::SplitPath(prog, &strDir, NULL, NULL);
204 }
205 if ( strDir.empty() )
206 {
207 strDir = wxT(".");
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(wxT("UserName"));
229
230 if (!user)
231 user = wxGetenv(wxT("USER"));
232
233 if (!user)
234 user = wxT("user");
235
236 wxStrlcpy(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(wxT("ComputerName"));
250
251 if (!host)
252 host = wxGetenv(wxT("HOSTNAME"));
253
254 if (!host)
255 host = wxT("host");
256
257 wxStrlcpy(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(wxT("UserDnsDomain"));
268
269 if (domain)
270 wxStrncat(wxStrncat(buf, wxT("."), 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(wxT("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 {
311 wxLogSysError(_("can't execute '%s'"), command.c_str());
312 }
313
314 return result == 0;
315 }
316
317 long wxExecute(const wxString& command, int flags, wxProcess *process,
318 const wxExecuteEnv *env)
319 {
320 // FIXME: shouldn't depend on wxCmdLineParser
321 wxArrayString args(wxCmdLineParser::ConvertStringToArgs(command));
322 size_t n = args.size();
323 wxChar **argv = new wxChar*[n + 1];
324
325 argv[n] = NULL;
326 while (n-- > 0)
327 argv[n] = const_cast<wxChar*>((const char *)args[n].c_str());
328
329 long result = wxExecute(argv, flags, process);
330
331 delete [] argv;
332 return result;
333 }
334
335 #if wxUSE_STREAMS
336
337 // A wxFFileInputStream that deletes the file in it's destructor
338 //
339 class wxTempFileInStream : public wxFFileInputStream
340 {
341 public:
342 wxTempFileInStream(const wxString& name)
343 : wxFFileInputStream(name, wxT("rt"))
344 { }
345
346 virtual ~wxTempFileInStream()
347 {
348 m_file->Close();
349 wxRemoveFile(m_file->GetName());
350 }
351 };
352
353 // A file descriptor that can be redirected to a file
354 //
355 class wxRedirectableFd
356 {
357 public:
358 wxRedirectableFd(int fd) : m_fd(fd), m_dup(-1) { }
359 ~wxRedirectableFd();
360
361 // Redirect the descriptor to a file, similar to ANSI C's freopen, but
362 // for low level descriptors. The desctructor un-redirects. If O_CREAT
363 // is in the flags then the destructor will delete the file unless it is
364 // given away with Release().
365 bool Reopen(const wxString& name, int flags);
366
367 // un-redirect the redirected file descriptor, closing the file, and give
368 // away the filename without deleting it
369 wxString Release();
370
371 private:
372 // un-redirect the descriptor, closing the file
373 void Restore();
374
375 int m_fd;
376 int m_dup;
377 wxString m_name;
378 };
379
380 wxRedirectableFd::~wxRedirectableFd()
381 {
382 Restore();
383 if (!m_name.empty())
384 wxRemoveFile(m_name);
385 }
386
387 bool wxRedirectableFd::Reopen(const wxString& name, int flags)
388 {
389 wxASSERT(m_dup == -1);
390 bool result = false;
391
392 // save a duplicate so that the descriptor can be closed now and
393 // restored later
394 m_dup = dup(m_fd);
395
396 if (m_dup != -1)
397 {
398 int tmp = open(name.mb_str(), flags);
399
400 if (tmp != -1)
401 {
402 close(m_fd);
403
404 if (flags & O_CREAT)
405 m_name = name;
406
407 result = dup2(tmp, m_fd) == m_fd;
408 close(tmp);
409 }
410 }
411
412 if (!result)
413 {
414 wxLogSysError(_("error opening '%s'"), name.c_str());
415 }
416
417 return result;
418 }
419
420 void wxRedirectableFd::Restore()
421 {
422 if (m_dup != -1)
423 {
424 close(m_fd);
425 dup2(m_dup, m_fd);
426 close(m_dup);
427 m_dup = -1;
428 }
429 }
430
431 wxString wxRedirectableFd::Release()
432 {
433 Restore();
434 wxString name = m_name;
435 m_name.clear();
436 return name;
437 }
438
439 #endif // wxUSE_STREAMS
440
441 // wxExecute implementation
442 //
443 long wxExecute(wxChar **argv, int flags, wxProcess *process,
444 const wxString* cwd, const wxEnvVariableHashMap* env)
445 {
446 #if wxUSE_STREAMS
447 const int STDIN = 0;
448 const int STDOUT = 1;
449 const int STDERR = 2;
450
451 wxRedirectableFd in(STDIN), out(STDOUT), err(STDERR);
452 bool redirect = process && process->IsRedirected() && (flags & wxEXEC_SYNC);
453
454 if (redirect)
455 {
456 // close stdin/out/err and reopen them as files
457 if (!in.Reopen(wxT("NUL"), O_RDONLY | O_TEXT))
458 return -1;
459
460 if (!out.Reopen(wxFileName::CreateTempFileName(wxT("out")),
461 O_CREAT | O_WRONLY | O_TRUNC | O_TEXT))
462 return -1;
463
464 if (!err.Reopen(wxFileName::CreateTempFileName(wxT("err")),
465 O_CREAT | O_WRONLY | O_TRUNC | O_TEXT))
466 return -1;
467 }
468 #endif // wxUSE_STREAMS
469
470 // FIXME: suspend/resume gui
471 int mode = flags & wxEXEC_SYNC ? P_WAIT : P_NOWAIT;
472 int result = spawnvp(mode, argv[0], argv);
473
474 if (result == -1)
475 {
476 wxLogSysError(_("can't execute '%s'"), argv[0]);
477 }
478
479 #if wxUSE_STREAMS
480 if (redirect)
481 process->SetPipeStreams(new wxTempFileInStream(out.Release()),
482 new wxFFileOutputStream(wxT("NUL"), wxT("wt")),
483 new wxTempFileInStream(err.Release()));
484 #endif // wxUSE_STREAMS
485
486 return result;
487 }
488
489
490 //----------------------------------------------------------------------------
491 // OS-related
492 //----------------------------------------------------------------------------
493
494 wxString wxGetOsDescription()
495 {
496 wxString osname(wxT("DOS"));
497 return osname;
498 }
499
500 wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
501 {
502 if ( verMaj )
503 *verMaj = _osmajor;
504 if ( verMin )
505 *verMin = _osminor;
506
507 return wxOS_DOS;
508 }
509
510 bool wxIsPlatform64Bit()
511 {
512 return false;
513 }
514