![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hostcall.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Tom Morton FrontierVM] / frontvm / hardware|
Return to hostcall.c CVS log | Up to [Tom Morton FrontierVM] / frontvm / hardware |
1.1 root 1: /*
2: Hatari - gemdos.c
3:
4: This file is distributed under the GNU Public License, version 2 or at
5: your option any later version. Read the file gpl.txt for details.
6:
7: GEMDOS intercept routines.
8: These are used mainly for hard drive redirection of high level file routines.
9:
10: Now case is handled by using glob. See the function
11: GemDOS_CreateHardDriveFileName for that. It also knows about symlinks.
12: A filename is recognized on its eight first characters, do don't try to
13: push this too far, or you'll get weirdness ! (But I can even run programs
14: directly from a mounted cd in lower cases, so I guess it's working well !).
15: */
16:
17: #include <sys/stat.h>
18: #include <time.h>
19: #include <dirent.h>
20: #include <ctype.h>
21: #include <unistd.h>
22: #include <glob.h>
23: #include <SDL/SDL.h>
24: #include <SDL/SDL_endian.h>
25:
26: #include "main.h"
27: #include "decode.h"
28: #include "configuration.h"
29: #include "file.h"
30: #include "hostcall.h"
31: #include "m68000.h"
32: #include "memAlloc.h"
33: #include "misc.h"
34: #include "stMemory.h"
35: #include "screen.h"
36: #include "video.h"
37: #include "audio.h"
38: #include "input.h"
39: #include "fe2.h"
40:
41: #include "../cpu/hatari-glue.h"
42:
43: //#define GEMDOS_VERBOSE
44: // uncomment the following line to debug filename lookups on hd
45: // #define FILE_DEBUG 1
46:
47: #define ENABLE_SAVING /* Turn on saving stuff */
48:
49: #define INVALID_HANDLE_VALUE -1
50:
51: #ifndef MAX_PATH
52: #define MAX_PATH 256
53: #endif
54:
55: /* GLOB_ONLYDIR is a GNU extension for the glob() function and not defined
56: * on some systems. We should probably use something different for this
57: * case, but at the moment it we simply define it as 0... */
58: #ifndef GLOB_ONLYDIR
59: #warning GLOB_ONLYDIR was not defined.
60: #define GLOB_ONLYDIR 0
61: #endif
62:
63:
64: /* structure with all the drive-specific data for our emulated drives */
65: EMULATEDDRIVE emudrive;
66:
67: typedef struct
68: {
69: BOOL bUsed;
70: FILE *FileHandle;
71: char szActualName[MAX_PATH]; /* used by F_DATIME (0x57) */
72: } FILE_HANDLE;
73:
74: typedef struct
75: {
76: BOOL bUsed;
77: int nentries; /* number of entries in fs directory */
78: int centry; /* current entry # */
79: struct dirent **found; /* legal files */
80: char path[MAX_PATH]; /* sfirst path */
81: } INTERNAL_DTA;
82:
83: FILE_HANDLE FileHandles[MAX_FILE_HANDLES];
84: INTERNAL_DTA InternalDTAs[MAX_DTAS_FILES];
85: int DTAIndex; /* Circular index into above */
86: DTA *pDTA; /* Our GEMDOS hard drive Disc Transfer Address structure */
87: unsigned char GemDOS_ConvertAttribute(mode_t mode);
88:
89:
90: /*-------------------------------------------------------*/
91: /*
92: Routines to convert time and date to MSDOS format.
93: Originally from the STonX emulator. (cheers!)
94: */
95: unsigned short time2dos (time_t t)
96: {
97: struct tm *x;
98: x = localtime (&t);
99: return (x->tm_sec>>1)|(x->tm_min<<5)|(x->tm_hour<<11);
100: }
101:
102: unsigned short date2dos (time_t t)
103: {
104: struct tm *x;
105: x = localtime (&t);
106: return x->tm_mday | ((x->tm_mon+1)<<5) | ( ((x->tm_year-80>0)?x->tm_year-80:0) << 9);
107: }
108:
109:
110: /*-----------------------------------------------------------------------*/
111: /*
112: Populate a DATETIME structure with file info
113: */
114: BOOL GetFileInformation(char *name, DATETIME *DateTime)
115: {
116: struct stat filestat;
117: int n;
118: struct tm *x;
119:
120: n = stat(name, &filestat);
121: if( n != 0 ) return(FALSE);
122: x = localtime( &filestat.st_mtime );
123:
124: DateTime->word1 = 0;
125: DateTime->word2 = 0;
126:
127: DateTime->word1 |= (x->tm_mday & 0x1F); /* 5 bits */
128: DateTime->word1 |= (x->tm_mon & 0x0F)<<5; /* 4 bits */
129: DateTime->word1 |= (((x->tm_year-80>0)?x->tm_year-80:0) & 0x7F)<<9; /* 7 bits*/
130:
131: DateTime->word2 |= (x->tm_sec & 0x1F); /* 5 bits */
132: DateTime->word2 |= (x->tm_min & 0x3F)<<5; /* 6 bits */
133: DateTime->word2 |= (x->tm_hour & 0x1F)<<11; /* 5 bits */
134:
135: return(TRUE);
136: }
137:
138:
139: /*-----------------------------------------------------------------------*/
140: /*
141: Populate the DTA buffer with file info
142: */
143: int PopulateDTA(char *path, struct dirent *file)
144: {
145: char tempstr[MAX_PATH];
146: struct stat filestat;
147: int n;
148:
149: sprintf(tempstr, "%s/%s", path, file->d_name);
150: n = stat(tempstr, &filestat);
151: if(n != 0) return(FALSE); /* return on error */
152:
153: if(!pDTA) return(FALSE); /* no DTA pointer set */
154: Misc_strupr(file->d_name); /* convert to atari-style uppercase */
155: strncpy(pDTA->dta_name,file->d_name,TOS_NAMELEN); /* FIXME: better handling of long file names */
156: STMemory_WriteLong_PCSpace(pDTA->dta_size, (long)filestat.st_size);
157: STMemory_WriteWord_PCSpace(pDTA->dta_time, time2dos(filestat.st_mtime));
158: STMemory_WriteWord_PCSpace(pDTA->dta_date, date2dos(filestat.st_mtime));
159: pDTA->dta_attrib = GemDOS_ConvertAttribute(filestat.st_mode);
160:
161: return(TRUE);
162: }
163:
164:
165: /*-----------------------------------------------------------------------*/
166: /*
167: Clear a used DTA structure.
168: */
169: void ClearInternalDTA(){
170: int i;
171:
172: /* clear the old DTA structure */
173: if(InternalDTAs[DTAIndex].found != NULL){
174: for(i=0; i <InternalDTAs[DTAIndex].nentries; i++)
175: free(InternalDTAs[DTAIndex].found[i]);
176: free(InternalDTAs[DTAIndex].found);
177: }
178: InternalDTAs[DTAIndex].bUsed = FALSE;
179: }
180:
181:
182: /*-----------------------------------------------------------------------*/
183: /*
184: Match a file to a dir mask.
185: */
186: static int match (char *pat, char *name)
187: {
188: /* make uppercase copies */
189: char p0[MAX_PATH], n0[MAX_PATH];
190: strcpy(p0, pat);
191: strcpy(n0, name);
192: Misc_strupr(p0);
193: Misc_strupr(n0);
194:
195: if(name[0] == '.') return(FALSE); /* no .* files */
196: if (strcmp(pat,"*.*")==0) return(TRUE);
197: else if (strcasecmp(pat,name)==0) return(TRUE);
198: else
199: {
200: char *p=p0,*n=n0;
201: for(;*n;)
202: {
203: if (*p=='*') {while (*n && *n != '.') n++;p++;}
204: else if (*p=='?' && *n) {n++;p++;}
205: else if (*p++ != *n++) return(FALSE);
206: }
207: if (*p==0)
208: {
209: return(TRUE);
210: }
211: }
212: return(FALSE);
213: }
214:
215: /*-----------------------------------------------------------------------*/
216: /*
217: Parse directory from sfirst mask
218: - e.g.: input: "hdemudir/auto/mask*.*" outputs: "hdemudir/auto"
219: */
220: void fsfirst_dirname(char *string, char *new){
221: int i=0;
222:
223: sprintf(new, string);
224: /* convert to front slashes. */
225: i=0;
226: while(new[i] != '\0'){
227: if(new[i] == '\\') new[i] = '/';
228: i++;
229: }
230: while(string[i] != '\0'){new[i] = string[i]; i++;} /* find end of string */
231: while(new[i] != '/') i--; /* find last slash */
232: new[i] = '\0';
233:
234: }
235:
236: /*-----------------------------------------------------------------------*/
237: /*
238: Parse directory mask, e.g. "*.*"
239: */
240: void fsfirst_dirmask(char *string, char *new){
241: int i=0, j=0;
242: while(string[i] != '\0')i++; /* go to end of string */
243: while(string[i] != '/') i--; /* find last slash */
244: i++;
245: while(string[i] != '\0')new[j++] = string[i++]; /* go to end of string */
246: new[j++] = '\0';
247: }
248:
249: /*-----------------------------------------------------------------------*/
250: /*
251: Initialize GemDOS/PC file system
252: */
253: void GemDOS_Init(void)
254: {
255: int i;
256:
257: /* Clear handles structure */
258: Memory_Clear(FileHandles, sizeof(FILE_HANDLE)*MAX_FILE_HANDLES);
259: /* Clear DTAs */
260: for(i=0; i<MAX_DTAS_FILES; i++)
261: {
262: InternalDTAs[i].bUsed = FALSE;
263: InternalDTAs[i].nentries = 0;
264: InternalDTAs[i].found = NULL;
265: }
266: DTAIndex = 0;
267: }
268:
269: /*-----------------------------------------------------------------------*/
270: /*
271: Reset GemDOS file system
272: */
273: void GemDOS_Reset()
274: {
275: int i;
276:
277: /* Init file handles table */
278: for(i=0; i<MAX_FILE_HANDLES; i++)
279: {
280: /* Was file open? If so close it */
281: if (FileHandles[i].bUsed)
282: fclose(FileHandles[i].FileHandle);
283:
284: FileHandles[i].FileHandle = NULL;
285: FileHandles[i].bUsed = FALSE;
286: }
287:
288: for(i=0; i<MAX_DTAS_FILES; i++)
289: {
290: InternalDTAs[i].bUsed = FALSE;
291: InternalDTAs[i].nentries = 0;
292: InternalDTAs[i].found = NULL;
293: }
294:
295: /* Reset */
296: pDTA = NULL;
297: DTAIndex = 0;
298: }
299:
300:
301: /*-----------------------------------------------------------------------*/
302: /*
303: Initialize a GEMDOS drive.
304: Only 1 emulated drive allowed, as of yet.
305: */
306: void GemDOS_InitDrives()
307: {
308: /* set emulation directory string */
309: strcpy(emudrive.hd_emulation_dir, "./");
310:
311: /* remove trailing slash, if any in the directory name */
312: File_CleanFileName(emudrive.hd_emulation_dir);
313:
314: emudrive.hd_letter = 2;
315: }
316:
317:
318: /*-----------------------------------------------------------------------*/
319: /*
320: Un-init the GEMDOS drive
321: */
322: void GemDOS_UnInitDrives()
323: {
324: GemDOS_Reset(); /* Close all open files on emulated drive*/
325: }
326:
327:
328: /*-----------------------------------------------------------------------*/
329: /*
330: Return free PC file handle table index, or -1 if error
331: */
332: int GemDOS_FindFreeFileHandle(void)
333: {
334: int i;
335:
336: /* Scan our file list for free slot */
337: for(i=0; i<MAX_FILE_HANDLES; i++) {
338: if (!FileHandles[i].bUsed)
339: return(i);
340: }
341:
342: /* Cannot open any more files, return error */
343: return(-1);
344: }
345:
346: /*-----------------------------------------------------------------------*/
347: /*
348: Check ST handle is within our table range, return TRUE if not
349: */
350: BOOL GemDOS_IsInvalidFileHandle(int Handle)
351: {
352: BOOL bInvalidHandle=FALSE;
353:
354: /* Check handle was valid with our handle table */
355: if ( (Handle<0) || (Handle>=MAX_FILE_HANDLES) )
356: bInvalidHandle = TRUE;
357: else if (!FileHandles[Handle].bUsed)
358: bInvalidHandle = TRUE;
359:
360: return(bInvalidHandle);
361: }
362:
363: int baselen(char *s) {
364: /* Returns the length of the basename of the file passed in parameter
365: (ie the file without extension) */
366: char *ext = strchr(s,'.');
367: if (ext) return ext-s;
368: return strlen(s);
369: }
370:
371: /*-----------------------------------------------------------------------*/
372: /*
373: Use hard-drive directory, current ST directory and filename to create full path
374: */
375: void GemDOS_CreateHardDriveFileName(int Drive,char *pszFileName,char *pszDestName)
376: {
377: /* int DirIndex = Misc_LimitInt(Drive-2, 0,ConfigureParams.HardDisc.nDriveList-1); */
378: char *s,*start;
379:
380: if(pszFileName[0] == '\0') return; /* check for valid string */
381:
382: /* case full filename "C:\foo\bar" */
383: s=pszDestName; start=NULL;
384:
385: if(pszFileName[1] == ':') {
386: sprintf(pszDestName, "%s%s", emudrive.hd_emulation_dir, File_RemoveFileNameDrive(pszFileName));
387: }
388: /* case referenced from root: "\foo\bar" */
389: else if(pszFileName[0] == '\\'){
390: sprintf(pszDestName, "%s%s", emudrive.hd_emulation_dir, pszFileName);
391: }
392: /* case referenced from current directory */
393: else {
394: sprintf(pszDestName, "%s%s", emudrive.fs_currpath, pszFileName);
395: start = pszDestName + strlen(emudrive.fs_currpath)-1;
396: }
397:
398: /* convert to front slashes. */
399: while((s = strchr(s+1,'\\'))) {
400: if (!start) {
401: start = s;
402: continue;
403: }
404: {
405: glob_t globbuf;
406: char old1,old2,dest[256];
407: int len,j,found,base_len;
408:
409: *start++ = '/';
410: old1 = *start; *start++ = '*';
411: old2 = *start; *start = 0;
412: glob(pszDestName,GLOB_ONLYDIR,NULL,&globbuf);
413: *start-- = old2; *start = old1;
414: *s = 0;
415: len = strlen(pszDestName);
416: base_len = baselen(start);
417: found = 0;
418: for (j=0; j<globbuf.gl_pathc; j++) {
419: /* If we search for a file of at least 8 characters, then it might
420: be a longer filename since the ST can access only the first 8
421: characters. If not, then it's a precise match (with case). */
422: if (!(base_len < 8 ? strcasecmp(globbuf.gl_pathv[j],pszDestName) :
423: strncasecmp(globbuf.gl_pathv[j],pszDestName,len))) {
424: /* we found a matching name... */
425: sprintf(dest,"%s%c%s",globbuf.gl_pathv[j],'/',s+1);
426: strcpy(pszDestName,dest);
427: j = globbuf.gl_pathc;
428: found = 1;
429: }
430: }
431: globfree(&globbuf);
432: if (!found) {
433: /* didn't find it. Let's try normal files (it might be a symlink) */
434: *start++ = '*';
435: *start = 0;
436: glob(pszDestName,0,NULL,&globbuf);
437: *start-- = old2; *start = old1;
438: for (j=0; j<globbuf.gl_pathc; j++) {
439: if (!strncasecmp(globbuf.gl_pathv[j],pszDestName,len)) {
440: /* we found a matching name... */
441: sprintf(dest,"%s%c%s",globbuf.gl_pathv[j],'/',s+1);
442: strcpy(pszDestName,dest);
443: j = globbuf.gl_pathc;
444: found = 1;
445: }
446: }
447: globfree(&globbuf);
448: if (!found) { /* really nothing ! */
449: *s = '/';
450: fprintf(stderr,"no path for %s\n",pszDestName);
451: }
452: }
453: }
454: start = s;
455: }
456:
457: if (!start) start = strrchr(pszDestName,'/'); // path already converted ?
458:
459: if (start) {
460: *start++ = '/'; /* in case there was only 1 anti slash */
461: if (*start && !strchr(start,'?') && !strchr(start,'*')) {
462: /* We have a complete name after the path, not a wildcard */
463: glob_t globbuf;
464: char old1,old2;
465: int len,j,found,base_len;
466:
467: old1 = *start; *start++ = '*';
468: old2 = *start; *start = 0;
469: glob(pszDestName,0,NULL,&globbuf);
470: *start-- = old2; *start = old1;
471: len = strlen(pszDestName);
472: base_len = baselen(start);
473: found = 0;
474: for (j=0; j<globbuf.gl_pathc; j++) {
475: /* If we search for a file of at least 8 characters, then it might
476: be a longer filename since the ST can access only the first 8
477: characters. If not, then it's a precise match (with case). */
478: if (!(base_len < 8 ? strcasecmp(globbuf.gl_pathv[j],pszDestName) :
479: strncasecmp(globbuf.gl_pathv[j],pszDestName,len))) {
480: /* we found a matching name... */
481: strcpy(pszDestName,globbuf.gl_pathv[j]);
482: j = globbuf.gl_pathc;
483: found = 1;
484: }
485: }
486: #if FILE_DEBUG
487: if (!found) {
488: /* It's often normal, the gem uses this to test for existence */
489: /* of desktop.inf or newdesk.inf for example. */
490: fprintf(stderr,"didn't find filename %s\n",pszDestName);
491: }
492: #endif
493: globfree(&globbuf);
494: }
495: }
496:
497: #if FILE_DEBUG
498: fprintf(stderr,"conv %s -> %s\n",pszFileName,pszDestName);
499: #endif
500: }
501:
502: /*-----------------------------------------------------------------------*/
503: /*
504: Covert from FindFirstFile/FindNextFile attribute to GemDOS format
505: */
506: unsigned char GemDOS_ConvertAttribute(mode_t mode)
507: {
508: unsigned char Attrib=0;
509:
510: /* FIXME: More attributes */
511: if(S_ISDIR(mode)) Attrib |= GEMDOS_FILE_ATTRIB_SUBDIRECTORY;
512:
513: /* FIXME */
514: /*
515: // Look up attributes
516: if (dwFileAttributes&FILE_ATTRIBUTE_READONLY)
517: Attrib |= GEMDOS_FILE_ATTRIB_READONLY;
518: if (dwFileAttributes&FILE_ATTRIBUTE_HIDDEN)
519: Attrib |= GEMDOS_FILE_ATTRIB_HIDDEN;
520: if (dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
521: Attrib |= GEMDOS_FILE_ATTRIB_SUBDIRECTORY;
522: */
523: return(Attrib);
524: }
525:
526:
527: /*-----------------------------------------------------------------------*/
528: /*
529: GEMDOS Set Disc Transfer Address (DTA)
530: Call 0x1A
531: */
532: void GemDOS_SetDTA(unsigned long Params)
533: {
534: /* Look up on stack to find where DTA is! Store as PC pointer */
535: pDTA = (DTA *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD));
536: }
537:
538: /*-----------------------------------------------------------------------*/
539: /*
540: GEMDOS Create file
541: Call 0x3C
542: */
543: void GemDOS_Create(unsigned long Params)
544: {
545: char szActualFileName[MAX_PATH];
546: char *pszFileName;
547: char *rwflags[] = { "w+", /* read / write (truncate if exists) */
548: "wb" /* write only */
549: };
550: int Drive,Index,Mode;
551:
552: /* Find filename */
553: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD));
554: Mode = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG);
555: Drive = 2;
556: /* And convert to hard drive filename */
557: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName);
558:
559: /* Find slot to store file handle, as need to return WORD handle for ST */
560: Index = GemDOS_FindFreeFileHandle();
561: if (Index==-1) {
562: /* No free handles, return error code */
563: Regs[REG_D0] = GEMDOS_ENHNDL; /* No more handles */
564: return;
565: }
566: else {
567: #ifdef ENABLE_SAVING
568:
569: FileHandles[Index].FileHandle = fopen(szActualFileName, rwflags[Mode&0x01]);
570:
571: if (FileHandles[Index].FileHandle != NULL) {
572: /* Tag handle table entry as used and return handle */
573: FileHandles[Index].bUsed = TRUE;
574: Regs[REG_D0] = Index+BASE_FILEHANDLE; /* Return valid ST file handle from range 6 to 45! (ours start from 0) */
575: return;
576: }
577: else {
578: Regs[REG_D0] = GEMDOS_EFILNF; /* File not found */
579: return;
580: }
581: #else
582: Regs[REG_D0] = GEMDOS_EFILNF; /* File not found */
583: return;
584: #endif
585: }
586: }
587:
588: /*-----------------------------------------------------------------------*/
589: /*
590: GEMDOS Open file
591: Call 0x3D
592: */
593: void GemDOS_Open(unsigned long Params)
594: {
595: char szActualFileName[MAX_PATH];
596: char *pszFileName;
597: char *open_modes[] = { "rb", "wb", "r+" }; /* convert atari modes to stdio modes */
598: int Drive,Index,Mode;
599:
600: /* Find filename */
601: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD));
602: Mode = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG);
603: Drive = 2;
604:
605: /* And convert to hard drive filename */
606: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName);
607: /* Find slot to store file handle, as need to return WORD handle for ST */
608: Index = GemDOS_FindFreeFileHandle();
609: if (Index == -1) {
610: /* No free handles, return error code */
611: Regs[REG_D0] = GEMDOS_ENHNDL; /* No more handles */
612: return;
613: }
614:
615: /* Open file */
616: FileHandles[Index].FileHandle = fopen(szActualFileName, open_modes[Mode&0x03]);
617:
618: sprintf(FileHandles[Index].szActualName,"%s",szActualFileName);
619:
620: if (FileHandles[Index].FileHandle != NULL) {
621: /* Tag handle table entry as used and return handle */
622: FileHandles[Index].bUsed = TRUE;
623: Regs[REG_D0] = Index+BASE_FILEHANDLE; /* Return valid ST file handle from range 6 to 45! (ours start from 0) */
624: return;
625: }
626: Regs[REG_D0] = GEMDOS_EFILNF; /* File not found/ error opening */
627: return;
628: }
629:
630: /*-----------------------------------------------------------------------*/
631: /*
632: GEMDOS Close file
633: Call 0x3E
634: */
635: void GemDOS_Close(unsigned long Params)
636: {
637: int Handle;
638:
639: /* Find our handle - may belong to TOS */
640: Handle = STMemory_ReadWord(Params+SIZE_WORD)-BASE_FILEHANDLE;
641:
642: /* Check handle was valid */
643: if (GemDOS_IsInvalidFileHandle(Handle)) {
644: /* No assume was TOS */
645: return;
646: }
647: else {
648: /* Close file and free up handle table */
649: fclose(FileHandles[Handle].FileHandle);
650: FileHandles[Handle].bUsed = FALSE;
651: /* Return no error */
652: Regs[REG_D0] = GEMDOS_EOK;
653: return;
654: }
655: }
656:
657: /*-----------------------------------------------------------------------*/
658: /*
659: GEMDOS Read file
660: Call 0x3F
661: */
662: void GemDOS_Read(unsigned long Params)
663: {
664: char *pBuffer;
665: unsigned long nBytesRead,Size,CurrentPos,FileSize;
666: long nBytesLeft;
667: int Handle;
668:
669: /* Read details from stack */
670: Handle = STMemory_ReadWord(Params+SIZE_WORD)-BASE_FILEHANDLE;
671: Size = STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD);
672: pBuffer = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD+SIZE_LONG));
673:
674: /* Check handle was valid */
675: if (GemDOS_IsInvalidFileHandle(Handle)) {
676: /* No - assume was TOS */
677: return;
678: }
679: else {
680:
681: /* To quick check to see where our file pointer is and how large the file is */
682: CurrentPos = ftell(FileHandles[Handle].FileHandle);
683: fseek(FileHandles[Handle].FileHandle, 0, SEEK_END);
684: FileSize = ftell(FileHandles[Handle].FileHandle);
685: fseek(FileHandles[Handle].FileHandle, CurrentPos, SEEK_SET);
686:
687: nBytesLeft = FileSize-CurrentPos;
688:
689: /* Check for End Of File */
690: if (nBytesLeft == 0) {
691: /* FIXME: should we return zero (bytes read) or an error? */
692: Regs[REG_D0] = 0;
693: return;
694: }
695: else {
696: /* Limit to size of file to prevent windows error */
697: if (Size>FileSize)
698: Size = FileSize;
699: /* And read data in */
700: nBytesRead = fread(pBuffer, 1, Size, FileHandles[Handle].FileHandle);
701:
702: /* Return number of bytes read */
703: Regs[REG_D0] = nBytesRead;
704:
705: return;
706: }
707: }
708: }
709:
710: /*-----------------------------------------------------------------------*/
711: /*
712: GEMDOS Write file
713: Call 0x40
714: */
715: void GemDOS_Write(unsigned long Params)
716: {
717: char *pBuffer;
718: unsigned long Size,nBytesWritten;
719: int Handle;
720:
721: #ifdef ENABLE_SAVING
722: /* Read details from stack */
723: Handle = STMemory_ReadWord(Params+SIZE_WORD)-BASE_FILEHANDLE;
724: Size = STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD);
725: pBuffer = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD+SIZE_LONG));
726:
727: /* Check handle was valid */
728: if (GemDOS_IsInvalidFileHandle(Handle)) {
729: /* No assume was TOS */
730: return;
731: }
732: else {
733:
734: nBytesWritten = fwrite(pBuffer, 1, Size, FileHandles[Handle].FileHandle);
735: if (nBytesWritten>=0) {
736:
737: Regs[REG_D0] = nBytesWritten; /* OK */
738: }
739: else
740: Regs[REG_D0] = GEMDOS_EACCDN; /* Access denied(ie read-only) */
741:
742: return;
743: }
744: #endif
745:
746: return;
747: }
748:
749: /*-----------------------------------------------------------------------*/
750: /*
751: GEMDOS UnLink(Delete) file
752: Call 0x41
753: */
754: void GemDOS_UnLink(unsigned long Params)
755: {
756: #ifdef ENABLE_SAVING
757: char szActualFileName[MAX_PATH];
758: char *pszFileName;
759: int Drive;
760:
761: /* Find filename */
762: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD));
763: Drive = 2;
764: /* And convert to hard drive filename */
765: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName);
766:
767: /* Now delete file?? */
768: if ( unlink(szActualFileName)==0 )
769: Regs[REG_D0] = GEMDOS_EOK; /* OK */
770: else
771: Regs[REG_D0] = GEMDOS_EFILNF; /* File not found */
772:
773: return;
774: #endif
775:
776: }
777:
778: /*-----------------------------------------------------------------------*/
779: /*
780: GEMDOS Search Next
781: Call 0x4F
782: */
783: void GemDOS_SNext(unsigned long Params)
784: {
785: struct dirent **temp;
786: int Index;
787:
788: /* Was DTA ours or TOS? */
789: if (STMemory_ReadLong_PCSpace(pDTA->magic)==DTA_MAGIC_NUMBER) {
790:
791: /* Find index into our list of structures */
792: Index = STMemory_ReadWord_PCSpace(pDTA->index)&(MAX_DTAS_FILES-1);
793:
794: if(InternalDTAs[Index].centry >= InternalDTAs[Index].nentries){
795: Regs[REG_D0] = GEMDOS_ENMFIL; /* No more files */
796: return;
797: }
798:
799: temp = InternalDTAs[Index].found;
800: if(PopulateDTA(InternalDTAs[Index].path, temp[InternalDTAs[Index].centry++]) == FALSE){
801: fprintf(stderr,"\tError setting DTA.\n");
802: return;
803: }
804:
805: Regs[REG_D0] = GEMDOS_EOK;
806: return;
807: }
808:
809: return;
810: }
811:
812:
813: /*-----------------------------------------------------------------------*/
814: /*
815: GEMDOS Find first file
816: Call 0x4E
817: */
818: void GemDOS_SFirst(unsigned long Params)
819: {
820: char szActualFileName[MAX_PATH];
821: char tempstr[MAX_PATH];
822: char *pszFileName;
823: struct dirent **files;
824: unsigned short int Attr;
825: int Drive;
826: DIR *fsdir;
827: int i,j,k;
828:
829: /* Find filename to search for */
830: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD));
831: Attr = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG);
832:
833: Drive = 2;
834:
835: /* And convert to hard drive filename */
836: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName);
837:
838: /* Populate DTA, set index for our use */
839: STMemory_WriteWord_PCSpace(pDTA->index,DTAIndex);
840: STMemory_WriteLong_PCSpace(pDTA->magic,DTA_MAGIC_NUMBER); /* set our dta magic num */
841:
842: if(InternalDTAs[DTAIndex].bUsed == TRUE) ClearInternalDTA();
843: InternalDTAs[DTAIndex].bUsed = TRUE;
844:
845: /* Were we looking for the volume label? */
846: if (Attr&GEMDOS_FILE_ATTRIB_VOLUME_LABEL) {
847: /* Volume name */
848: strcpy(pDTA->dta_name,"EMULATED.001");
849: Regs[REG_D0] = GEMDOS_EOK; /* Got volume */
850: return;
851: }
852:
853: /* open directory */
854: fsfirst_dirname(szActualFileName, InternalDTAs[DTAIndex].path);
855: fsdir = opendir(InternalDTAs[DTAIndex].path);
856:
857: if( fsdir == NULL ){
858: Regs[REG_D0] = GEMDOS_EPTHNF; /* Path not found */
859: return;
860: }
861: /* close directory */
862: closedir( fsdir );
863:
864: InternalDTAs[DTAIndex].nentries = scandir(InternalDTAs[DTAIndex].path, &files, 0, alphasort);
865: if( InternalDTAs[DTAIndex].nentries < 0 ){
866: Regs[REG_D0] = GEMDOS_EFILNF; /* File (directory actually) not found */
867: return;
868: }
869:
870: InternalDTAs[DTAIndex].centry = 0; /* current entry is 0 */
871: fsfirst_dirmask(szActualFileName, tempstr); /* get directory mask */
872:
873: /* Create and populate a list of matching files. */
874:
875: j = 0; /* count number of entries matching mask */
876: for(i=0;i<InternalDTAs[DTAIndex].nentries;i++)
877: if(match(tempstr, files[i]->d_name)) j++;
878:
879: if (j==0) {
880: return;
881: }
882:
883: InternalDTAs[DTAIndex].found = (struct dirent **)malloc(sizeof(struct dirent *) * j);
884:
885: /* copy the dirent pointers for files matching the mask to our list */
886: k = 0;
887: for(i=0;i<InternalDTAs[DTAIndex].nentries;i++)
888: if(match(tempstr, files[i]->d_name)){
889: InternalDTAs[DTAIndex].found[k] = files[i];
890: k++;
891: }
892:
893: InternalDTAs[DTAIndex].nentries = j; /* set number of legal entries */
894:
895: if(InternalDTAs[DTAIndex].nentries == 0){
896: /* No files of that match, return error code */
897: Regs[REG_D0] = GEMDOS_EFILNF; /* File not found */
898: return;
899: }
900:
901: /* Scan for first file (SNext uses no parameters) */
902: GemDOS_SNext(0);
903: /* increment DTA index */
904: DTAIndex++;
905: DTAIndex&=(MAX_DTAS_FILES-1);
906:
907: return;
908: }
909:
910:
911: void Call_Memset (unsigned long Params)
912: {
913: int adr, count;
914: count = STMemory_ReadLong (Params+SIZE_WORD);
915: adr = STMemory_ReadLong (Params+SIZE_WORD+SIZE_LONG);
916: memset (STRam+adr, 0, count);
917: }
918:
919: void Call_MemsetBlue (unsigned long Params)
920: {
921: int adr, count;
922: count = STMemory_ReadLong (Params+SIZE_WORD);
923: adr = STMemory_ReadLong (Params+SIZE_WORD+SIZE_LONG);
924: memset (STRam+adr, 0xe, count);
925: }
926:
927: void Call_Memcpy (unsigned long Params)
928: {
929: int dest, src, count;
930:
931: dest = STMemory_ReadLong (Params + SIZE_WORD);
932: src = STMemory_ReadLong (Params + SIZE_WORD + SIZE_LONG);
933: count = STMemory_ReadLong (Params + SIZE_WORD + 2*SIZE_LONG);
934:
935: memcpy (STRam+dest, STRam+src, count);
936: }
937:
938: static const char mouse_bmp[256] = {
939: 0, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
940: 0,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
941: 0,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
942: 0,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
943: 0,15,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
944: 0,15,15,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,
945: 0,15,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
946: 0,15,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
947: 0,15, 0,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,
948: 0, 0,-1, 0,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,
949: -1,-1,-1, 0,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,
950: -1,-1,-1,-1, 0,15,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,
951: -1,-1,-1,-1, 0,15,15,15, 0,-1,-1,-1,-1,-1,-1,-1,
952: -1,-1,-1,-1,-1, 0,15, 0,-1,-1,-1,-1,-1,-1,-1,-1,
953: -1,-1,-1,-1,-1,-1, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,
954: -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
955: };
956:
957: Uint8 under_mouse[256];
958:
959: void Call_BlitCursor (unsigned long Params)
960: {
961: int x, y, adr, org_x, org_y;
962: Uint8 *pixbase, *pix;
963: const char *bmp;
964: Uint8 *save;
965: org_x = STMemory_ReadLong (Params+SIZE_WORD);
966: org_y = STMemory_ReadLong (Params+SIZE_WORD+SIZE_LONG);
967: adr = STMemory_ReadLong (Params+SIZE_WORD+2*SIZE_LONG);
968:
969: pixbase = STRam + adr + (org_y*SCREENBYTES_LINE) + org_x;
970: bmp = mouse_bmp;
971: save = under_mouse;
972:
973: for (y=0; y<16; y++) {
974: if (y + org_y > SCREEN_HEIGHT_HBL) break;
975: pix = pixbase;
976: pixbase += SCREENBYTES_LINE;
977: for (x=0; x<16; x++, pix++, bmp++, save++) {
978: if (x+org_x >= SCREENBYTES_LINE) continue;
979: *save = *pix;
980: if (*bmp != -1) *pix = *bmp;
981: }
982: }
983: }
984:
985: void Call_RestoreUnderCursor (unsigned long Params)
986: {
987: int x, y, adr, org_x, org_y;
988: Uint8 *pixbase, *pix;
989: char *bmp;
990: org_x = STMemory_ReadLong (Params+SIZE_WORD);
991: org_y = STMemory_ReadLong (Params+SIZE_WORD+SIZE_LONG);
992: adr = STMemory_ReadLong (Params+SIZE_WORD+2*SIZE_LONG);
993:
994: pixbase = STRam + adr + (org_y*SCREENBYTES_LINE) + org_x;
995: bmp = under_mouse;
996:
997: for (y=0; y<16; y++) {
998: if (y + org_y > SCREEN_HEIGHT_HBL) break;
999: pix = pixbase;
1000: pixbase += SCREENBYTES_LINE;
1001: for (x=0; x<16; x++, pix++, bmp++) {
1002: if (x+org_x >= SCREENBYTES_LINE) continue;
1003: if (*bmp != -1) *pix = *bmp;
1004: }
1005: }
1006: }
1007:
1008: void Call_PutPix (unsigned long Params)
1009: {
1010: int col, org_x, scr;
1011: char *pix;
1012: col = STMemory_ReadWord (Params+SIZE_WORD)>>2;
1013: org_x = Regs[REG_D4] & 0xffff;
1014: scr = Regs[REG_A3];
1015:
1016: /* hack to fix screen line. frontier's logic still thinks
1017: * there are 160 bytes per line */
1018: /* which screen buffer it is based on */
1019: if (scr & 0x100000) {
1020: scr -= 0x100000;
1021: scr *= 2;
1022: scr += 0x100000;
1023: } else {
1024: scr -= 0xf0000;
1025: scr *= 2;
1026: scr += 0xf0000;
1027: }
1028: pix = (char *)STRam + scr + org_x;
1029: *pix = col;
1030: return;
1031: }
1032:
1033: void Call_FillLine (unsigned long Params)
1034: {
1035: int org_x,len,scr,col;
1036: char *pix;
1037:
1038: col = STMemory_ReadWord (Params+SIZE_WORD)>>2;
1039: org_x = Regs[REG_D4] & 0xffff;
1040: len = (~Regs[REG_D5]) & 0xffff;
1041: scr = Regs[REG_A3];
1042:
1043: /* hack to fix screen line. frontier's logic still thinks
1044: * there are 160 bytes per line */
1045: /* which screen buffer it is based on */
1046: if (scr & 0x100000) {
1047: scr -= 0x100000;
1048: scr *= 2;
1049: scr += 0x100000;
1050: } else {
1051: scr -= 0xf0000;
1052: scr *= 2;
1053: scr += 0xf0000;
1054: }
1055: pix = (char *)STRam + scr;
1056: org_x = SCREENBYTES_LINE;
1057: while (org_x--) {
1058: *pix = col;
1059: pix++;
1060: }
1061: }
1062:
1063: /*
1064: * This is used by the scanner code to draw object stalks
1065: * which are below the plane of the scanner.
1066: * The mask d7 indicates which pixels in the plane to set,
1067: * and they are set if their current colour is zero.
1068: *
1069: * This implementation isn't the way the function is really
1070: * supposed to be implemented (colour and draw mask was
1071: * combined in d6 but the colour mask is wrong now for
1072: * non-planar screen).
1073: */
1074: void Call_BackHLine (unsigned long Params)
1075: {
1076: int i,scr,col,bitfield;
1077: char *pix;
1078:
1079: col = STMemory_ReadWord (Params+SIZE_WORD)>>2;
1080: scr = Regs[REG_A3];
1081: bitfield = Regs[REG_D7] & 0xffff;
1082:
1083: /* hack to fix screen line. frontier's logic still thinks
1084: * there are 160 bytes per line */
1085: /* which screen buffer it is based on */
1086: if (scr & 0x100000) {
1087: scr -= 0x100000;
1088: scr *= 2;
1089: scr += 0x100000;
1090: } else {
1091: scr -= 0xf0000;
1092: scr *= 2;
1093: scr += 0xf0000;
1094: }
1095: pix = STRam + scr;
1096: for (i=15; i>=0; i--) {
1097: if ((bitfield & (1<<i)) && (*pix == 0)) *pix = col;
1098: pix++;
1099: }
1100: }
1101:
1102: void Call_OldHLine (unsigned long Params)
1103: {
1104: int org_x,len,scr,col;
1105: char *pix;
1106:
1107: col = STMemory_ReadWord (Params+SIZE_WORD)>>2;
1108: //printf ("col=%d, d4=%d, (idx) d5=%d, (scr_line) a3=%p\n", col, Regs[REG_D4]&0xffff, Regs[REG_D5]&0xffff, (void*)Regs[REG_A3]);
1109: org_x = Regs[REG_D4] & 0xffff;
1110: len = Regs[REG_D5] & 0xffff;
1111: scr = Regs[REG_A3];
1112:
1113: /* hack to fix screen line. frontier's logic still thinks
1114: * there are 160 bytes per line */
1115: /* which screen buffer it is based on */
1116: if (scr & 0x100000) {
1117: scr -= 0x100000;
1118: scr *= 2;
1119: scr += 0x100000;
1120: } else {
1121: scr -= 0xf0000;
1122: scr *= 2;
1123: scr += 0xf0000;
1124: }
1125: len = len/2;
1126: /* horizontal line */
1127: pix = STRam + scr + org_x;
1128: while (len--) {
1129: *pix = col;
1130: pix++;
1131: }
1132: }
1133:
1134: void Call_HLine (unsigned long Params)
1135: {
1136: int org_x,len,scr,col;
1137: char *pix;
1138:
1139: col = (Regs[REG_D1] & 0xffff)>>2;
1140: org_x = Regs[REG_D4] & 0xffff;
1141: len = Regs[REG_D5] & 0xffff;
1142: scr = Regs[REG_A3];
1143:
1144: /* horizontal line */
1145: pix = STRam + scr + org_x;
1146: while (len--) {
1147: *pix = col;
1148: pix++;
1149: }
1150: }
1151:
1152: /*
1153: * Blits frontier format 4-plane thingy
1154: */
1155: void Call_BlitBmp (unsigned long Params)
1156: {
1157: int width, height, org_x, org_y, bmp, scr;
1158: char *bmp_pix, *scr_pix, *ybase;
1159: int xpoo, i, ypoo, plane_incr;
1160:
1161: short word0, word1, word2, word3;
1162:
1163: width = STMemory_ReadWord (Params+SIZE_WORD);
1164: height = STMemory_ReadWord (Params+SIZE_WORD*2);
1165: org_x = STMemory_ReadWord (Params+SIZE_WORD*3);
1166: org_y = STMemory_ReadWord (Params+SIZE_WORD*4);
1167: bmp = STMemory_ReadLong (Params+SIZE_WORD*5);
1168: scr = STMemory_ReadLong (Params+SIZE_WORD*5 + SIZE_LONG);
1169:
1170: /* width is in words (width/16) */
1171: //printf ("Blit %dx%d to %d,%d, bmp 0x%x, scr 0x%x.\n", width, height, org_x, org_y, bmp, scr);
1172: bmp_pix = STRam + bmp + 4;
1173: ybase = STRam + scr + (org_y*SCREENBYTES_LINE) + org_x;
1174:
1175: /* These checks were in the original blit routine */
1176: if (org_x < 0) return;
1177: if (org_y < 0) return;
1178: if (height > 200) return;
1179: if (width > 320) return;
1180:
1181: plane_incr = 2*height*width;
1182:
1183: ypoo = height;
1184: while (ypoo--) {
1185: scr_pix = (char *)ybase;
1186: ybase += SCREENBYTES_LINE;
1187: for (xpoo = width; xpoo; xpoo--) {
1188: word0 = SDL_SwapBE16 (*((short*)bmp_pix));
1189: bmp_pix += plane_incr;
1190: word1 = SDL_SwapBE16 (*((short*)bmp_pix));
1191: bmp_pix += plane_incr;
1192: word2 = SDL_SwapBE16 (*((short*)bmp_pix));
1193: bmp_pix += plane_incr;
1194: word3 = SDL_SwapBE16 (*((short*)bmp_pix));
1195:
1196: for (i=0; i<16; i++) {
1197: *scr_pix = (word0 >> (15-i))&0x1;
1198: *scr_pix |= ((word1 >> (15-i))&0x1)<<1;
1199: *scr_pix |= ((word2 >> (15-i))&0x1)<<2;
1200: *scr_pix |= ((word3 >> (15-i))&0x1)<<3;
1201: scr_pix++;
1202: }
1203: bmp_pix -= 3*plane_incr;
1204: bmp_pix += 2;
1205: }
1206: }
1207: }
1208:
1209: #define SCR_W 320
1210:
1211: void Call_DrawStrShadowed (Params)
1212: {
1213: unsigned char *str;
1214:
1215: str = Regs[REG_A0] + STRam;
1216:
1217: Regs[REG_D1] = DrawStr (
1218: Regs[REG_D1], Regs[REG_D2],
1219: Regs[REG_D0], str, TRUE);
1220: }
1221:
1222: void Call_DrawStr (Params)
1223: {
1224: unsigned char *str;
1225:
1226: str = Regs[REG_A0] + STRam;
1227:
1228: Regs[REG_D1] = DrawStr (
1229: Regs[REG_D1], Regs[REG_D2],
1230: Regs[REG_D0], str, FALSE);
1231: }
1232:
1233: void Call_SetMainPalette (unsigned long Params)
1234: {
1235: Uint32 pal_ptr;
1236: int i;
1237:
1238: pal_ptr = STMemory_ReadLong (Params+SIZE_WORD);
1239:
1240: for (i=0; i<16; i++) {
1241: MainPalette[i] = STMemory_ReadWord (pal_ptr);
1242: //printf ("%hx ", MainPalette[i]);
1243: pal_ptr+=2;
1244: }
1245: //printf ("\n");
1246: }
1247:
1248: void Call_SetCtrlPalette (unsigned long Params)
1249: {
1250: Uint32 pal_ptr;
1251: int i;
1252:
1253: pal_ptr = STMemory_ReadLong (Params+SIZE_WORD);
1254:
1255: for (i=0; i<16; i++) {
1256: CtrlPalette[i] = STMemory_ReadWord (pal_ptr);
1257: pal_ptr+=2;
1258: }
1259: }
1260:
1261: int len_working_ext_pal;
1262: unsigned short working_ext_pal[240];
1263:
1264: void Call_InformScreens (unsigned long Params)
1265: {
1266: physcreen2 = STMemory_ReadLong (Params+SIZE_WORD);
1267: logscreen2 = STMemory_ReadLong (Params+SIZE_WORD+SIZE_LONG);
1268: physcreen = STMemory_ReadLong (Params+SIZE_WORD+2*SIZE_LONG);
1269: logscreen = STMemory_ReadLong (Params+SIZE_WORD+3*SIZE_LONG);
1270: }
1271:
1272: /* also copies the extended palette into main palette */
1273: void Call_SetScreenBase (unsigned long Params)
1274: {
1275: int i;
1276: VideoBase = STMemory_ReadLong (Params+SIZE_WORD);
1277: VideoRaster = STRam + VideoBase;
1278:
1279: for (i=0; i<len_working_ext_pal; i++) {
1280: MainPalette[16+i] = working_ext_pal[i];
1281: }
1282: len_main_palette = 16 + len_working_ext_pal;
1283: }
1284:
1285: void Call_MakeExtPalette (unsigned long Params)
1286: {
1287: int col_list, len, col_idx, col_val, i;
1288:
1289: col_list = STMemory_ReadLong (Params+SIZE_WORD);
1290:
1291: len = STMemory_ReadWord (col_list) >> 2;
1292: len_working_ext_pal = len;
1293: col_list+=2;
1294: //printf ("%d colours.\n", len+2);
1295: for (i=0; i<len; i++) {
1296: col_val = STMemory_ReadWord (col_list);
1297: working_ext_pal[i] = col_val;
1298: col_list += 2;
1299: col_idx = STMemory_ReadWord (col_list);
1300: /* offset dynamic colours into extended palette
1301: * range (colours 16+) */
1302: col_idx += 16<<2;
1303: STMemory_WriteWord (col_list, col_idx);
1304: col_list += 2;
1305: }
1306: }
1307:
1308: void Call_DumpRegs (unsigned long Params)
1309: {
1310: printf ("0x%x d0.l=%d ", m68k_getpc(), Regs[REG_D0]);
1311: printf ("d1.l=%d ", Regs[REG_D1]);
1312: printf ("d2.l=%d ", Regs[REG_D2]);
1313: printf ("d3.l=%d ", Regs[REG_D3]);
1314: printf ("d4.l=%d ", Regs[REG_D4]);
1315: printf ("d5.l=%d ", Regs[REG_D5]);
1316: printf ("d6.l=%d ", Regs[REG_D6]);
1317: printf ("d7.l=%d ", Regs[REG_D7]);
1318: printf ("\n");
1319: }
1320:
1321: void Call_NotifyOfScrFlip (unsigned long Params)
1322: {
1323: bScreenContentsChanged = TRUE;
1324: }
1325:
1326: /* mouse pos in d3,d4 */
1327: void Call_NotifyMousePos (unsigned long Params)
1328: {
1329: #if 0
1330: int x, y;
1331:
1332: x = Regs[REG_D3] & 0xffff;
1333: y = Regs[REG_D4] & 0xffff;
1334:
1335: x *= ScreenDraw.MouseScale;
1336: y *= ScreenDraw.MouseScale;
1337:
1338: SDL_EventState (SDL_MOUSEMOTION, SDL_DISABLE);
1339: SDL_WarpMouse (x, y);
1340: SDL_EventState (SDL_MOUSEMOTION, SDL_ENABLE);
1341: SDL_ShowCursor (SDL_ENABLE);
1342: #endif /* 0 */
1343: }
1344:
1345: void Call_DrawQuad (unsigned long Params)
1346: {
1347: int high, i, j;
1348: struct Point pts[4];
1349:
1350: pts[0].x = Regs[REG_D0];
1351: pts[0].y = Regs[REG_D1];
1352: pts[1].x = Regs[REG_D2];
1353: pts[1].y = Regs[REG_D3];
1354: pts[2].x = Regs[REG_D4];
1355: pts[2].y = Regs[REG_D5];
1356: pts[3].x = Regs[REG_D6];
1357: pts[3].y = Regs[REG_D7];
1358:
1359: /* the two points with highest y actually seem to be
1360: * drawn only to y-1 by the frontier routines. weird. */
1361: for (i=0; i<4; i++) {
1362: high = 0;
1363: for (j=0; j<4; j++) {
1364: if (pts[i].y > pts[j].y) high++;
1365: }
1366: if (high >= 2) pts[i].y--;
1367: }
1368: DrawPoly (pts, 4, Regs[REG_A0]/4);
1369: }
1370:
1371: void Call_DrawTriangle (unsigned long Params)
1372: {
1373: DrawTriangle (Regs[REG_D0], Regs[REG_D1],
1374: Regs[REG_D2], Regs[REG_D3],
1375: Regs[REG_D4], Regs[REG_D5],
1376: Regs[REG_A0]/4);
1377: }
1378:
1379: void Call_L35ea2 (unsigned long Params)
1380: {
1381: int d0,d1,d2,max;
1382:
1383: d0 = Regs[REG_D0];
1384: d1 = Regs[REG_D1];
1385: d2 = Regs[REG_D2];
1386:
1387: max = (d0 > d1 ? d0 : d1);
1388:
1389: if (d2 == 0) {
1390: printf ("Eeek. zero divide (for real)\n");
1391: Regs[REG_D0] = 0;
1392: Regs[REG_D1] = 0;
1393: return;
1394: }
1395:
1396: if ((d0 >= (1<<16)) || (d0 <= ((-1)<<16))) {
1397: Regs[REG_D0] = d0/(d2>>8);
1398: } else {
1399: Regs[REG_D0] = (d0<<8)/d2;
1400: }
1401: if ((d1 >= (1<<16)) || (d1 <= ((-1)<<16))) {
1402: Regs[REG_D1] = d1/(d2>>8);
1403: } else {
1404: Regs[REG_D1] = (d1<<8)/d2;
1405: }
1406: /* with d2=0x2000 the 1st BP is 0x3e000 */
1407: /* with d2=0x4000 the 1st BP is 0x7c010 */
1408: /* with d2=0x8000 the 1st BP is 0xf8000 */
1409: /* with d2=0x10000 the 1st BP is 0x1f0040 */
1410: /* next cunt point at > 0xf803f */
1411: //printf ("%d, %d, %d = %d, %d\n", d0, d1, d2, Regs[REG_D0], Regs[REG_D1]);
1412: }
1413:
1414: typedef void (*HOSTCALL) (unsigned long);
1415:
1416: HOSTCALL hostcalls [] = {
1417: NULL,
1418: &Call_Memset, /* 0x1 */
1419: &Call_MemsetBlue, /* 0x2 */
1420: &Call_BlitCursor, /* 0x3 */
1421: &Call_RestoreUnderCursor, /* 0x4 */
1422: &Call_BlitBmp, /* 0x5 */
1423: &Call_OldHLine, /* 0x6 */
1424: NULL, /* 0x7 */
1425: &Call_Memcpy, /* 0x8 */
1426: &Call_PutPix, /* 0x9 */
1427: &Call_BackHLine, /* 0xa */
1428: &Call_FillLine, /* 0xb */
1429: &Call_SetMainPalette, /* 0xc */
1430: &Call_SetCtrlPalette, /* 0xd */
1431: &Call_SetScreenBase, /* 0xe */
1432: &Screen_Draw, /* 0xf */
1433: &Call_DumpRegs, /* 0x10 */
1434: &Call_MakeExtPalette, /* 0x11 */
1435: &Call_PlaySFX, /* 0x12 */
1436: &Call_GetMouseInput, /* 0x13 */
1437: &Call_GetKeyboardEvent, /* 0x14 */
1438: &Call_L35ea2, /* 0x15 */
1439: &Call_HLine, /* 0x16 */
1440: &Call_NotifyOfScrFlip, /* 0x17 */
1441: &Call_NotifyMousePos, /* 0x18 */
1442: &Call_InformScreens, /* 0x19 */
1443: &GemDOS_SetDTA,
1444: &Call_DrawStrShadowed, /* 0x1b */
1445: &Call_DrawStr, /* 0x1c */
1446: &Call_DrawTriangle, /* 0x1d */
1447: &Call_DrawQuad, /* 0x1e */
1448: NULL,
1449: NULL, /* 0x20 */
1450: NULL,
1451: NULL,
1452: NULL,
1453: NULL,
1454: NULL,
1455: NULL,
1456: NULL,
1457: NULL,
1458: NULL,
1459: NULL,
1460: NULL,
1461: NULL,
1462: NULL,
1463: NULL,
1464: NULL,
1465: NULL, /* 0x30 */
1466: NULL,
1467: NULL,
1468: NULL,
1469: NULL,
1470: NULL,
1471: NULL,
1472: NULL,
1473: NULL,
1474: NULL,
1475: NULL,
1476: NULL,
1477: &GemDOS_Create,
1478: &GemDOS_Open,
1479: &GemDOS_Close,
1480: &GemDOS_Read,
1481: &GemDOS_Write, /* 0x40 */
1482: &GemDOS_UnLink,
1483: NULL,
1484: NULL,
1485: NULL,
1486: NULL,
1487: NULL,
1488: NULL,
1489: NULL,
1490: NULL,
1491: NULL,
1492: NULL,
1493: NULL,
1494: NULL,
1495: &GemDOS_SFirst,
1496: &GemDOS_SNext,
1497: NULL, /* 0x50 */
1498: };
1499:
1500: /*
1501: * Yay. Calling a C function from the 68k emu.
1502: */
1503: unsigned long HostCall_OpCode (uae_u32 opcode)
1504: {
1505: unsigned short int GemDOSCall;
1506: unsigned long Params;
1507:
1508: Params = Regs[REG_A7];
1509:
1510: GemDOSCall = STMemory_ReadWord(Params);
1511:
1512: (*hostcalls [GemDOSCall]) (Params);
1513:
1514: m68k_incpc (2);
1515: fill_prefetch_0 ();
1516: return 4;
1517: }
1518:
1519: /*
1520: * Faster hostcall, which takes opcode as immediate
1521: * 16-bit value, rather than on stack.
1522: */
1523: unsigned long HCall_OpCode (uae_u32 opcode)
1524: {
1525: unsigned short int call_idx;
1526: unsigned long Params;
1527:
1528: Params = Regs[REG_A7];
1529: Params -= SIZE_WORD;
1530:
1531: m68k_incpc (2);
1532: call_idx = STMemory_ReadWord(m68k_getpc());
1533:
1534: (hostcalls [call_idx]) (Params);
1535:
1536: m68k_incpc (2);
1537: fill_prefetch_0 ();
1538: return 4;
1539: }
1540:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.