changed PF_WARNING to not do a return
[divverent/darkplaces.git] / sys_linux.c
1
2 #ifdef WIN32
3 #include <io.h>
4 #include "conio.h"
5 #else
6 #include <unistd.h>
7 #include <fcntl.h>
8 #include <sys/time.h>
9 #endif
10
11 #include <signal.h>
12
13 #include "quakedef.h"
14
15
16 #ifdef WIN32
17 cvar_t sys_usetimegettime = {CVAR_SAVE, "sys_usetimegettime", "1", "use windows timeGetTime function (which has issues on some motherboards) for timing rather than QueryPerformanceCounter timer (which has issues on multicore/multiprocessor machines and processors which are designed to conserve power)"};
18 #endif
19
20
21
22 // =======================================================================
23 // General routines
24 // =======================================================================
25 void Sys_Shutdown (void)
26 {
27 #ifndef WIN32
28         fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
29 #endif
30         fflush(stdout);
31 }
32
33 void Sys_Error (const char *error, ...)
34 {
35         va_list argptr;
36         char string[MAX_INPUTLINE];
37
38 // change stdin to non blocking
39 #ifndef WIN32
40         fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
41 #endif
42
43         va_start (argptr,error);
44         dpvsnprintf (string, sizeof (string), error, argptr);
45         va_end (argptr);
46
47         Con_Printf ("Quake Error: %s\n", string);
48
49         Host_Shutdown ();
50         exit (1);
51 }
52
53 void Sys_PrintToTerminal(const char *text)
54 {
55 #ifndef WIN32
56         // BUG: for some reason, NDELAY also affects stdout (1) when used on stdin (0).
57         int origflags = fcntl (1, F_GETFL, 0);
58         fcntl (1, F_SETFL, origflags & ~FNDELAY);
59 #endif
60         while(*text)
61         {
62                 int written = (int)write(1, text, (int)strlen(text));
63                 if(written <= 0)
64                         break; // sorry, I cannot do anything about this error - without an output
65                 text += written;
66         }
67 #ifndef WIN32
68         fcntl (1, F_SETFL, origflags);
69 #endif
70         //fprintf(stdout, "%s", text);
71 }
72
73 double Sys_DoubleTime (void)
74 {
75         static int first = true;
76         static double oldtime = 0.0, curtime = 0.0;
77         double newtime;
78 #ifdef WIN32
79 #include <mmsystem.h>
80         // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
81         if (sys_usetimegettime.integer)
82         {
83                 static int firsttimegettime = true;
84                 // timeGetTime
85                 // platform:
86                 // Windows 95/98/ME/NT/2000/XP
87                 // features:
88                 // reasonable accuracy (millisecond)
89                 // issues:
90                 // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
91
92                 // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
93                 if (firsttimegettime)
94                 {
95                         timeBeginPeriod (1);
96                         firsttimegettime = false;
97                 }
98
99                 newtime = (double) timeGetTime () / 1000.0;
100         }
101         else
102         {
103                 // QueryPerformanceCounter
104                 // platform:
105                 // Windows 95/98/ME/NT/2000/XP
106                 // features:
107                 // very accurate (CPU cycles)
108                 // known issues:
109                 // does not necessarily match realtime too well (tends to get faster and faster in win98)
110                 // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
111                 double timescale;
112                 LARGE_INTEGER PerformanceFreq;
113                 LARGE_INTEGER PerformanceCount;
114
115                 if (!QueryPerformanceFrequency (&PerformanceFreq))
116                 {
117                         Con_Printf ("No hardware timer available\n");
118                         // fall back to timeGetTime
119                         Cvar_SetValueQuick(&sys_usetimegettime, true);
120                         return Sys_DoubleTime();
121                 }
122                 QueryPerformanceCounter (&PerformanceCount);
123
124                 #ifdef __BORLANDC__
125                 timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
126                 newtime = ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
127                 #else
128                 timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
129                 newtime = ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
130                 #endif
131         }
132 #else
133         struct timeval tp;
134         gettimeofday(&tp, NULL);
135         newtime = (double) tp.tv_sec + tp.tv_usec / 1000000.0;
136 #endif
137
138         if (first)
139         {
140                 first = false;
141                 oldtime = newtime;
142         }
143
144         if (newtime < oldtime)
145         {
146                 // warn if it's significant
147                 if (newtime - oldtime < -0.01)
148                         Con_Printf("Sys_DoubleTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
149         }
150         else
151                 curtime += newtime - oldtime;
152         oldtime = newtime;
153
154         return curtime;
155 }
156
157 char *Sys_ConsoleInput(void)
158 {
159         if (cls.state == ca_dedicated)
160         {
161                 static char text[MAX_INPUTLINE];
162                 static unsigned int len = 0;
163 #ifdef WIN32
164                 int c;
165
166                 // read a line out
167                 while (_kbhit ())
168                 {
169                         c = _getch ();
170                         if (c == '\r')
171                         {
172                                 text[len] = '\0';
173                                 putch ('\n');
174                                 len = 0;
175                                 return text;
176                         }
177                         if (c == '\b')
178                         {
179                                 if (len)
180                                 {
181                                         putch (c);
182                                         putch (' ');
183                                         putch (c);
184                                         len--;
185                                 }
186                                 continue;
187                         }
188                         if (len < sizeof (text) - 1)
189                         {
190                                 putch (c);
191                                 text[len] = c;
192                                 len++;
193                         }
194                 }
195 #else
196                 fd_set fdset;
197                 struct timeval timeout;
198                 FD_ZERO(&fdset);
199                 FD_SET(0, &fdset); // stdin
200                 timeout.tv_sec = 0;
201                 timeout.tv_usec = 0;
202                 if (select (1, &fdset, NULL, NULL, &timeout) != -1 && FD_ISSET(0, &fdset))
203                 {
204                         len = read (0, text, sizeof(text));
205                         if (len >= 1)
206                         {
207                                 // rip off the \n and terminate
208                                 text[len-1] = 0;
209                                 return text;
210                         }
211                 }
212 #endif
213         }
214         return NULL;
215 }
216
217 void Sys_Sleep(int milliseconds)
218 {
219         if (milliseconds < 1)
220                 milliseconds = 1;
221 #ifdef WIN32
222         Sleep(milliseconds);
223 #else
224         usleep(milliseconds * 1000);
225 #endif
226 }
227
228 char *Sys_GetClipboardData (void)
229 {
230         return NULL;
231 }
232
233 void Sys_InitConsole (void)
234 {
235 }
236
237 void Sys_Init_Commands (void)
238 {
239 }
240
241 int main (int argc, char **argv)
242 {
243         signal(SIGFPE, SIG_IGN);
244
245         com_argc = argc;
246         com_argv = (const char **)argv;
247
248 #ifndef WIN32
249         fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
250 #endif
251
252         Host_Main();
253
254         return 0;
255 }