![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gemdos.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to gemdos.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 ! root 1: /* ! 2: Hatari ! 3: ! 4: GEMDos intercept routines. These are used mainly for Hard Drive redirection of high level ! 5: file routines. ! 6: */ ! 7: ! 8: #include <sys/types.h> ! 9: #include <sys/stat.h> ! 10: #include <fcntl.h> ! 11: ! 12: #include "main.h" ! 13: #include "cart.h" ! 14: #include "debug.h" ! 15: #include "decode.h" ! 16: #include "dialog.h" ! 17: #include "file.h" ! 18: #include "floppy.h" ! 19: #include "gemdos.h" ! 20: #include "m68000.h" ! 21: #include "memAlloc.h" ! 22: #include "memorySnapShot.h" ! 23: #include "misc.h" ! 24: #include "printer.h" ! 25: #include "rs232.h" ! 26: #include "statusBar.h" ! 27: #include "stMemory.h" ! 28: #include "view.h" ! 29: ! 30: #define ENABLE_SAVING /* Turn on saving stuff */ ! 31: ! 32: #define INVALID_HANDLE_VALUE -1 ! 33: ! 34: #ifndef MAX_PATH ! 35: #define MAX_PATH 256 ! 36: #endif ! 37: ! 38: typedef struct ! 39: { ! 40: BOOL bUsed; ! 41: int FileHandle; ! 42: } FILE_HANDLE; ! 43: ! 44: FILE_HANDLE FileHandles[MAX_FILE_HANDLES]; ! 45: //INTERNAL_DTA InternalDTAs[MAX_DTAS_FILES]; ! 46: int DTAIndex; /* Circular index into above */ ! 47: BOOL bInitGemDOS; /* Have we re-directed GemDOS vector to our own routines yet? */ ! 48: DTA *pDTA; /* Our GEMDOS hard drive Disc Transfer Address structure */ ! 49: unsigned short int CurrentDrive; /* Current drive (0=A,1=B,2=C etc...) */ ! 50: ! 51: #ifdef DEBUG_TO_FILE ! 52: /* List of GEMDos functions... */ ! 53: char *pszGemDOSNames[] = { ! 54: "Term", //0x00 ! 55: "Conin", //0x01 ! 56: "ConOut", //0x02 ! 57: "Auxiliary Input", //0x03 ! 58: "Auxiliary Output", //0x04 ! 59: "Printer Output", //0x05 ! 60: "RawConIO", //0x06 ! 61: "Direct Conin no echo", //0x07 ! 62: "Conin no echo", //0x08 ! 63: "Print line", //0x09 ! 64: "ReadLine", //0x0a ! 65: "ConStat", //0x0b ! 66: "", //0x0c ! 67: "", //0x0d ! 68: "SetDrv", //0x0e ! 69: "", //0x0f ! 70: "Conout Stat", //0x10 ! 71: "PrtOut Stat", //0x11 ! 72: "Auxin Stat", //0x12 ! 73: "AuxOut Stat", //0x13 ! 74: "", //0x14 ! 75: "", //0x15 ! 76: "", //0x16 ! 77: "", //0x17 ! 78: "", //0x18 ! 79: "Current Disk", //0x19 ! 80: "Set DTA", //0x1a ! 81: "", //0x1b ! 82: "", //0x1c ! 83: "", //0x1d ! 84: "", //0x1e ! 85: "", //0x1f ! 86: "Super", //0x20 ! 87: "", //0x21 ! 88: "", //0x22 ! 89: "", //0x23 ! 90: "", //0x24 ! 91: "", //0x25 ! 92: "", //0x26 ! 93: "", //0x27 ! 94: "", //0x28 ! 95: "", //0x29 ! 96: "Get Date", //0x2a ! 97: "Set Date", //0x2b ! 98: "Get Time", //0x2c ! 99: "Set Time", //0x2d ! 100: "", //0x2e ! 101: "Get DTA", //0x2f ! 102: "Get Version Number", //0x30 ! 103: "Keep Process", //0x31 ! 104: "", //0x32 ! 105: "", //0x33 ! 106: "", //0x34 ! 107: "", //0x35 ! 108: "Get Disk Free Space", //0x36 ! 109: "", //0x37 ! 110: "", //0x38 ! 111: "MkDir", //0x39 ! 112: "RmDir", //0x3a ! 113: "ChDir", //0x3b ! 114: "Create", //0x3c ! 115: "Open", //0x3d ! 116: "Close", //0x3e ! 117: "Read", //0x3f ! 118: "Write", //0x40 ! 119: "UnLink", //0x41 ! 120: "LSeek", //0x42 ! 121: "ChMod", //0x43 ! 122: "", //0x44 ! 123: "Dup", //0x45 ! 124: "Force", //0x46 ! 125: "GetDir", //0x47 ! 126: "Malloc", //0x48 ! 127: "MFree", //0x49 ! 128: "SetBlock", //0x4a ! 129: "Exec", //0x4b ! 130: "Term", //0x4c ! 131: "", //0x4d ! 132: "SFirst", //0x4e ! 133: "SNext", //0x4f ! 134: "", //0x50 ! 135: "", //0x51 ! 136: "", //0x52 ! 137: "", //0x53 ! 138: "", //0x54 ! 139: "", //0x55 ! 140: "Rename", //0x56 ! 141: "GSDTof" //0x57 ! 142: }; ! 143: #endif ! 144: ! 145: ! 146: ! 147: /* Convert a string to uppercase */ ! 148: void strupr(char *string) ! 149: { ! 150: int i; ! 151: for(i=0; i<strlen(string); i++) ! 152: string[i] = toupper(string[i]); ! 153: } ! 154: ! 155: ! 156: //----------------------------------------------------------------------- ! 157: /* ! 158: Initialize GemDOS/PC file system ! 159: */ ! 160: void GemDOS_Init(void) ! 161: { ! 162: // Clear handles structure ! 163: Memory_Clear(FileHandles,sizeof(FILE_HANDLE)*MAX_FILE_HANDLES); ! 164: } ! 165: ! 166: //----------------------------------------------------------------------- ! 167: /* ! 168: Reset GemDOS file system ! 169: */ ! 170: void GemDOS_Reset(void) ! 171: { ! 172: int i; ! 173: ! 174: // Init file handles table ! 175: for(i=0; i<MAX_FILE_HANDLES; i++) { ! 176: // Was file open? If so close it ! 177: if (FileHandles[i].bUsed) ! 178: close(FileHandles[i].FileHandle); ! 179: ! 180: FileHandles[i].FileHandle = INVALID_HANDLE_VALUE; ! 181: FileHandles[i].bUsed = FALSE; ! 182: } ! 183: ! 184: // Reset ! 185: bInitGemDOS = FALSE; ! 186: CurrentDrive = nBootDrive; ! 187: pDTA = NULL; ! 188: DTAIndex = 0; ! 189: } ! 190: ! 191: //----------------------------------------------------------------------- ! 192: /* ! 193: Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type) ! 194: */ ! 195: void GemDOS_MemorySnapShot_Capture(BOOL bSave) ! 196: { ! 197: unsigned int Addr; ! 198: int i; ! 199: ! 200: // Save/Restore details ! 201: MemorySnapShot_Store(&DTAIndex,sizeof(DTAIndex)); ! 202: MemorySnapShot_Store(&bInitGemDOS,sizeof(bInitGemDOS)); ! 203: if (bSave) { ! 204: Addr = (unsigned int)pDTA-(unsigned int)STRam; ! 205: MemorySnapShot_Store(&Addr,sizeof(Addr)); ! 206: } ! 207: else { ! 208: MemorySnapShot_Store(&Addr,sizeof(Addr)); ! 209: pDTA = (DTA *)((unsigned int)STRam+(unsigned int)Addr); ! 210: } ! 211: MemorySnapShot_Store(&CurrentDrive,sizeof(CurrentDrive)); ! 212: // Don't save file handles as files may have changed which makes ! 213: // it impossible to get a valid handle back ! 214: if (!bSave) { ! 215: // Clear file handles ! 216: for(i=0; i<MAX_FILE_HANDLES; i++) { ! 217: FileHandles[i].FileHandle = INVALID_HANDLE_VALUE; ! 218: FileHandles[i].bUsed = FALSE; ! 219: } ! 220: // And DTAs ! 221: /*FIXME*/ ! 222: /* for(i=0; i<MAX_DTAS_FILES; i++) { ! 223: InternalDTAs[i].FileHandle = INVALID_HANDLE_VALUE; ! 224: memset(&InternalDTAs[i].FindFileData,0x0,sizeof(WIN32_FIND_DATA)); ! 225: } ! 226: */ ! 227: } ! 228: } ! 229: ! 230: //----------------------------------------------------------------------- ! 231: /* ! 232: Return free PC file handle table index, or -1 if error ! 233: */ ! 234: int GemDOS_FindFreeFileHandle(void) ! 235: { ! 236: int i; ! 237: ! 238: /* Scan our file list for free slot */ ! 239: for(i=0; i<MAX_FILE_HANDLES; i++) { ! 240: if (!FileHandles[i].bUsed) ! 241: return(i); ! 242: } ! 243: ! 244: /* Cannot open any more files, return error */ ! 245: return(-1); ! 246: } ! 247: ! 248: //----------------------------------------------------------------------- ! 249: /* ! 250: Check ST handle is within our table range, return TRUE if not ! 251: */ ! 252: BOOL GemDOS_IsInvalidFileHandle(int Handle) ! 253: { ! 254: BOOL bInvalidHandle=FALSE; ! 255: ! 256: /* Check handle was valid with our handle table */ ! 257: if ( (Handle<0) || (Handle>=MAX_FILE_HANDLES) ) ! 258: bInvalidHandle = TRUE; ! 259: else if (!FileHandles[Handle].bUsed) ! 260: bInvalidHandle = TRUE; ! 261: ! 262: return(bInvalidHandle); ! 263: } ! 264: ! 265: //----------------------------------------------------------------------- ! 266: /* ! 267: Find drive letter from a filename, eg C,D... and return as drive ID(C:2, D:3...) ! 268: */ ! 269: int GemDOS_FindDriveNumber(char *pszFileName) ! 270: { ! 271: /* Does have 'A:' or 'C:' etc.. at start of string? */ ! 272: if ( (pszFileName[0]!='\0') && (pszFileName[1]==':') ) { ! 273: if ( (pszFileName[0]>='a') && (pszFileName[0]<='z') ) ! 274: return(pszFileName[0]-'a'); ! 275: else if ( (pszFileName[0]>='A') && (pszFileName[0]<='Z') ) ! 276: return(pszFileName[0]-'A'); ! 277: } ! 278: ! 279: return(CurrentDrive); ! 280: } ! 281: ! 282: //----------------------------------------------------------------------- ! 283: /* ! 284: Return drive ID(C:2, D:3 etc...) or -1 if not one of our emulation hard-drives ! 285: */ ! 286: int GemDOS_IsFileNameAHardDrive(char *pszFileName) ! 287: { ! 288: int DriveLetter; ! 289: ! 290: /* Do we even have a hard-drive? */ ! 291: if (ConfigureParams.HardDisc.nDriveList!=DRIVELIST_NONE) { ! 292: // Find drive letter(as number) ! 293: DriveLetter = GemDOS_FindDriveNumber(pszFileName); ! 294: // Does match one of our drives? ! 295: if ( (DriveLetter>=2) && (DriveLetter<=DRIVELIST_TO_DRIVE_INDEX(ConfigureParams.HardDisc.nDriveList)) ) ! 296: return(DriveLetter); ! 297: } ! 298: ! 299: // No, let TOS handle it ! 300: return(-1); ! 301: } ! 302: ! 303: //----------------------------------------------------------------------- ! 304: /* ! 305: Use hard-drive directory, current ST directory and filename to create full path ! 306: */ ! 307: void GemDOS_CreateHardDriveFileName(int Drive,char *pszFileName,char *pszDestName) ! 308: { ! 309: int DirIndex = Misc_LimitInt(Drive-2, 0,ConfigureParams.HardDisc.nDriveList-1); ! 310: // debug << "::" << pszFileName << endl; ! 311: /* Combine names */ ! 312: if (File_IsRootFileName(pszFileName)) ! 313: sprintf(pszDestName,"%s%s",ConfigureParams.HardDisc.szHardDiscDirectories[DirIndex],File_RemoveFileNameDrive(pszFileName)); ! 314: else { ! 315: if (File_DoesFileNameEndWithSlash(szCurrentDir)) ! 316: sprintf(pszDestName,"%s%s%s",ConfigureParams.HardDisc.szHardDiscDirectories[DirIndex],File_RemoveFileNameDrive(szCurrentDir),File_RemoveFileNameDrive(pszFileName)); ! 317: else ! 318: sprintf(pszDestName,"%s%s/%s",ConfigureParams.HardDisc.szHardDiscDirectories[DirIndex],File_RemoveFileNameDrive(szCurrentDir),File_RemoveFileNameDrive(pszFileName)); ! 319: } ! 320: // Remove any '/'s at end of filenames ! 321: File_RemoveFileNameTrailingSlashes(pszDestName); ! 322: ! 323: // And make all upper case, as original ST ! 324: strupr(pszDestName); ! 325: // debug << "\t" << pszDestName << endl; ! 326: } ! 327: ! 328: //----------------------------------------------------------------------- ! 329: /* ! 330: Covert from FindFirstFile/FindNextFile attribute to GemDOS format ! 331: */ ! 332: char GemDOS_ConvertAttribute(int dwFileAttributes) ! 333: { ! 334: char Attrib=0; ! 335: /* FIXME */ ! 336: /* ! 337: // Look up attributes ! 338: if (dwFileAttributes&FILE_ATTRIBUTE_READONLY) ! 339: Attrib |= GEMDOS_FILE_ATTRIB_READONLY; ! 340: if (dwFileAttributes&FILE_ATTRIBUTE_HIDDEN) ! 341: Attrib |= GEMDOS_FILE_ATTRIB_HIDDEN; ! 342: if (dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) ! 343: Attrib |= GEMDOS_FILE_ATTRIB_SUBDIRECTORY; ! 344: */ ! 345: return(Attrib); ! 346: } ! 347: ! 348: //----------------------------------------------------------------------- ! 349: /* ! 350: GEMDOS Cauxin ! 351: Call 0x3 ! 352: */ ! 353: BOOL GemDOS_Cauxin(unsigned long Params) ! 354: { ! 355: unsigned char Char; ! 356: ! 357: // Wait here until a character is ready ! 358: while(!RS232_GetStatus()); ! 359: ! 360: // And read character ! 361: RS232_ReadBytes(&Char,1); ! 362: Regs[REG_D0] = Char; ! 363: ! 364: return(TRUE); ! 365: } ! 366: ! 367: //----------------------------------------------------------------------- ! 368: /* ! 369: GEMDOS Cauxout ! 370: Call 0x4 ! 371: */ ! 372: BOOL GemDOS_Cauxout(unsigned long Params) ! 373: { ! 374: unsigned char Char; ! 375: ! 376: // Send character to RS232 ! 377: Char = STMemory_ReadWord(Params+SIZE_WORD); ! 378: RS232_TransferBytesTo(&Char,1); ! 379: ! 380: return(TRUE); ! 381: } ! 382: ! 383: //----------------------------------------------------------------------- ! 384: /* ! 385: GEMDOS Cprnout ! 386: Call 0x5 ! 387: */ ! 388: BOOL GemDOS_Cprnout(unsigned long Params) ! 389: { ! 390: unsigned char Char; ! 391: ! 392: // Send character to printer(or file) ! 393: Char = STMemory_ReadWord(Params+SIZE_WORD); ! 394: Printer_TransferByteTo(Char); ! 395: Regs[REG_D0] = -1; // Printer OK ! 396: ! 397: return(TRUE); ! 398: } ! 399: ! 400: //----------------------------------------------------------------------- ! 401: /* ! 402: GEMDOS Set drive (0=A,1=B,2=C etc...) ! 403: Call 0xE ! 404: */ ! 405: BOOL GemDOS_SetDrv(unsigned long Params) ! 406: { ! 407: // Read details from stack for our own use ! 408: CurrentDrive = STMemory_ReadWord(Params+SIZE_WORD); ! 409: // debug << "CurrentDrive: " << CurrentDrive << endl; ! 410: ! 411: // Still re-direct to TOS ! 412: return(FALSE); ! 413: } ! 414: ! 415: //----------------------------------------------------------------------- ! 416: /* ! 417: GEMDOS Cprnos ! 418: Call 0x11 ! 419: */ ! 420: BOOL GemDOS_Cprnos(unsigned long Params) ! 421: { ! 422: Regs[REG_D0] = -1; // Printer OK ! 423: ! 424: return(TRUE); ! 425: } ! 426: ! 427: //----------------------------------------------------------------------- ! 428: /* ! 429: GEMDOS Cauxis ! 430: Call 0x12 ! 431: */ ! 432: BOOL GemDOS_Cauxis(unsigned long Params) ! 433: { ! 434: // Read our RS232 state ! 435: if (RS232_GetStatus()) ! 436: Regs[REG_D0] = -1; // Chars waiting ! 437: else ! 438: Regs[REG_D0] = 0; ! 439: ! 440: return(TRUE); ! 441: } ! 442: ! 443: //----------------------------------------------------------------------- ! 444: /* ! 445: GEMDOS Cauxos ! 446: Call 0x13 ! 447: */ ! 448: BOOL GemDOS_Cauxos(unsigned long Params) ! 449: { ! 450: Regs[REG_D0] = -1; // Device ready ! 451: ! 452: return(TRUE); ! 453: } ! 454: ! 455: //----------------------------------------------------------------------- ! 456: /* ! 457: GEMDOS Set Disc Transfer Address (DTA) ! 458: Call 0x1A ! 459: */ ! 460: BOOL GemDOS_SetDTA(unsigned long Params) ! 461: { ! 462: // Look up on stack to find where DTA is! Store as PC pointer ! 463: pDTA = (DTA *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 464: ! 465: // char szString[256]; ! 466: // sprintf(szString,"0x%X",STMemory_ReadLong(Params+SIZE_WORD)); ! 467: // debug << " to " << szString << endl; ! 468: ! 469: // Still re-direct to TOS ! 470: return(FALSE); ! 471: } ! 472: ! 473: //----------------------------------------------------------------------- ! 474: /* ! 475: GEMDOS MkDir ! 476: Call 0x39 ! 477: */ ! 478: BOOL GemDOS_MkDir(unsigned long Params) ! 479: { ! 480: char szDirPath[MAX_PATH]; ! 481: char *pDirName; ! 482: int Drive; ! 483: ! 484: // Find directory to make ! 485: pDirName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 486: // debug << pDirName << endl; ! 487: Drive = GemDOS_IsFileNameAHardDrive(pDirName); ! 488: // debug << Drive << endl; ! 489: if (ISHARDDRIVE(Drive)) { ! 490: // Copy old directory, as if calls fails keep this one ! 491: GemDOS_CreateHardDriveFileName(Drive,pDirName,szDirPath); ! 492: ! 493: // Attempt to make directory ! 494: if ( mkdir(szDirPath, 0755)==0 ) ! 495: Regs[REG_D0] = GEMDOS_EOK; ! 496: else ! 497: Regs[REG_D0] = GEMDOS_EACCDN; // Access denied ! 498: ! 499: return(TRUE); ! 500: } ! 501: return(FALSE); ! 502: } ! 503: ! 504: //----------------------------------------------------------------------- ! 505: /* ! 506: GEMDOS RmDir ! 507: Call 0x3A ! 508: */ ! 509: BOOL GemDOS_RmDir(unsigned long Params) ! 510: { ! 511: char szDirPath[MAX_PATH]; ! 512: char *pDirName; ! 513: int Drive; ! 514: ! 515: // Find directory to make ! 516: pDirName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 517: Drive = GemDOS_IsFileNameAHardDrive(pDirName); ! 518: if (ISHARDDRIVE(Drive)) { ! 519: // Copy old directory, as if calls fails keep this one ! 520: GemDOS_CreateHardDriveFileName(Drive,pDirName,szDirPath); ! 521: ! 522: // Attempt to make directory ! 523: if ( rmdir(szDirPath)==0 ) ! 524: Regs[REG_D0] = GEMDOS_EOK; ! 525: else ! 526: Regs[REG_D0] = GEMDOS_EACCDN; // Access denied ! 527: ! 528: return(TRUE); ! 529: } ! 530: return(FALSE); ! 531: } ! 532: ! 533: //----------------------------------------------------------------------- ! 534: /* ! 535: GEMDOS ChDir ! 536: Call 0x3B ! 537: */ ! 538: BOOL GemDOS_ChDir(unsigned long Params) ! 539: { ! 540: char szDirPath[MAX_PATH]; ! 541: char *pDirName; ! 542: int Drive; ! 543: ! 544: // Find new directory ! 545: pDirName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 546: // debug << pDirName << endl; ! 547: Drive = GemDOS_IsFileNameAHardDrive(pDirName); ! 548: if (ISHARDDRIVE(Drive)) { ! 549: // Check path exists, else error ! 550: GemDOS_CreateHardDriveFileName(Drive,"",szDirPath); ! 551: ! 552: if ( chdir(szDirPath)==0 ) { ! 553: strcpy(szCurrentDir,pDirName); ! 554: Regs[REG_D0] = GEMDOS_EOK; ! 555: } ! 556: else ! 557: Regs[REG_D0] = GEMDOS_EPTHNF; // Path not found ! 558: ! 559: return(TRUE); ! 560: } ! 561: ! 562: return(FALSE); ! 563: } ! 564: ! 565: //----------------------------------------------------------------------- ! 566: /* ! 567: GEMDOS Create file ! 568: Call 0x3C ! 569: */ ! 570: BOOL GemDOS_Create(unsigned long Params) ! 571: { ! 572: char szActualFileName[MAX_PATH]; ! 573: char *pszFileName; ! 574: unsigned int Access; ! 575: int Drive,Index,Mode; ! 576: ! 577: // Find filename ! 578: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 579: Mode = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG); ! 580: Drive = GemDOS_IsFileNameAHardDrive(pszFileName); ! 581: if (ISHARDDRIVE(Drive)) { ! 582: // And convert to hard drive filename ! 583: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName); ! 584: ! 585: // Find slot to store file handle, as need to return WORD handle for ST (NOTE PC's Window handles are all LONGS) ! 586: Index = GemDOS_FindFreeFileHandle(); ! 587: if (Index==-1) { ! 588: // No free handles, return error code ! 589: Regs[REG_D0] = GEMDOS_ENHNDL; // No more handles ! 590: return(TRUE); ! 591: } ! 592: else { ! 593: #ifdef ENABLE_SAVING ! 594: // Select mode ! 595: switch(Mode&0x01) { // Top bits used in some TOSes ! 596: case 0: // Read/Write ! 597: //FIXME Access = GENERIC_READ|GENERIC_WRITE; ! 598: break; ! 599: case 1: // Write only ! 600: //FIXME Access = GENERIC_WRITE; ! 601: break; ! 602: } ! 603: ! 604: //FIXME FileHandles[Index].FileHandle = CreateFile(szActualFileName,Access,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL); ! 605: if (FileHandles[Index].FileHandle!=INVALID_HANDLE_VALUE) { ! 606: /* Tag handle table entry as used and return handle */ ! 607: FileHandles[Index].bUsed = TRUE; ! 608: Regs[REG_D0] = Index+BASE_FILEHANDLE; // Return valid ST file handle from range 6 to 45! (ours start from 0) ! 609: ! 610: return(TRUE); ! 611: } ! 612: else { ! 613: Regs[REG_D0] = GEMDOS_EFILNF; // File not found ! 614: return(TRUE); ! 615: } ! 616: #else ! 617: Regs[REG_D0] = GEMDOS_EFILNF; // File not found ! 618: return(TRUE); ! 619: #endif ! 620: } ! 621: } ! 622: ! 623: return(FALSE); ! 624: } ! 625: ! 626: //----------------------------------------------------------------------- ! 627: /* ! 628: GEMDOS Open file ! 629: Call 0x3D ! 630: */ ! 631: BOOL GemDOS_Open(unsigned long Params) ! 632: { ! 633: char szActualFileName[MAX_PATH]; ! 634: char *pszFileName; ! 635: unsigned int Access; ! 636: int Drive,Index,Mode; ! 637: ! 638: // Find filename ! 639: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 640: Mode = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG); ! 641: Drive = GemDOS_IsFileNameAHardDrive(pszFileName); ! 642: // Debug_File("Open %s\n",pszFileName); ! 643: if (ISHARDDRIVE(Drive)) { ! 644: // And convert to hard drive filename ! 645: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName); ! 646: ! 647: // Find slot to store file handle, as need to return WORD handle for ST (NOTE PC's Window handles are all LONGS) ! 648: Index = GemDOS_FindFreeFileHandle(); ! 649: if (Index==-1) { ! 650: // No free handles, return error code ! 651: Regs[REG_D0] = GEMDOS_ENHNDL; // No more handles ! 652: return(TRUE); ! 653: } ! 654: else { ! 655: // Select mode ! 656: switch(Mode&0x03) { // Top bits used in some TOSes ! 657: case 0: // Read only ! 658: //FIXME Access = GENERIC_READ; ! 659: break; ! 660: case 1: // Write only ! 661: //FIXME Access = GENERIC_WRITE; ! 662: break; ! 663: case 2: // Read/Write ! 664: //FIXME Access = GENERIC_READ|GENERIC_WRITE; ! 665: break; ! 666: } ! 667: ! 668: // Open file ! 669: //FIXME FileHandles[Index].FileHandle = CreateFile(szActualFileName,Access,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL); ! 670: if (FileHandles[Index].FileHandle!=INVALID_HANDLE_VALUE) { ! 671: // Tag handle table entry as used and return handle ! 672: FileHandles[Index].bUsed = TRUE; ! 673: Regs[REG_D0] = Index+BASE_FILEHANDLE; // Return valid ST file handle from range 6 to 45! (ours start from 0) ! 674: ! 675: return(TRUE); ! 676: } ! 677: else { ! 678: Regs[REG_D0] = GEMDOS_EFILNF; // File not found ! 679: return(TRUE); ! 680: } ! 681: } ! 682: } ! 683: ! 684: return(FALSE); ! 685: } ! 686: ! 687: //----------------------------------------------------------------------- ! 688: /* ! 689: GEMDOS Close file ! 690: Call 0x3E ! 691: */ ! 692: BOOL GemDOS_Close(unsigned long Params) ! 693: { ! 694: int Handle; ! 695: ! 696: // Find our handle - may belong to TOS ! 697: Handle = STMemory_ReadWord(Params+SIZE_WORD)-BASE_FILEHANDLE; ! 698: ! 699: // Check handle was valid ! 700: if (GemDOS_IsInvalidFileHandle(Handle)) { ! 701: // No assume was TOS ! 702: return(FALSE); ! 703: } ! 704: else { ! 705: // Close file and free up handle table ! 706: close(FileHandles[Handle].FileHandle); ! 707: FileHandles[Handle].bUsed = FALSE; ! 708: // Return no error ! 709: Regs[REG_D0] = GEMDOS_EOK; ! 710: return(TRUE); ! 711: } ! 712: } ! 713: ! 714: //----------------------------------------------------------------------- ! 715: /* ! 716: GEMDOS Read file ! 717: Call 0x3F ! 718: */ ! 719: BOOL GemDOS_Read(unsigned long Params) ! 720: { ! 721: char *pBuffer; ! 722: unsigned long nBytesRead,Size,CurrentPos,FileSize,nBytesLeft; ! 723: int Handle; ! 724: ! 725: // Read details from stack ! 726: Handle = STMemory_ReadWord(Params+SIZE_WORD)-BASE_FILEHANDLE; ! 727: Size = STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD); ! 728: pBuffer = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD+SIZE_LONG)); ! 729: ! 730: // Check handle was valid ! 731: if (GemDOS_IsInvalidFileHandle(Handle)) { ! 732: // No assume was TOS ! 733: return(FALSE); ! 734: } ! 735: else { ! 736: StatusBar_SetIcon(STATUS_ICON_HARDDRIVE,ICONSTATE_UPDATE); ! 737: ! 738: // To quick check to see where our file pointer is and how large the file is ! 739: CurrentPos = lseek(FileHandles[Handle].FileHandle, 0, SEEK_CUR); ! 740: FileSize = lseek(FileHandles[Handle].FileHandle, 0, SEEK_END); ! 741: lseek(FileHandles[Handle].FileHandle, CurrentPos, SEEK_SET); ! 742: ! 743: nBytesLeft = FileSize-CurrentPos; ! 744: ! 745: // Check for End Of File ! 746: if (nBytesLeft<0) { ! 747: Regs[REG_D0] = GEMDOS_ERROR; ! 748: ! 749: return(TRUE); ! 750: } ! 751: else { ! 752: // Limit to size of file to prevent windows error ! 753: if (Size>FileSize) ! 754: Size = FileSize; ! 755: // And read data in ! 756: nBytesRead = read(FileHandles[Handle].FileHandle, pBuffer, Size); ! 757: //??? FlushFileBuffers(FileHandles[Handle].FileHandle); ! 758: ! 759: // Return number of bytes read ! 760: Regs[REG_D0] = nBytesRead; ! 761: ! 762: return(TRUE); ! 763: } ! 764: } ! 765: } ! 766: ! 767: //----------------------------------------------------------------------- ! 768: /* ! 769: GEMDOS Write file ! 770: Call 0x40 ! 771: */ ! 772: BOOL GemDOS_Write(unsigned long Params) ! 773: { ! 774: char *pBuffer; ! 775: unsigned long Size,nBytesWritten; ! 776: int Handle; ! 777: ! 778: #ifdef ENABLE_SAVING ! 779: // Read details from stack ! 780: Handle = STMemory_ReadWord(Params+SIZE_WORD)-BASE_FILEHANDLE; ! 781: Size = STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD); ! 782: pBuffer = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD+SIZE_LONG)); ! 783: ! 784: // Check handle was valid ! 785: if (GemDOS_IsInvalidFileHandle(Handle)) { ! 786: // No assume was TOS ! 787: return(FALSE); ! 788: } ! 789: else { ! 790: StatusBar_SetIcon(STATUS_ICON_HARDDRIVE,ICONSTATE_UPDATE); ! 791: ! 792: nBytesWritten = write(FileHandles[Handle].FileHandle, pBuffer, Size); ! 793: if (nBytesWritten>=0) { ! 794: //??? FlushFileBuffers(FileHandles[Handle].FileHandle); ! 795: ! 796: Regs[REG_D0] = nBytesWritten; // OK ! 797: } ! 798: else ! 799: Regs[REG_D0] = GEMDOS_EACCDN; // Access denied(ie read-only) ! 800: ! 801: return(TRUE); ! 802: } ! 803: #endif ! 804: ! 805: return(FALSE); ! 806: } ! 807: ! 808: //----------------------------------------------------------------------- ! 809: /* ! 810: GEMDOS UnLink(Delete) file ! 811: Call 0x41 ! 812: */ ! 813: BOOL GemDOS_UnLink(unsigned long Params) ! 814: { ! 815: #ifdef ENABLE_SAVING ! 816: char szActualFileName[MAX_PATH]; ! 817: char *pszFileName; ! 818: int Drive; ! 819: ! 820: // Find filename ! 821: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 822: Drive = GemDOS_IsFileNameAHardDrive(pszFileName); ! 823: if (ISHARDDRIVE(Drive)) { ! 824: // And convert to hard drive filename ! 825: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName); ! 826: ! 827: // Now delete file?? ! 828: if ( unlink(szActualFileName)==0 ) ! 829: Regs[REG_D0] = GEMDOS_EOK; // OK ! 830: else ! 831: Regs[REG_D0] = GEMDOS_EFILNF; // File not found ! 832: ! 833: return(TRUE); ! 834: } ! 835: #endif ! 836: ! 837: return(FALSE); ! 838: } ! 839: ! 840: //----------------------------------------------------------------------- ! 841: /* ! 842: GEMDOS File seek ! 843: Call 0x42 ! 844: */ ! 845: BOOL GemDOS_LSeek(unsigned long Params) ! 846: { ! 847: long Offset; ! 848: int Handle,Mode; ! 849: ! 850: // Read details from stack ! 851: Offset = (long)STMemory_ReadLong(Params+SIZE_WORD); ! 852: Handle = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG)-BASE_FILEHANDLE; ! 853: Mode = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG+SIZE_WORD); ! 854: ! 855: // Check handle was valid ! 856: if (GemDOS_IsInvalidFileHandle(Handle)) { ! 857: // No assume was TOS ! 858: return(FALSE); ! 859: } ! 860: else { ! 861: // Return offset from start of file ! 862: Regs[REG_D0] = lseek(FileHandles[Handle].FileHandle, Offset, Mode); ! 863: return(TRUE); ! 864: } ! 865: } ! 866: ! 867: //----------------------------------------------------------------------- ! 868: /* ! 869: PExec Load And Go - Redirect to cart' routine at address 0xFA1000 ! 870: ! 871: If loading from hard-drive(ie drive ID 2 or more) set condition codes to run own GEMDos routines ! 872: */ ! 873: void GemDOS_Pexec_LoadAndGo(unsigned long Params) ! 874: { ! 875: // Hard-drive? ! 876: if (CurrentDrive>=2) // If not using A: or B:, use my own routines to load ! 877: SR = (SR&0xff00) | SR_OVERFLOW; ! 878: } ! 879: ! 880: //----------------------------------------------------------------------- ! 881: /* ! 882: PExec Load But Don't Go - Redirect to cart' routine at address 0xFA1000 ! 883: */ ! 884: void GemDOS_Pexec_LoadDontGo(unsigned long Params) ! 885: { ! 886: // Hard-drive? ! 887: if (CurrentDrive>=2) ! 888: SR = (SR&0xff00) | SR_OVERFLOW; ! 889: } ! 890: ! 891: //----------------------------------------------------------------------- ! 892: /* ! 893: GEMDOS PExec handler ! 894: Call 0x4B ! 895: */ ! 896: BOOL GemDOS_Pexec(unsigned long Params) ! 897: { ! 898: unsigned short int Mode; ! 899: ! 900: // Find PExec mode ! 901: Mode = STMemory_ReadWord(Params+SIZE_WORD); ! 902: // Debug_File("Pexec %d (Drv:%d)\n",Mode,CurrentDrive); ! 903: ! 904: // Re-direct as needed ! 905: switch(Mode) { ! 906: case 0: // Load and go ! 907: GemDOS_Pexec_LoadAndGo(Params); ! 908: return(FALSE); ! 909: case 3: // Load, don't go ! 910: GemDOS_Pexec_LoadDontGo(Params); ! 911: return(FALSE); ! 912: case 4: // Just go ! 913: return(FALSE); ! 914: case 5: // Create basepage ! 915: return(FALSE); ! 916: case 6: ! 917: return(FALSE); ! 918: ! 919: default: ! 920: return(FALSE); ! 921: } ! 922: ! 923: // Still re-direct to TOS ! 924: return(FALSE); ! 925: } ! 926: ! 927: //----------------------------------------------------------------------- ! 928: /* ! 929: GEMDOS Find first file ! 930: Call 0x4E ! 931: */ ! 932: BOOL GemDOS_SFirst(unsigned long Params) ! 933: { ! 934: int FatDate, FatTime; ! 935: char szActualFileName[MAX_PATH]; ! 936: char *pszFileName; ! 937: unsigned short int Attr; ! 938: int Drive; ! 939: ! 940: // Find filename to search for ! 941: pszFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 942: Attr = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG); ! 943: // debug << "SFirst: " << pszFileName << endl; ! 944: // M68000_OutputHistory(); ! 945: ! 946: Drive = GemDOS_IsFileNameAHardDrive(pszFileName); ! 947: if (ISHARDDRIVE(Drive)) { ! 948: StatusBar_SetIcon(STATUS_ICON_HARDDRIVE,ICONSTATE_UPDATE); ! 949: ! 950: // And convert to hard drive filename ! 951: GemDOS_CreateHardDriveFileName(Drive,pszFileName,szActualFileName); ! 952: ! 953: // Populate DTA, set index for our use ! 954: STMemory_WriteWord_PCSpace(pDTA->index,DTAIndex); ! 955: STMemory_WriteLong_PCSpace(pDTA->magic,DTA_MAGIC_NUMBER); ! 956: strcpy(pDTA->dta_pat,""); ! 957: pDTA->dta_sattrib = 0; ! 958: pDTA->dta_attrib = 0; ! 959: ! 960: // Were we looking for the volume label? Read directly from drive ! 961: if (Attr&GEMDOS_FILE_ATTRIB_VOLUME_LABEL) { ! 962: // Default and find drive from filename ! 963: strcpy(pDTA->dta_name,""); ! 964: File_GetFileNameDrive(pszFileName); ! 965: //FIXME if (GetVolumeInformation(pszFileName,pDTA->dta_name,TOS_NAMELEN,NULL,NULL,NULL,NULL,0)) ! 966: // strupr(pDTA->dta_name); ! 967: Regs[REG_D0] = GEMDOS_EOK; // Got volume ! 968: return(TRUE); ! 969: } ! 970: ! 971: // Scan for first file ! 972: /* FIXME */ ! 973: /* ! 974: InternalDTAs[DTAIndex].FileHandle = FindFirstFile(szActualFileName,&InternalDTAs[DTAIndex].FindFileData); ! 975: if (InternalDTAs[DTAIndex].FileHandle==INVALID_HANDLE_VALUE) { ! 976: // No files of that match, return error code ! 977: Regs[REG_D0] = GEMDOS_EFILNF; // File not found ! 978: return(TRUE); ! 979: } ! 980: else { ! 981: // Repeat find until have useable filename! The PC returns '.' and '..' - ignore '.'! ! 982: while( !stricmp(InternalDTAs[DTAIndex].FindFileData.cFileName,".") ) { ! 983: if (FindNextFile(InternalDTAs[DTAIndex].FileHandle,&InternalDTAs[DTAIndex].FindFileData)==0) { ! 984: // If this is all there is, then error ! 985: Regs[REG_D0] = GEMDOS_ENMFIL; // No more files ! 986: return(TRUE); ! 987: } ! 988: } ! 989: ! 990: // And make all upper case, as original ST ! 991: strupr(InternalDTAs[DTAIndex].FindFileData.cFileName); ! 992: strcpy(pDTA->dta_name,InternalDTAs[DTAIndex].FindFileData.cFileName); ! 993: ! 994: // Fill remaining details, as PC ! 995: //FIXME STMemory_WriteLong_PCSpace(pDTA->dta_size,InternalDTAs[DTAIndex].FindFileData.nFileSizeLow); ! 996: //FIXME Misc_TimeDataToDos(&InternalDTAs[DTAIndex].FindFileData.ftLastWriteTime,&FatDate,&FatTime); ! 997: STMemory_WriteWord_PCSpace(pDTA->dta_time,FatTime); ! 998: STMemory_WriteWord_PCSpace(pDTA->dta_date,FatDate); ! 999: //FIXME pDTA->dta_attrib = GemDOS_ConvertAttribute(InternalDTAs[DTAIndex].FindFileData.dwFileAttributes); ! 1000: ! 1001: Regs[REG_D0] = GEMDOS_EOK; ! 1002: ! 1003: DTAIndex++; ! 1004: DTAIndex&=(MAX_DTAS_FILES-1); ! 1005: } ! 1006: return(TRUE); ! 1007: */ ! 1008: } ! 1009: return(FALSE); ! 1010: } ! 1011: ! 1012: //----------------------------------------------------------------------- ! 1013: /* ! 1014: GEMDOS Search Next ! 1015: Call 0x4F ! 1016: */ ! 1017: BOOL GemDOS_SNext(unsigned long Params) ! 1018: { ! 1019: int FatDate, FatTime; ! 1020: int DTAIndex; ! 1021: ! 1022: // Was DTA ours or TOS? ! 1023: if (STMemory_ReadLong_PCSpace(pDTA->magic)==DTA_MAGIC_NUMBER) { ! 1024: StatusBar_SetIcon(STATUS_ICON_HARDDRIVE,ICONSTATE_UPDATE); ! 1025: ! 1026: // Find index into our list of structures ! 1027: DTAIndex = STMemory_ReadWord_PCSpace(pDTA->index)&(MAX_DTAS_FILES-1); ! 1028: /*FIXME ! 1029: if (FindNextFile(InternalDTAs[DTAIndex].FileHandle,&InternalDTAs[DTAIndex].FindFileData)==0) { ! 1030: Regs[REG_D0] = GEMDOS_ENMFIL; // No more files ! 1031: return(TRUE); ! 1032: } ! 1033: // Find next file on hard drive ! 1034: else { ! 1035: // And make all upper case, as original ST ! 1036: strupr(InternalDTAs[DTAIndex].FindFileData.cFileName); ! 1037: strcpy(pDTA->dta_name,InternalDTAs[DTAIndex].FindFileData.cFileName); ! 1038: // Fill remaining details, as PC ! 1039: STMemory_WriteLong_PCSpace(pDTA->dta_size,InternalDTAs[DTAIndex].FindFileData.nFileSizeLow); ! 1040: Misc_TimeDataToDos(&InternalDTAs[DTAIndex].FindFileData.ftLastWriteTime,&FatDate,&FatTime); ! 1041: STMemory_WriteWord_PCSpace(pDTA->dta_time,FatTime); ! 1042: STMemory_WriteWord_PCSpace(pDTA->dta_date,FatDate); ! 1043: pDTA->dta_attrib = GemDOS_ConvertAttribute(InternalDTAs[DTAIndex].FindFileData.dwFileAttributes); ! 1044: ! 1045: Regs[REG_D0] = GEMDOS_EOK; ! 1046: return(TRUE); ! 1047: } ! 1048: */ ! 1049: } ! 1050: ! 1051: return(FALSE); ! 1052: } ! 1053: ! 1054: //----------------------------------------------------------------------- ! 1055: /* ! 1056: GEMDOS Rename ! 1057: Call 0x56 ! 1058: */ ! 1059: BOOL GemDOS_Rename(unsigned long Params) ! 1060: { ! 1061: char *pszNewFileName,*pszOldFileName; ! 1062: char szNewActualFileName[MAX_PATH],szOldActualFileName[MAX_PATH]; ! 1063: int NewDrive, OldDrive; ! 1064: ! 1065: // Read details from stack ! 1066: pszOldFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD)); ! 1067: pszNewFileName = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD+SIZE_WORD+SIZE_LONG)); ! 1068: ! 1069: NewDrive = GemDOS_IsFileNameAHardDrive(pszNewFileName); ! 1070: OldDrive = GemDOS_IsFileNameAHardDrive(pszOldFileName); ! 1071: if (ISHARDDRIVE(NewDrive) && ISHARDDRIVE(OldDrive)) { ! 1072: // And convert to hard drive filenames ! 1073: GemDOS_CreateHardDriveFileName(NewDrive,pszNewFileName,szNewActualFileName); ! 1074: GemDOS_CreateHardDriveFileName(OldDrive,pszOldFileName,szOldActualFileName); ! 1075: ! 1076: // Rename files ! 1077: if ( rename(szOldActualFileName,szNewActualFileName)==0 ) ! 1078: Regs[REG_D0] = GEMDOS_EOK; ! 1079: else ! 1080: Regs[REG_D0] = GEMDOS_EACCDN; // Access denied ! 1081: return(TRUE); ! 1082: } ! 1083: ! 1084: return(FALSE); ! 1085: } ! 1086: ! 1087: //----------------------------------------------------------------------- ! 1088: /* ! 1089: GEMDOS GSDToF ! 1090: Call 0x57 ! 1091: */ ! 1092: BOOL GemDOS_GSDToF(unsigned long Params) ! 1093: { ! 1094: /*FIXME*/ ! 1095: /* ! 1096: BY_HANDLE_FILE_INFORMATION FileInfo; ! 1097: WORD FatDate,FatTime; ! 1098: DATETIME DateTime; ! 1099: char *pBuffer; ! 1100: int Handle,Flag; ! 1101: ! 1102: // Read details from stack ! 1103: pBuffer = (char *)STRAM_ADDR(STMemory_ReadLong(Params+SIZE_WORD)); ! 1104: Handle = STMemory_ReadWord(Params+SIZE_WORD+SIZE_LONG)-BASE_FILEHANDLE; ! 1105: Flag = STMemory_ReadWord(Params+SIZE_WORD+SIZE_WORD+SIZE_LONG); ! 1106: ! 1107: // Check handle was valid ! 1108: if (GemDOS_IsInvalidFileHandle(Handle)) { ! 1109: // No assume was TOS ! 1110: return(FALSE); ! 1111: } ! 1112: else { ! 1113: Regs[REG_D0] = GEMDOS_ERROR; // Invalid parameter ! 1114: ! 1115: if (Flag==0) { // Read time ! 1116: if (GetFileInformationByHandle(FileHandles[Handle].FileHandle,&FileInfo)) { ! 1117: if (FileTimeToDosDateTime(&FileInfo.ftCreationTime,&FatDate,&FatTime)) { ! 1118: DateTime.hour = FatTime>>11; ! 1119: DateTime.minute = FatTime>>5; ! 1120: DateTime.second = FatTime; ! 1121: DateTime.year = FatDate>>9; ! 1122: DateTime.month = FatDate>>5; ! 1123: DateTime.day = FatDate; ! 1124: ! 1125: Regs[REG_D0] = GEMDOS_EOK; ! 1126: } ! 1127: } ! 1128: } ! 1129: else if (Flag==1) { ! 1130: Regs[REG_D0] = GEMDOS_EOK; ! 1131: } ! 1132: ! 1133: return(TRUE); ! 1134: } ! 1135: */ ! 1136: return(FALSE); ! 1137: } ! 1138: ! 1139: //----------------------------------------------------------------------- ! 1140: /* ! 1141: This is called when we get a GemDOS exception. We then re-direct vector to our ! 1142: own routine. This forces execution through TOS which sets up the stack etc... and ! 1143: then calls our own routine in the cart' space which has the illegal instruction ! 1144: 'GEMDOS_OPCODE'. ! 1145: */ ! 1146: BOOL GemDOS(void) ! 1147: { ! 1148: unsigned long OldGemDOSVector; ! 1149: ! 1150: // Init Gemdos if not already ! 1151: if (!bInitGemDOS) { ! 1152: OldGemDOSVector = STMemory_ReadLong(0x84); ! 1153: STMemory_WriteLong(CART_OLDGEMDOS,OldGemDOSVector); // Store original gemdos handler ! 1154: STMemory_WriteLong(0x84,CART_GEMDOS); // And redirect to new one (see cart.s) ! 1155: ! 1156: bInitGemDOS = TRUE; ! 1157: } ! 1158: ! 1159: // Now execute as normal, we may intercept it again later (see cart.s) ! 1160: return(FALSE); ! 1161: } ! 1162: ! 1163: ! 1164: /*-----------------------------------------------------------------------*/ ! 1165: /* ! 1166: Run GEMDos call, and re-direct if need to. Used to handle hard-disc emulation etc... ! 1167: This sets the condition codes(in SR), which are used in the 'cart.s' program to decide if we ! 1168: need to run old GEM vector, or PExec or nothing. ! 1169: ! 1170: This method keeps the stack and other states consistant with the original ST which is very important ! 1171: for the PExec call and maximum compatibility through-out ! 1172: */ ! 1173: void GemDOS_OpCode(void) ! 1174: { ! 1175: unsigned short int GemDOSCall,CallingSReg; ! 1176: unsigned long Params; ! 1177: ! 1178: /* Read SReg from stack to see if parameters are on User or Super stack (We enter here ALWAYS in super mode) */ ! 1179: CallingSReg = STMemory_ReadWord(Regs[REG_A7]); ! 1180: if ((CallingSReg&SR_SUPERMODE)==0) /* Calling from user mode */ ! 1181: Params = Regs[REG_A8]; ! 1182: else /* Calling from super mode */ ! 1183: Params = Regs[REG_A7]+SIZE_WORD+SIZE_LONG; ! 1184: ! 1185: /* Default to run TOS GemDos (SR_NEG run Gemdos, SR_ZERO already done, SR_OVERFLOW run own 'Pexec' */ ! 1186: SR &= SR_CLEAR_OVERFLOW; ! 1187: SR &= SR_CLEAR_ZERO; ! 1188: SR |= SR_NEG; ! 1189: ! 1190: /* Find pointer to call parameters */ ! 1191: GemDOSCall = STMemory_ReadWord(Params); ! 1192: #ifdef DEBUG_TO_FILE ! 1193: Debug_File("GemDOS 0x%X (%s)\n",GemDOSCall,pszGemDOSNames[GemDOSCall]); ! 1194: #endif ! 1195: ! 1196: /* Intercept call */ ! 1197: switch(GemDOSCall) { ! 1198: case 0x3: ! 1199: if (GemDOS_Cauxin(Params)) ! 1200: SR |= SR_ZERO; ! 1201: break; ! 1202: case 0x4: ! 1203: if (GemDOS_Cauxout(Params)) ! 1204: SR |= SR_ZERO; ! 1205: break; ! 1206: case 0x5: ! 1207: if (GemDOS_Cprnout(Params)) ! 1208: SR |= SR_ZERO; ! 1209: break; ! 1210: case 0xe: ! 1211: if (GemDOS_SetDrv(Params)) ! 1212: SR |= SR_ZERO; ! 1213: break; ! 1214: case 0x11: ! 1215: if (GemDOS_Cprnos(Params)) ! 1216: SR |= SR_ZERO; ! 1217: break; ! 1218: case 0x12: ! 1219: if (GemDOS_Cauxis(Params)) ! 1220: SR |= SR_ZERO; ! 1221: break; ! 1222: case 0x13: ! 1223: if (GemDOS_Cauxos(Params)) ! 1224: SR |= SR_ZERO; ! 1225: break; ! 1226: case 0x1a: ! 1227: if (GemDOS_SetDTA(Params)) ! 1228: SR |= SR_ZERO; ! 1229: break; ! 1230: case 0x39: ! 1231: if (GemDOS_MkDir(Params)) ! 1232: SR |= SR_ZERO; ! 1233: break; ! 1234: case 0x3a: ! 1235: if (GemDOS_RmDir(Params)) ! 1236: SR |= SR_ZERO; ! 1237: break; ! 1238: case 0x3b: ! 1239: if (GemDOS_ChDir(Params)) ! 1240: SR |= SR_ZERO; ! 1241: break; ! 1242: case 0x3c: ! 1243: if (GemDOS_Create(Params)) ! 1244: SR |= SR_ZERO; ! 1245: break; ! 1246: case 0x3d: ! 1247: if (GemDOS_Open(Params)) ! 1248: SR |= SR_ZERO; ! 1249: break; ! 1250: case 0x3e: ! 1251: if (GemDOS_Close(Params)) ! 1252: SR |= SR_ZERO; ! 1253: break; ! 1254: case 0x3f: ! 1255: if (GemDOS_Read(Params)) ! 1256: SR |= SR_ZERO; ! 1257: break; ! 1258: case 0x40: ! 1259: if (GemDOS_Write(Params)) ! 1260: SR |= SR_ZERO; ! 1261: break; ! 1262: case 0x41: ! 1263: if (GemDOS_UnLink(Params)) ! 1264: SR |= SR_ZERO; ! 1265: break; ! 1266: case 0x42: ! 1267: if (GemDOS_LSeek(Params)) ! 1268: SR |= SR_ZERO; ! 1269: break; ! 1270: case 0x4b: ! 1271: if (GemDOS_Pexec(Params)) ! 1272: SR |= SR_ZERO; ! 1273: break; ! 1274: case 0x4e: ! 1275: if (GemDOS_SFirst(Params)) ! 1276: SR |= SR_ZERO; ! 1277: break; ! 1278: case 0x4f: ! 1279: if (GemDOS_SNext(Params)) ! 1280: SR |= SR_ZERO; ! 1281: break; ! 1282: case 0x56: ! 1283: if (GemDOS_Rename(Params)) ! 1284: SR |= SR_ZERO; ! 1285: break; ! 1286: case 0x57: ! 1287: if (GemDOS_GSDToF(Params)) ! 1288: SR |= SR_ZERO; ! 1289: break; ! 1290: } ! 1291: ! 1292: /* Write back to emulation condition codes, used for code re-direction */ ! 1293: EmuCCode = SR<<4; ! 1294: } ! 1295: ! 1296: ! 1297: //----------------------------------------------------------------------- ! 1298: /* ! 1299: Re-direct execution to old GEM calls, used in 'cart.s' ! 1300: */ ! 1301: void GemDOS_RunOldOpCode(void) ! 1302: { ! 1303: /* Set 'PC' to that of old GemDOS routines (see 'old_gemdos' in cart.s) */ ! 1304: m68k_setpc( STMemory_ReadLong(0xfa1004) ); /* Address of 'old_gemdos' in cart.s */ ! 1305: /* __asm { ! 1306: mov ecx,[STRAM_OFFSET+0xfa1004] // Address of 'old_gemdos' in cart.s ! 1307: bswap ecx ! 1308: and ecx,0x00ffffff ! 1309: mov esi,ecx ! 1310: add esi,STRAM_OFFSET // New PC ! 1311: RET ! 1312: } ! 1313: */ ! 1314: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.