![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_irix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to sys_irix.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: #include <unistd.h>
2: #include <signal.h>
3: #include <stdlib.h>
4: #include <limits.h>
5: #include <sys/time.h>
6: #include <sys/types.h>
7: #include <unistd.h>
8: #include <fcntl.h>
9: #include <stdarg.h>
10: #include <stdio.h>
11: #include <sys/ipc.h>
12: #include <sys/shm.h>
13: #include <sys/stat.h>
14: #include <string.h>
15: #include <ctype.h>
16: #include <sys/wait.h>
17: #include <sys/mman.h>
18: #include <errno.h>
19:
20: #include "quakedef.h"
21:
22: #define TICRATE (1.0/30)
23:
24: FILE *debugfile=0;
25:
26: // =======================================================================
27: // General routines
28: // =======================================================================
29:
30: void I_DebugNumber(int y, int val)
31: {
32: }
33:
34: /*
35: void I_Printf (char *fmt, ...)
36: {
37: va_list argptr;
38: char text[1024];
39:
40: va_start (argptr,fmt);
41: vsprintf (text,fmt,argptr);
42: va_end (argptr);
43: fprintf(stderr, "%s", text);
44:
45: Con_Print (text);
46: }
47: */
48:
49: void I_Printf (char *fmt, ...)
50: {
51: va_list argptr;
52: char text[1024], *t_p;
53: int l, r;
54:
55: va_start (argptr,fmt);
56: vsprintf (text,fmt,argptr);
57: va_end (argptr);
58:
59: l = strlen(text);
60: t_p = text;
61:
62: // make sure everything goes through, even though we are non-blocking
63: while (l)
64: {
65: r = write (1, text, l);
66: if (r == -1)
67: {
68: sleep (0);
69: continue;
70: }
71: t_p += r;
72: l -= r;
73: }
74: }
75:
76: void I_Quit (void)
77: {
78: fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
79: S_Shutdown();
80: exit(0);
81: }
82:
83: void I_Error (char *error, ...)
84: {
85: va_list argptr;
86: char string[1024];
87:
88: fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
89: va_start (argptr,error);
90: vsprintf (string,error,argptr);
91: va_end (argptr);
92: fprintf(stderr, "Error: %s\n", string);
93: S_Shutdown();
94: VID_Shutdown();
95: exit(-1);
96: }
97:
98: void I_Warn (char *warning, ...)
99: {
100: va_list argptr;
101: char string[1024];
102:
103: va_start (argptr,warning);
104: vsprintf (string,warning,argptr);
105: va_end (argptr);
106: fprintf(stderr, "Warning: %s", string);
107: }
108:
109: /*
110: ============
111: Sys_FileTime
112:
113: returns -1 if not present
114: ============
115: */
116: int Sys_FileTime (char *path)
117: {
118: struct stat buf;
119:
120: if (stat (path,&buf) == -1)
121: return -1;
122:
123: return buf.st_mtime;
124: }
125:
126:
127: void Sys_mkdir (char *path)
128: {
129: mkdir (path, 0777);
130: }
131:
132: int Sys_FileOpenRead (char *path, int *handle)
133: {
134: int h;
135: struct stat fileinfo;
136:
137:
138: h = open (path, O_RDONLY, 0666);
139: *handle = h;
140: if (h == -1)
141: return -1;
142:
143: if (fstat (h,&fileinfo) == -1)
144: I_Error ("Error fstating %s", path);
145:
146: return fileinfo.st_size;
147: }
148:
149: int Sys_FileOpenWrite (char *path)
150: {
151: int handle;
152:
153: umask (0);
154:
155: handle = open(path,O_RDWR | O_CREAT | O_TRUNC
156: , 0666);
157:
158: if (handle == -1)
159: I_Error ("Error opening %s: %s", path,strerror(errno));
160:
161: return handle;
162: }
163:
164: int Sys_FileWrite (int handle, void *src, int count)
165: {
166: return write (handle, src, count);
167: }
168:
169: void Sys_FileClose (int handle)
170: {
171: close (handle);
172: }
173:
174: void Sys_FileSeek (int handle, int position)
175: {
176: lseek (handle, position, SEEK_SET);
177: }
178:
179: int Sys_FileRead (int handle, void *dest, int count)
180: {
181: return read (handle, dest, count);
182: }
183:
184: void I_DebugLog(char *file, char *fmt, ...)
185: {
186: va_list argptr;
187: static char data[1024];
188: int fd;
189:
190: va_start(argptr, fmt);
191: vsprintf(data, fmt, argptr);
192: va_end(argptr);
193: // fd = open(file, O_WRONLY | O_BINARY | O_CREAT | O_APPEND, 0666);
194: fd = open(file, O_WRONLY | O_CREAT | O_APPEND, 0666);
195: write(fd, data, strlen(data));
196: close(fd);
197: }
198:
199: /*=============
200: StartMSRInterval
201: =============
202: */
203: void StartMSRInterval(int msreg)
204: {
205: }
206:
207: /*
208: =============
209: EndMSRInterval
210: =============
211: */
212: unsigned long EndMSRInterval()
213: {
214: return 0;
215: }
216:
217: cvar_t sys_showfiles = {"showfiles","1"};
218:
219:
220: void Sys_EditFile(char *filename)
221: {
222:
223: char cmd[256];
224: char *term;
225: char *editor;
226:
227: term = getenv("TERM");
228: if (term && !strcmp(term, "xterm"))
229: {
230: editor = getenv("VISUAL");
231: if (!editor)
232: editor = getenv("EDITOR");
233: if (!editor)
234: editor = getenv("EDIT");
235: if (!editor)
236: editor = "vi";
237: sprintf(cmd, "xterm -e %s %s", editor, filename);
238: system(cmd);
239: }
240:
241: }
242:
243: double I_FloatTime (void)
244: {
245: struct timeval tp;
246: struct timezone tzp;
247: static int secbase;
248:
249: gettimeofday(&tp, &tzp);
250:
251: if (!secbase)
252: {
253: secbase = tp.tv_sec;
254: return tp.tv_usec/1000000.0;
255: }
256:
257: return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
258: }
259:
260: // =======================================================================
261: // Sleeps for microseconds
262: // =======================================================================
263:
264: static volatile int oktogo;
265:
266: void alarm_handler(int x)
267: {
268: oktogo=1;
269: }
270:
271: void I_Sleep(int usecs)
272: {
273:
274: struct itimerval it;
275:
276: it.it_interval.tv_sec = 0;
277: it.it_interval.tv_usec = 0;
278: it.it_value.tv_sec = usecs / 1000000;
279: it.it_value.tv_usec = usecs % 1000000;
280:
281: signal(SIGALRM, alarm_handler);
282:
283: oktogo=0;
284: setitimer(ITIMER_REAL, &it, 0);
285: while (!oktogo) sleep(0);
286:
287: }
288:
289: byte *I_ZoneBase (int *size)
290: {
291:
292: char *QUAKEOPT = getenv("QUAKEOPT");
293:
294: *size = 0xc00000;
295: if (QUAKEOPT)
296: {
297: while (*QUAKEOPT)
298: if (tolower(*QUAKEOPT++) == 'm')
299: {
300: *size = atof(QUAKEOPT) * 1024*1024;
301: break;
302: }
303: }
304: return malloc (*size);
305:
306: }
307:
308: void SV_LineRefresh(void)
309: {
310: }
311:
312: void Sys_Sleep(void)
313: {
314: sleep(0);
315: }
316:
317: void I_GetMemory(quakeparms_t *parms)
318: {
319: FILE *f;
320: char buffer[256];
321: char *procparse;
322: int freemem, buffermem, totalmem;
323: int rc, suggestion;
324:
325: parms->memsize = 8*1024*1024;
326:
327: f = fopen("/proc/meminfo", "r");
328: if (f)
329: {
330: fgets(buffer, sizeof buffer, f);
331: procparse = "%s %d %d %d %d %d";
332: rc = fscanf(f, procparse, buffer, &totalmem, buffer, &freemem,
333: buffer, &buffermem);
334:
335: suggestion = (9*buffermem)/10 + freemem;
336: if (suggestion > totalmem)
337: I_Printf("[%s] did not properly parse /proc/meminfo\n", procparse);
338: if (suggestion > parms->memsize && suggestion < totalmem)
339: parms->memsize = suggestion;
340:
341: fclose(f);
342: }
343: else
344: I_Printf("Did you know /proc breaks up painful gas bubbles?\n");
345:
346: parms->membase = malloc (parms->memsize);
347:
348: }
349:
350:
351: void floating_point_exception_handler(int whatever)
352: {
353: // I_Warn("floating point exception\n");
354: signal(SIGFPE, floating_point_exception_handler);
355: }
356:
357: int main (int c, char **v)
358: {
359:
360: extern qboolean pr_debugerrors;
361: double time, oldtime, newtime;
362: quakeparms_t parms;
363:
364: pr_debugerrors = false;
365:
366: signal(SIGFPE, floating_point_exception_handler);
367:
368: fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
369:
370: parms.memsize = 0x2000000;
371: parms.membase = malloc (parms.memsize);
372: parms.basedir = "/flem/quake";
373:
374: COM_InitArgv (c, v);
375:
376: parms.argc = com_argc;
377: parms.argv = com_argv;
378:
379: Quake_Init(&parms);
380:
381: if (COM_CheckParm ("-debugfile"))
382: {
383: char hostname[80];
384: char filename[80];
385:
386: gethostname(hostname, sizeof(hostname));
387: sprintf (filename, "%s.dbg",hostname);
388: debugfile = fopen (filename,"w");
389:
390: net_debug = true;
391: }
392:
393: oldtime = I_FloatTime ();
394: while (1)
395: {
396: // find time spent rendering last frame
397: newtime = I_FloatTime ();
398: time = newtime - oldtime;
399:
400: // if ( !cl_connected && time < TICRATE)
401: if ( host_dedicated && time < TICRATE)
402: {
403: I_Sleep (1);
404: continue; // not time to run a server only tic yet
405: }
406:
407: Host_Frame(time);
408: // CL_Frame(time);
409:
410: oldtime = newtime;
411: }
412:
413: Quake_Shutdown();
414:
415: }
416:
417:
418: /*
419: ================
420: I_MakeCodeWriteable
421: ================
422: */
423: void I_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
424: {
425:
426: int r;
427: unsigned int addr;
428: int psize = getpagesize();
429:
430: addr = startaddr & ~(psize-1);
431:
432: r = mprotect((char*)addr, length + startaddr - addr, 7);
433:
434: if (r < 0)
435: I_Error("Protection change failed\n");
436:
437: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.