![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to msdos.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MS-DOS Player] / msdos-player / source|
Return to msdos.cpp CVS log | Up to [MS-DOS Player] / msdos-player / source |
1.1 ! root 1: /* ! 2: MS-DOS Player for Win32 console ! 3: ! 4: Author : Takeda.Toshiya ! 5: Date : 2009.11.09- ! 6: */ ! 7: ! 8: #include "msdos.h" ! 9: ! 10: #ifdef _MSC_VER ! 11: #pragma warning( disable : 4018 ) ! 12: #pragma warning( disable : 4065 ) ! 13: #pragma warning( disable : 4146 ) ! 14: #pragma warning( disable : 4244 ) ! 15: #pragma warning( disable : 4267 ) ! 16: #endif ! 17: ! 18: #define my_strchr(str, chr) (char *)_mbschr((unsigned char *)(str), (unsigned int)(chr)) ! 19: #define my_strtok(tok, del) (char *)_mbstok((unsigned char *)(tok), (const unsigned char *)(del)) ! 20: #define my_strupr(str) (char *)_mbsupr((unsigned char *)(str)) ! 21: ! 22: #define fatalerror(...) { \ ! 23: fprintf(stderr, __VA_ARGS__); \ ! 24: exit(1); \ ! 25: } ! 26: #define error(...) fprintf(stderr, "error: " __VA_ARGS__) ! 27: ! 28: /* ---------------------------------------------------------------------------- ! 29: MAME i386 ! 30: ---------------------------------------------------------------------------- */ ! 31: ! 32: //#define SUPPORT_DISASSEMBLER ! 33: ! 34: #define CPU_MODEL i386 ! 35: //#define CPU_MODEL i486 ! 36: //#define CPU_MODEL pentium ! 37: //#define CPU_MODEL mediagx ! 38: //#define CPU_MODEL pentium_pro ! 39: //#define CPU_MODEL pentium_mmx ! 40: //#define CPU_MODEL pentium2 ! 41: //#define CPU_MODEL pentium3 ! 42: //#define CPU_MODEL pentium4 ! 43: ! 44: #define LSB_FIRST ! 45: ! 46: #ifndef INLINE ! 47: #define INLINE inline ! 48: #endif ! 49: #define U64(v) UINT64(v) ! 50: ! 51: //#define logerror(...) fprintf(stderr, __VA_ARGS__) ! 52: #define logerror(...) ! 53: //#define popmessage(...) fprintf(stderr, __VA_ARGS__) ! 54: #define popmessage(...) ! 55: ! 56: /*****************************************************************************/ ! 57: /* src/emu/diexec.h */ ! 58: ! 59: // I/O line states ! 60: enum line_state ! 61: { ! 62: CLEAR_LINE = 0, // clear (a fired or held) line ! 63: ASSERT_LINE, // assert an interrupt immediately ! 64: HOLD_LINE, // hold interrupt line until acknowledged ! 65: PULSE_LINE // pulse interrupt line instantaneously (only for NMI, RESET) ! 66: }; ! 67: ! 68: // I/O line definitions ! 69: enum ! 70: { ! 71: INPUT_LINE_IRQ = 0, ! 72: INPUT_LINE_NMI ! 73: }; ! 74: ! 75: /*****************************************************************************/ ! 76: /* src/emu/devcpu.h */ ! 77: ! 78: // CPU interface functions ! 79: #define CPU_INIT_NAME(name) cpu_init_##name ! 80: #define CPU_INIT(name) void* CPU_INIT_NAME(name)() ! 81: #define CPU_INIT_CALL(name) CPU_INIT_NAME(name)() ! 82: ! 83: #define CPU_RESET_NAME(name) cpu_reset_##name ! 84: #define CPU_RESET(name) void CPU_RESET_NAME(name)(i386_state *cpustate) ! 85: #define CPU_RESET_CALL(name) CPU_RESET_NAME(name)(cpustate) ! 86: ! 87: #define CPU_EXECUTE_NAME(name) cpu_execute_##name ! 88: #define CPU_EXECUTE(name) void CPU_EXECUTE_NAME(name)(i386_state *cpustate) ! 89: #define CPU_EXECUTE_CALL(name) CPU_EXECUTE_NAME(name)(cpustate) ! 90: ! 91: #define CPU_DISASSEMBLE_NAME(name) cpu_disassemble_##name ! 92: #define CPU_DISASSEMBLE(name) int CPU_DISASSEMBLE_NAME(name)(char *buffer, offs_t eip, const UINT8 *oprom) ! 93: #define CPU_DISASSEMBLE_CALL(name) CPU_DISASSEMBLE_NAME(name)(buffer, eip, oprom) ! 94: ! 95: /*****************************************************************************/ ! 96: /* src/emu/memory.h */ ! 97: ! 98: // offsets and addresses are 32-bit (for now...) ! 99: typedef UINT32 offs_t; ! 100: ! 101: // read accessors ! 102: UINT8 read_byte(offs_t byteaddress) ! 103: { ! 104: if(byteaddress < MAX_MEM) { ! 105: return mem[byteaddress]; ! 106: } else if((byteaddress & 0xfffffff0) == 0xfffffff0) { ! 107: return read_byte(byteaddress & 0xfffff); ! 108: } ! 109: return 0; ! 110: } ! 111: ! 112: UINT16 read_word(offs_t byteaddress) ! 113: { ! 114: if(byteaddress < MAX_MEM - 1) { ! 115: return *(UINT16 *)(mem + byteaddress); ! 116: } else if((byteaddress & 0xfffffff0) == 0xfffffff0) { ! 117: return read_word(byteaddress & 0xfffff); ! 118: } ! 119: return 0; ! 120: } ! 121: ! 122: UINT32 read_dword(offs_t byteaddress) ! 123: { ! 124: if(byteaddress < MAX_MEM - 3) { ! 125: return *(UINT32 *)(mem + byteaddress); ! 126: } else if((byteaddress & 0xfffffff0) == 0xfffffff0) { ! 127: return read_dword(byteaddress & 0xfffff); ! 128: } ! 129: return 0; ! 130: } ! 131: ! 132: // write accessors ! 133: void write_byte(offs_t byteaddress, UINT8 data) ! 134: { ! 135: if(byteaddress < MAX_MEM) { ! 136: if(byteaddress >= tvram_base_address && byteaddress < tvram_base_address + 4000) { ! 137: if(int_10h_feh_called && !int_10h_ffh_called && mem[byteaddress] != data) { ! 138: COORD co; ! 139: DWORD num; ! 140: ! 141: co.X = ((byteaddress - tvram_base_address) >> 1) % 80; ! 142: co.Y = ((byteaddress - tvram_base_address) >> 1) / 80; ! 143: ! 144: if(byteaddress & 1) { ! 145: scr_attr[0] = data; ! 146: WriteConsoleOutputAttribute(hStdout, scr_attr, 1, co, &num); ! 147: } else { ! 148: scr_char[0] = data; ! 149: WriteConsoleOutputCharacter(hStdout, scr_char, 1, co, &num); ! 150: } ! 151: } ! 152: } ! 153: mem[byteaddress] = data; ! 154: } ! 155: } ! 156: ! 157: void write_word(offs_t byteaddress, UINT16 data) ! 158: { ! 159: if(byteaddress < MAX_MEM - 1) { ! 160: if(byteaddress >= tvram_base_address && byteaddress < tvram_base_address + 4000) { ! 161: if(int_10h_feh_called && !int_10h_ffh_called && *(UINT16 *)(mem + byteaddress) != data) { ! 162: if(byteaddress & 1) { ! 163: write_byte(byteaddress , data ); ! 164: write_byte(byteaddress + 1, data >> 8); ! 165: } else { ! 166: COORD co; ! 167: DWORD num; ! 168: ! 169: co.X = ((byteaddress - tvram_base_address) >> 1) % 80; ! 170: co.Y = ((byteaddress - tvram_base_address) >> 1) / 80; ! 171: ! 172: scr_char[0] = data; ! 173: scr_attr[0] = data >> 8; ! 174: ! 175: WriteConsoleOutputCharacter(hStdout, scr_char, 1, co, &num); ! 176: WriteConsoleOutputAttribute(hStdout, scr_attr, 1, co, &num); ! 177: } ! 178: return; ! 179: } ! 180: } ! 181: *(UINT16 *)(mem + byteaddress) = data; ! 182: } ! 183: } ! 184: ! 185: void write_dword(offs_t byteaddress, UINT32 data) ! 186: { ! 187: if(byteaddress < MAX_MEM - 3) { ! 188: if(byteaddress >= tvram_base_address && byteaddress < tvram_base_address + 4000) { ! 189: if(int_10h_feh_called && !int_10h_ffh_called && *(UINT32 *)(mem + byteaddress) != data) { ! 190: if(byteaddress & 1) { ! 191: write_byte(byteaddress , data ); ! 192: write_byte(byteaddress + 1, data >> 8); ! 193: write_byte(byteaddress + 2, data >> 16); ! 194: write_byte(byteaddress + 3, data >> 24); ! 195: } else { ! 196: COORD co; ! 197: DWORD num; ! 198: ! 199: co.X = ((byteaddress - tvram_base_address) >> 1) % 80; ! 200: co.Y = ((byteaddress - tvram_base_address) >> 1) / 80; ! 201: ! 202: scr_char[0] = data; ! 203: scr_attr[0] = data >> 8; ! 204: scr_char[1] = data >> 16; ! 205: scr_attr[1] = data >> 24; ! 206: ! 207: WriteConsoleOutputCharacter(hStdout, scr_char, 2, co, &num); ! 208: WriteConsoleOutputAttribute(hStdout, scr_attr, 2, co, &num); ! 209: } ! 210: return; ! 211: } ! 212: } ! 213: *(UINT32 *)(mem + byteaddress) = data; ! 214: } ! 215: } ! 216: ! 217: // accessor methods for reading decrypted data ! 218: #define read_decrypted_byte read_byte ! 219: #define read_decrypted_word read_word ! 220: #define read_decrypted_dword read_dword ! 221: ! 222: UINT8 read_io_byte(offs_t byteaddress); ! 223: UINT16 read_io_word(offs_t byteaddress); ! 224: UINT32 read_io_dword(offs_t byteaddress); ! 225: ! 226: void write_io_byte(offs_t byteaddress, UINT8 data); ! 227: void write_io_word(offs_t byteaddress, UINT16 data); ! 228: void write_io_dword(offs_t byteaddress, UINT32 data); ! 229: ! 230: /*****************************************************************************/ ! 231: /* src/emu/emucore.h */ ! 232: ! 233: // constants for expression endianness ! 234: enum endianness_t ! 235: { ! 236: ENDIANNESS_LITTLE, ! 237: ENDIANNESS_BIG ! 238: }; ! 239: ! 240: // declare native endianness to be one or the other ! 241: #ifdef LSB_FIRST ! 242: const endianness_t ENDIANNESS_NATIVE = ENDIANNESS_LITTLE; ! 243: #else ! 244: const endianness_t ENDIANNESS_NATIVE = ENDIANNESS_BIG; ! 245: #endif ! 246: ! 247: // endian-based value: first value is if 'endian' is little-endian, second is if 'endian' is big-endian ! 248: #define ENDIAN_VALUE_LE_BE(endian,leval,beval) (((endian) == ENDIANNESS_LITTLE) ? (leval) : (beval)) ! 249: ! 250: // endian-based value: first value is if native endianness is little-endian, second is if native is big-endian ! 251: #define NATIVE_ENDIAN_VALUE_LE_BE(leval,beval) ENDIAN_VALUE_LE_BE(ENDIANNESS_NATIVE, leval, beval) ! 252: ! 253: // endian-based value: first value is if 'endian' matches native, second is if 'endian' doesn't match native ! 254: #define ENDIAN_VALUE_NE_NNE(endian,leval,beval) (((endian) == ENDIANNESS_NATIVE) ? (neval) : (nneval)) ! 255: ! 256: /*****************************************************************************/ ! 257: /* src/emu/didisasm.h */ ! 258: ! 259: // Disassembler constants ! 260: const UINT32 DASMFLAG_SUPPORTED = 0x80000000; // are disassembly flags supported? ! 261: const UINT32 DASMFLAG_STEP_OUT = 0x40000000; // this instruction should be the end of a step out sequence ! 262: const UINT32 DASMFLAG_STEP_OVER = 0x20000000; // this instruction should be stepped over by setting a breakpoint afterwards ! 263: const UINT32 DASMFLAG_OVERINSTMASK = 0x18000000; // number of extra instructions to skip when stepping over ! 264: const UINT32 DASMFLAG_OVERINSTSHIFT = 27; // bits to shift after masking to get the value ! 265: const UINT32 DASMFLAG_LENGTHMASK = 0x0000ffff; // the low 16-bits contain the actual length ! 266: ! 267: /*****************************************************************************/ ! 268: /* src/osd/osdcomm.h */ ! 269: ! 270: /* Highly useful macro for compile-time knowledge of an array size */ ! 271: #define ARRAY_LENGTH(x) (sizeof(x) / sizeof(x[0])) ! 272: ! 273: #include "softfloat/softfloat.c" ! 274: #include "i386/i386.c" ! 275: #ifdef SUPPORT_DISASSEMBLER ! 276: #include "i386/i386dasm.c" ! 277: bool dasm = false; ! 278: #endif ! 279: ! 280: i386_state *cpustate; ! 281: int cpu_type, cpu_step; ! 282: ! 283: void i386_jmp_far(UINT16 selector, UINT32 address) ! 284: { ! 285: if(PROTECTED_MODE && !V8086_MODE) { ! 286: i386_protected_mode_jump(cpustate, selector, address, 1, cpustate->operand_size); ! 287: } else { ! 288: cpustate->sreg[CS].selector = selector; ! 289: cpustate->performed_intersegment_jump = 1; ! 290: i386_load_segment_descriptor(cpustate, CS); ! 291: cpustate->eip = address; ! 292: CHANGE_PC(cpustate, cpustate->eip); ! 293: } ! 294: } ! 295: ! 296: /* ---------------------------------------------------------------------------- ! 297: main ! 298: ---------------------------------------------------------------------------- */ ! 299: ! 300: int main(int argc, char *argv[], char *envp[]) ! 301: { ! 302: int standard_env = (argc > 1 && _stricmp(argv[1], "-e") == 0); ! 303: ! 304: if(argc < 2 + standard_env) { ! 305: #ifdef _WIN64 ! 306: fprintf(stderr, "MS-DOS Player for Win32-x64 console\n\n"); ! 307: #else ! 308: fprintf(stderr, "MS-DOS Player for Win32 console\n\n"); ! 309: #endif ! 310: fprintf(stderr, "Usage: MSDOS [-e] (command file) [opions]\n"); ! 311: return(EXIT_FAILURE); ! 312: } ! 313: ! 314: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 315: hStdin = GetStdHandle(STD_INPUT_HANDLE); ! 316: hStdout = GetStdHandle(STD_OUTPUT_HANDLE); ! 317: GetConsoleScreenBufferInfo(hStdout, &csbi); ! 318: ! 319: for(int y = 0; y < SCR_BUF_SIZE; y++) { ! 320: for(int x = 0; x < 80; x++) { ! 321: scr_buf[y][x].Char.AsciiChar = ' '; ! 322: scr_buf[y][x].Attributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; ! 323: } ! 324: } ! 325: scr_buf_size.X = 80; ! 326: scr_buf_size.Y = SCR_BUF_SIZE; ! 327: scr_buf_pos.X = scr_buf_pos.Y = 0; ! 328: scr_width = csbi.dwSize.X; ! 329: scr_height = csbi.dwSize.Y; ! 330: cursor_moved = false; ! 331: ! 332: key_buf_char = new FIFO(); ! 333: key_buf_scan = new FIFO(); ! 334: ! 335: hardware_init(); ! 336: ! 337: if(msdos_init(argc - (standard_env + 1), argv + (standard_env + 1), envp, standard_env)) { ! 338: retval = EXIT_FAILURE; ! 339: } else { ! 340: timeBeginPeriod(1); ! 341: hardware_run(); ! 342: msdos_finish(); ! 343: timeEndPeriod(1); ! 344: } ! 345: hardware_finish(); ! 346: ! 347: delete key_buf_char; ! 348: delete key_buf_scan; ! 349: ! 350: SetConsoleTextAttribute(hStdout, csbi.wAttributes); ! 351: ! 352: return(retval); ! 353: } ! 354: ! 355: /* ---------------------------------------------------------------------------- ! 356: MS-DOS virtual machine ! 357: ---------------------------------------------------------------------------- */ ! 358: ! 359: void update_key_buffer() ! 360: { ! 361: DWORD dwRead; ! 362: INPUT_RECORD ir[16]; ! 363: ! 364: if(ReadConsoleInputA(hStdin, ir, 16, &dwRead)) { ! 365: for(int i = 0; i < dwRead; i++) { ! 366: if((ir[i].EventType & KEY_EVENT) && ir[i].Event.KeyEvent.bKeyDown) { ! 367: if(ir[i].Event.KeyEvent.uChar.AsciiChar == 0) { ! 368: // ignore shift, ctrl and alt keys ! 369: if(ir[i].Event.KeyEvent.wVirtualScanCode != 0x1d && ! 370: ir[i].Event.KeyEvent.wVirtualScanCode != 0x2a && ! 371: ir[i].Event.KeyEvent.wVirtualScanCode != 0x36 && ! 372: ir[i].Event.KeyEvent.wVirtualScanCode != 0x38) { ! 373: key_buf_char->write(0x00); ! 374: key_buf_scan->write(ir[i].Event.KeyEvent.dwControlKeyState & ENHANCED_KEY ? 0xe0 : 0x00); ! 375: key_buf_char->write(0x00); ! 376: key_buf_scan->write(ir[i].Event.KeyEvent.wVirtualScanCode & 0xff); ! 377: } ! 378: } else { ! 379: key_buf_char->write(ir[i].Event.KeyEvent.uChar.AsciiChar & 0xff); ! 380: key_buf_scan->write(ir[i].Event.KeyEvent.wVirtualScanCode & 0xff); ! 381: } ! 382: } ! 383: } ! 384: } ! 385: if(key_buf_char->count() == 0) { ! 386: Sleep(10); ! 387: } ! 388: } ! 389: ! 390: // process info ! 391: ! 392: process_t *msdos_process_info_create(UINT16 psp_seg) ! 393: { ! 394: for(int i = 0; i < MAX_PROCESS; i++) { ! 395: if(process[i].psp == 0 || process[i].psp == psp_seg) { ! 396: memset(&process[i], 0, sizeof(process_t)); ! 397: process[i].psp = psp_seg; ! 398: return(&process[i]); ! 399: } ! 400: } ! 401: fatalerror("too many processes\n"); ! 402: return(NULL); ! 403: } ! 404: ! 405: process_t *msdos_process_info_get(UINT16 psp_seg) ! 406: { ! 407: for(int i = 0; i < MAX_PROCESS; i++) { ! 408: if(process[i].psp == psp_seg) { ! 409: return(&process[i]); ! 410: } ! 411: } ! 412: fatalerror("invalid psp address\n"); ! 413: return(NULL); ! 414: } ! 415: ! 416: void msdos_cds_update(int drv) ! 417: { ! 418: cds_t *cds = (cds_t *)(mem + CDS_TOP); ! 419: ! 420: memset(mem + CDS_TOP, 0, CDS_SIZE); ! 421: sprintf(cds->path_name, "%c:\\", 'A' + drv); ! 422: cds->drive_attrib = 0x4000; // physical drive ! 423: cds->physical_drive_number = drv; ! 424: } ! 425: ! 426: // dbcs ! 427: ! 428: void msdos_dbcs_table_update() ! 429: { ! 430: UINT8 dbcs_data[DBCS_SIZE]; ! 431: memset(dbcs_data, 0, sizeof(dbcs_data)); ! 432: ! 433: CPINFO info; ! 434: GetCPInfo(active_code_page, &info); ! 435: ! 436: if(info.MaxCharSize != 1) { ! 437: for(int i = 0;; i += 2) { ! 438: UINT8 lo = info.LeadByte[i + 0]; ! 439: UINT8 hi = info.LeadByte[i + 1]; ! 440: dbcs_data[2 + i + 0] = lo; ! 441: dbcs_data[2 + i + 1] = hi; ! 442: if(lo == 0 && hi == 0) { ! 443: dbcs_data[0] = i + 2; ! 444: break; ! 445: } ! 446: } ! 447: } else { ! 448: dbcs_data[0] = 2; // ??? ! 449: } ! 450: memcpy(mem + DBCS_TOP, dbcs_data, sizeof(dbcs_data)); ! 451: } ! 452: ! 453: void msdos_dbcs_table_init() ! 454: { ! 455: system_code_page = active_code_page = _getmbcp(); ! 456: msdos_dbcs_table_update(); ! 457: } ! 458: ! 459: void msdos_dbcs_table_finish() ! 460: { ! 461: if(active_code_page != system_code_page) { ! 462: _setmbcp(system_code_page); ! 463: } ! 464: } ! 465: ! 466: int msdos_lead_byte_check(UINT8 code) ! 467: { ! 468: UINT8 *dbcs_table = mem + DBCS_TABLE; ! 469: ! 470: for(int i = 0;; i += 2) { ! 471: UINT8 lo = dbcs_table[i + 0]; ! 472: UINT8 hi = dbcs_table[i + 1]; ! 473: if(lo == 0 && hi == 0) { ! 474: break; ! 475: } ! 476: if(lo <= code && code <= hi) { ! 477: return(1); ! 478: } ! 479: } ! 480: return(0); ! 481: } ! 482: ! 483: // file control ! 484: ! 485: char *msdos_trimmed_path(char *path, int lfn) ! 486: { ! 487: static char tmp[MAX_PATH]; ! 488: ! 489: if(lfn) { ! 490: strcpy(tmp, path); ! 491: } else { ! 492: // remove space in the path ! 493: char *src = path, *dst = tmp; ! 494: ! 495: while(*src != '\0') { ! 496: if(msdos_lead_byte_check(*src)) { ! 497: *dst++ = *src++; ! 498: *dst++ = *src++; ! 499: } else if(*src != ' ') { ! 500: *dst++ = *src++; ! 501: } else { ! 502: src++; // skip space ! 503: } ! 504: } ! 505: *dst = '\0'; ! 506: } ! 507: return(tmp); ! 508: } ! 509: ! 510: bool match(char *text, char *pattern) ! 511: { ! 512: //http://www.prefield.com/algorithm/string/wildcard.html ! 513: switch (*pattern) { ! 514: case '\0': ! 515: return !*text; ! 516: case '*': ! 517: return match(text, pattern + 1) || *text && match(text + 1, pattern); ! 518: case '?': ! 519: return *text && match(text + 1, pattern + 1); ! 520: default: ! 521: return (*text == *pattern) && match(text + 1, pattern + 1); ! 522: } ! 523: } ! 524: ! 525: bool msdos_match_volume_label(char *path, char *volume) ! 526: { ! 527: char *p; ! 528: ! 529: if((p = my_strchr(path, ':')) != NULL) { ! 530: return msdos_match_volume_label(p + 1, volume); ! 531: } else if((p = my_strchr(path, '\\')) != NULL) { ! 532: return msdos_match_volume_label(p + 1, volume); ! 533: } else if((p = my_strchr(path, '.')) != NULL) { ! 534: *p = '\0'; ! 535: bool result = match(volume, path); ! 536: *p = '.'; ! 537: return result; ! 538: } else { ! 539: return match(volume, path); ! 540: } ! 541: } ! 542: ! 543: char *msdos_fcb_path(fcb_t *fcb) ! 544: { ! 545: static char tmp[MAX_PATH]; ! 546: char name[9], ext[4]; ! 547: ! 548: memset(name, 0, sizeof(name)); ! 549: memcpy(name, fcb->file_name, 8); ! 550: strcpy(name, msdos_trimmed_path(name, 0)); ! 551: ! 552: memset(ext, 0, sizeof(ext)); ! 553: memcpy(ext, fcb->file_name + 8, 3); ! 554: strcpy(ext, msdos_trimmed_path(ext, 0)); ! 555: ! 556: if(name[0] == '\0' || strcmp(name, "????????") == 0) { ! 557: strcpy(name, "*"); ! 558: } ! 559: if(ext[0] == '\0') { ! 560: strcpy(tmp, name); ! 561: } else { ! 562: if(strcmp(ext, "???") == 0) { ! 563: strcpy(ext, "*"); ! 564: } ! 565: sprintf(tmp, "%s.%s", name, ext); ! 566: } ! 567: return(tmp); ! 568: } ! 569: ! 570: void msdos_set_fcb_path(fcb_t *fcb, char *path) ! 571: { ! 572: char *ext = my_strchr(path, '.'); ! 573: ! 574: memset(fcb->file_name, 0x20, 8 + 3); ! 575: if(ext != NULL && path[0] != '.') { ! 576: *ext = '\0'; ! 577: memcpy(fcb->file_name + 8, ext + 1, strlen(ext + 1)); ! 578: } ! 579: memcpy(fcb->file_name, path, strlen(path)); ! 580: } ! 581: ! 582: char *msdos_short_path(char *path) ! 583: { ! 584: static char tmp[MAX_PATH]; ! 585: ! 586: GetShortPathName(path, tmp, MAX_PATH); ! 587: my_strupr(tmp); ! 588: return(tmp); ! 589: } ! 590: ! 591: char *msdos_short_full_path(char *path) ! 592: { ! 593: static char tmp[MAX_PATH]; ! 594: char full[MAX_PATH], *name; ! 595: ! 596: GetFullPathName(path, MAX_PATH, full, &name); ! 597: GetShortPathName(full, tmp, MAX_PATH); ! 598: my_strupr(tmp); ! 599: return(tmp); ! 600: } ! 601: ! 602: char *msdos_short_full_dir(char *path) ! 603: { ! 604: static char tmp[MAX_PATH]; ! 605: char full[MAX_PATH], *name; ! 606: ! 607: GetFullPathName(path, MAX_PATH, full, &name); ! 608: name[-1] = '\0'; ! 609: GetShortPathName(full, tmp, MAX_PATH); ! 610: my_strupr(tmp); ! 611: return(tmp); ! 612: } ! 613: ! 614: char *msdos_local_file_path(char *path, int lfn) ! 615: { ! 616: char *trimmed = msdos_trimmed_path(path, lfn); ! 617: ! 618: if(_access(trimmed, 0) != 0) { ! 619: process_t *process = msdos_process_info_get(current_psp); ! 620: static char tmp[MAX_PATH]; ! 621: ! 622: sprintf(tmp, "%s\\%s", process->module_dir, trimmed); ! 623: if(_access(tmp, 0) == 0) { ! 624: return(tmp); ! 625: } ! 626: } ! 627: return(trimmed); ! 628: } ! 629: ! 630: int msdos_drive_number(char *path) ! 631: { ! 632: char tmp[MAX_PATH], *name; ! 633: ! 634: GetFullPathName(path, MAX_PATH, tmp, &name); ! 635: if(tmp[0] >= 'a' && tmp[0] <= 'z') { ! 636: return(tmp[0] - 'a'); ! 637: } else { ! 638: return(tmp[0] - 'A'); ! 639: } ! 640: } ! 641: ! 642: char *msdos_volume_label(char *path) ! 643: { ! 644: static char tmp[MAX_PATH]; ! 645: char volume[] = "A:\\"; ! 646: ! 647: if(path[1] == ':') { ! 648: volume[0] = path[0]; ! 649: } else { ! 650: volume[0] = 'A' + _getdrive() - 1; ! 651: } ! 652: if(!GetVolumeInformation(volume, tmp, MAX_PATH, NULL, NULL, NULL, NULL, 0)) { ! 653: memset(tmp, 0, sizeof(tmp)); ! 654: } ! 655: return(tmp); ! 656: } ! 657: ! 658: char *msdos_short_volume_label(char *label) ! 659: { ! 660: static char tmp[(8 + 1 + 3) + 1]; ! 661: char *src = label; ! 662: int remain = strlen(label); ! 663: char *dst_n = tmp; ! 664: char *dst_e = tmp + 9; ! 665: ! 666: strcpy(tmp, " . "); ! 667: for(int i = 0; i < 8 && remain > 0; i++) { ! 668: if(msdos_lead_byte_check(*src)) { ! 669: if(++i == 8) { ! 670: break; ! 671: } ! 672: *dst_n++ = *src++; ! 673: remain--; ! 674: } ! 675: *dst_n++ = *src++; ! 676: remain--; ! 677: } ! 678: if(remain > 0) { ! 679: for(int i = 0; i < 3 && remain > 0; i++) { ! 680: if(msdos_lead_byte_check(*src)) { ! 681: if(++i == 3) { ! 682: break; ! 683: } ! 684: *dst_e++ = *src++; ! 685: remain--; ! 686: } ! 687: *dst_e++ = *src++; ! 688: remain--; ! 689: } ! 690: *dst_e = '\0'; ! 691: } else { ! 692: *dst_n = '\0'; ! 693: } ! 694: my_strupr(tmp); ! 695: return(tmp); ! 696: } ! 697: ! 698: void msdos_file_handler_open(int fd, char *path, int atty, int mode, UINT16 info, UINT16 psp_seg) ! 699: { ! 700: static int id = 0; ! 701: char full[MAX_PATH], *name; ! 702: ! 703: if(psp_seg && fd < 20) { ! 704: psp_t *psp = (psp_t *)(mem + (psp_seg << 4)); ! 705: psp->file_table[fd] = fd; ! 706: } ! 707: if(GetFullPathName(path, MAX_PATH, full, &name) != 0) { ! 708: strcpy(file_handler[fd].path, full); ! 709: } else { ! 710: strcpy(file_handler[fd].path, path); ! 711: } ! 712: file_handler[fd].valid = 1; ! 713: file_handler[fd].id = id++; // dummy id for int 21h ax=71a6h ! 714: file_handler[fd].atty = atty; ! 715: file_handler[fd].mode = mode; ! 716: file_handler[fd].info = info; ! 717: file_handler[fd].psp = psp_seg; ! 718: } ! 719: ! 720: void msdos_file_handler_dup(int dst, int src, UINT16 psp_seg) ! 721: { ! 722: if(psp_seg && dst < 20) { ! 723: psp_t *psp = (psp_t *)(mem + (psp_seg << 4)); ! 724: psp->file_table[dst] = dst; ! 725: } ! 726: strcpy(file_handler[dst].path, file_handler[src].path); ! 727: file_handler[dst].valid = 1; ! 728: file_handler[dst].id = file_handler[src].id; ! 729: file_handler[dst].atty = file_handler[src].atty; ! 730: file_handler[dst].mode = file_handler[src].mode; ! 731: file_handler[dst].info = file_handler[src].info; ! 732: file_handler[dst].psp = psp_seg; ! 733: } ! 734: ! 735: void msdos_file_handler_close(int fd, UINT16 psp_seg) ! 736: { ! 737: if(psp_seg && fd < 20) { ! 738: psp_t *psp = (psp_t *)(mem + (psp_seg << 4)); ! 739: psp->file_table[fd] = 0xff; ! 740: } ! 741: file_handler[fd].valid = 0; ! 742: } ! 743: ! 744: int msdos_file_attribute_create(UINT16 new_attr) ! 745: { ! 746: int attr = 0; ! 747: ! 748: if(REG16(CX) & 0x01) { ! 749: attr |= FILE_ATTRIBUTE_READONLY; ! 750: } ! 751: if(REG16(CX) & 0x02) { ! 752: attr |= FILE_ATTRIBUTE_HIDDEN; ! 753: } ! 754: if(REG16(CX) & 0x04) { ! 755: attr |= FILE_ATTRIBUTE_SYSTEM; ! 756: } ! 757: if(REG16(CX) & 0x20) { ! 758: attr |= FILE_ATTRIBUTE_ARCHIVE; ! 759: } ! 760: return(attr); ! 761: } ! 762: ! 763: // find file ! 764: ! 765: int msdos_find_file_check_attribute(int attribute, int allowed_mask, int required_mask) ! 766: { ! 767: if((allowed_mask & 0x08) && !(attribute & FILE_ATTRIBUTE_DIRECTORY)) { ! 768: return(0); // search directory only !!! ! 769: } else if(!(allowed_mask & 0x02) && (attribute & FILE_ATTRIBUTE_HIDDEN)) { ! 770: return(0); ! 771: } else if(!(allowed_mask & 0x04) && (attribute & FILE_ATTRIBUTE_SYSTEM)) { ! 772: return(0); ! 773: } else if(!(allowed_mask & 0x10) && (attribute & FILE_ATTRIBUTE_DIRECTORY)) { ! 774: return(0); ! 775: } else if((attribute & required_mask) != required_mask) { ! 776: return(0); ! 777: } else { ! 778: return(1); ! 779: } ! 780: } ! 781: ! 782: void msdos_find_file_conv_local_time(WIN32_FIND_DATA *fd) ! 783: { ! 784: FILETIME local; ! 785: ! 786: FileTimeToLocalFileTime(&fd->ftCreationTime, &local); ! 787: fd->ftCreationTime.dwLowDateTime = local.dwLowDateTime; ! 788: fd->ftCreationTime.dwHighDateTime = local.dwHighDateTime; ! 789: ! 790: FileTimeToLocalFileTime(&fd->ftLastAccessTime, &local); ! 791: fd->ftLastAccessTime.dwLowDateTime = local.dwLowDateTime; ! 792: fd->ftLastAccessTime.dwHighDateTime = local.dwHighDateTime; ! 793: ! 794: FileTimeToLocalFileTime(&fd->ftLastWriteTime, &local); ! 795: fd->ftLastWriteTime.dwLowDateTime = local.dwLowDateTime; ! 796: fd->ftLastWriteTime.dwHighDateTime = local.dwHighDateTime; ! 797: } ! 798: ! 799: // i/o ! 800: ! 801: void msdos_putch(UINT8 data); ! 802: ! 803: void msdos_stdio_reopen() ! 804: { ! 805: if(!file_handler[0].valid) { ! 806: _dup2(DUP_STDIN, 0); ! 807: msdos_file_handler_open(0, "STDIN", _isatty(0), 0, 0x80d3, 0); ! 808: } ! 809: if(!file_handler[1].valid) { ! 810: _dup2(DUP_STDOUT, 1); ! 811: msdos_file_handler_open(1, "STDOUT", _isatty(1), 1, 0x80d3, 0); ! 812: } ! 813: if(!file_handler[2].valid) { ! 814: _dup2(DUP_STDERR, 2); ! 815: msdos_file_handler_open(2, "STDERR", _isatty(2), 1, 0x80d3, 0); ! 816: } ! 817: } ! 818: ! 819: int msdos_kbhit() ! 820: { ! 821: msdos_stdio_reopen(); ! 822: ! 823: if(!file_handler[0].atty) { ! 824: // stdin is redirected to file ! 825: return(eof(0) == 0); ! 826: } ! 827: ! 828: // check keyboard status ! 829: if(key_buf_char->count() != 0) { ! 830: return(1); ! 831: } else { ! 832: return(_kbhit()); ! 833: } ! 834: } ! 835: ! 836: int msdos_getch_ex(int echo) ! 837: { ! 838: static char prev = 0; ! 839: ! 840: msdos_stdio_reopen(); ! 841: ! 842: if(!file_handler[0].atty) { ! 843: // stdin is redirected to file ! 844: retry: ! 845: char data; ! 846: if(_read(0, &data, 1) == 1) { ! 847: char tmp = data; ! 848: if(data == 0x0a) { ! 849: if(prev == 0x0d) { ! 850: goto retry; // CRLF -> skip LF ! 851: } else { ! 852: data = 0x0d; // LF only -> CR ! 853: } ! 854: } ! 855: prev = tmp; ! 856: return(data); ! 857: } ! 858: return(EOF); ! 859: } ! 860: ! 861: // input from console ! 862: while(key_buf_char->count() == 0) { ! 863: update_key_buffer(); ! 864: } ! 865: int key_char = key_buf_char->read(); ! 866: int key_scan = key_buf_scan->read(); ! 867: ! 868: if(echo && key_char) { ! 869: msdos_putch(key_char); ! 870: } ! 871: return key_char ? key_char : (key_scan != 0xe0) ? key_scan : 0; ! 872: } ! 873: ! 874: inline int msdos_getch() ! 875: { ! 876: return(msdos_getch_ex(0)); ! 877: } ! 878: ! 879: inline int msdos_getche() ! 880: { ! 881: return(msdos_getch_ex(1)); ! 882: } ! 883: ! 884: int msdos_write(int fd, const void *buffer, unsigned int count) ! 885: { ! 886: static int is_cr = 0; ! 887: ! 888: if(fd == 1 && !file_handler[1].atty) { ! 889: // CR+LF -> LF ! 890: UINT8 *buf = (UINT8 *)buffer; ! 891: for(unsigned int i = 0; i < count; i++) { ! 892: UINT8 data = buf[i]; ! 893: if(is_cr) { ! 894: if(data != 0x0a) { ! 895: UINT8 tmp = 0x0d; ! 896: _write(1, &tmp, 1); ! 897: } ! 898: _write(1, &data, 1); ! 899: is_cr = 0; ! 900: } else if(data == 0x0d) { ! 901: is_cr = 1; ! 902: } else { ! 903: _write(1, &data, 1); ! 904: } ! 905: } ! 906: return(count); ! 907: } ! 908: return(_write(fd, buffer, count)); ! 909: } ! 910: ! 911: void msdos_putch(UINT8 data) ! 912: { ! 913: static int p = 0; ! 914: static int is_kanji = 0; ! 915: static int is_esc = 0; ! 916: static int stored_x; ! 917: static int stored_y; ! 918: static WORD stored_a; ! 919: static char tmp[64]; ! 920: ! 921: msdos_stdio_reopen(); ! 922: ! 923: if(!file_handler[1].atty) { ! 924: // stdout is redirected to file ! 925: msdos_write(1, &data, 1); ! 926: return; ! 927: } ! 928: ! 929: // output to console ! 930: tmp[p++] = data; ! 931: ! 932: if(is_kanji) { ! 933: // kanji character ! 934: is_kanji = 0; ! 935: } else if(is_esc) { ! 936: // escape sequense ! 937: if((tmp[1] == ')' || tmp[1] == '(') && p == 3) { ! 938: p = is_esc = 0; ! 939: } else if(tmp[1] == '=' && p == 4) { ! 940: COORD co; ! 941: co.X = tmp[3] - 0x20; ! 942: co.Y = tmp[2] - 0x20; ! 943: SetConsoleCursorPosition(hStdout, co); ! 944: mem[0x450 + mem[0x462] * 2] = co.X; ! 945: mem[0x451 + mem[0x462] * 2] = co.Y; ! 946: cursor_moved = false; ! 947: p = is_esc = 0; ! 948: } else if((data >= 'a' && data <= 'z') || (data >= 'A' && data <= 'Z') || data == '*') { ! 949: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 950: COORD co; ! 951: GetConsoleScreenBufferInfo(hStdout, &csbi); ! 952: co.X = csbi.dwCursorPosition.X; ! 953: co.Y = csbi.dwCursorPosition.Y; ! 954: WORD wAttributes = csbi.wAttributes; ! 955: ! 956: if(tmp[1] == 'D') { ! 957: co.Y++; ! 958: } else if(tmp[1] == 'E') { ! 959: co.X = 0; ! 960: co.Y++; ! 961: } else if(tmp[1] == 'M') { ! 962: co.Y--; ! 963: } else if(tmp[1] == '*') { ! 964: SMALL_RECT rect; ! 965: SET_RECT(rect, 0, 0, csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 966: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 967: co.X = co.Y = 0; ! 968: } else if(tmp[1] == '[') { ! 969: int param[256], params = 0; ! 970: memset(param, 0, sizeof(param)); ! 971: for(int i = 2; i < p; i++) { ! 972: if(tmp[i] >= '0' && tmp[i] <= '9') { ! 973: param[params] *= 10; ! 974: param[params] += tmp[i] - '0'; ! 975: } else { ! 976: params++; ! 977: } ! 978: } ! 979: if(data == 'A') { ! 980: co.Y -= param[0]; ! 981: } else if(data == 'B') { ! 982: co.Y += param[0]; ! 983: } else if(data == 'C') { ! 984: co.X += param[0]; ! 985: } else if(data == 'D') { ! 986: co.X -= param[0]; ! 987: } else if(data == 'H' || data == 'f') { ! 988: co.X = param[1] - 1; ! 989: co.Y = param[0] - 1; ! 990: } else if(data == 'J') { ! 991: SMALL_RECT rect; ! 992: if(param[0] == 0) { ! 993: SET_RECT(rect, co.X, co.Y, csbi.dwSize.X - 1, co.Y); ! 994: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 995: if(co.Y < csbi.dwSize.Y - 1) { ! 996: SET_RECT(rect, 0, co.Y + 1, csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 997: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 998: } ! 999: } else if(param[0] == 1) { ! 1000: if(co.Y > 0) { ! 1001: SET_RECT(rect, 0, 0, csbi.dwSize.X - 1, co.Y - 1); ! 1002: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1003: } ! 1004: SET_RECT(rect, 0, co.Y, co.X, co.Y); ! 1005: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1006: } else if(param[0] == 2) { ! 1007: SET_RECT(rect, 0, 0, csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 1008: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1009: co.X = co.Y = 0; ! 1010: } ! 1011: } else if(data == 'K') { ! 1012: SMALL_RECT rect; ! 1013: if(param[0] == 0) { ! 1014: SET_RECT(rect, co.X, co.Y, csbi.dwSize.X - 1, co.Y); ! 1015: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1016: } else if(param[0] == 1) { ! 1017: SET_RECT(rect, 0, co.Y, co.X, co.Y); ! 1018: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1019: } else if(param[0] == 2) { ! 1020: SET_RECT(rect, 0, co.Y, csbi.dwSize.X - 1, co.Y); ! 1021: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1022: } ! 1023: } else if(data == 'L') { ! 1024: SMALL_RECT rect; ! 1025: SET_RECT(rect, 0, co.Y, csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 1026: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1027: SET_RECT(rect, 0, co.Y + param[0], csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 1028: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1029: // clear buffer ! 1030: for(int y = 0; y < SCR_BUF_SIZE; y++) { ! 1031: for(int x = 0; x < 80; x++) { ! 1032: scr_buf[y][x].Char.AsciiChar = ' '; ! 1033: scr_buf[y][x].Attributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; ! 1034: } ! 1035: } ! 1036: SET_RECT(rect, 0, co.Y, csbi.dwSize.X - 1, co.Y + param[0] - 1); ! 1037: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1038: co.X = 0; ! 1039: } else if(data == 'M') { ! 1040: SMALL_RECT rect; ! 1041: if(co.Y + param[0] > csbi.dwSize.Y - 1) { ! 1042: SET_RECT(rect, 0, co.Y, csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 1043: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1044: } else { ! 1045: SET_RECT(rect, 0, co.Y + param[0], csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 1046: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1047: SET_RECT(rect, 0, co.Y, csbi.dwSize.X - 1, csbi.dwSize.Y - 1); ! 1048: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1049: // clear buffer ! 1050: for(int y = 0; y < SCR_BUF_SIZE; y++) { ! 1051: for(int x = 0; x < 80; x++) { ! 1052: scr_buf[y][x].Char.AsciiChar = ' '; ! 1053: scr_buf[y][x].Attributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; ! 1054: } ! 1055: } ! 1056: } ! 1057: co.X = 0; ! 1058: } else if(data == 'h') { ! 1059: if(tmp[2] == '>' && tmp[3] == '5') { ! 1060: CONSOLE_CURSOR_INFO cur; ! 1061: GetConsoleCursorInfo(hStdout, &cur); ! 1062: if(cur.bVisible) { ! 1063: cur.bVisible = FALSE; ! 1064: GetConsoleCursorInfo(hStdout, &cur); ! 1065: } ! 1066: } ! 1067: } else if(data == 'l') { ! 1068: if(tmp[2] == '>' && tmp[3] == '5') { ! 1069: CONSOLE_CURSOR_INFO cur; ! 1070: GetConsoleCursorInfo(hStdout, &cur); ! 1071: if(!cur.bVisible) { ! 1072: cur.bVisible = TRUE; ! 1073: GetConsoleCursorInfo(hStdout, &cur); ! 1074: } ! 1075: } ! 1076: } else if(data == 'm') { ! 1077: wAttributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; ! 1078: int reverse = 0, hidden = 0; ! 1079: for(int i = 0; i < params; i++) { ! 1080: if(param[i] == 1) { ! 1081: wAttributes |= FOREGROUND_INTENSITY; ! 1082: } else if(param[i] == 4) { ! 1083: wAttributes |= COMMON_LVB_UNDERSCORE; ! 1084: } else if(param[i] == 7) { ! 1085: reverse = 1; ! 1086: } else if(param[i] == 8 || param[i] == 16) { ! 1087: hidden = 1; ! 1088: } else if((param[i] >= 17 && param[i] <= 23) || (param[i] >= 30 && param[i] <= 37)) { ! 1089: wAttributes &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE); ! 1090: if(param[i] >= 17 && param[i] <= 23) { ! 1091: param[i] -= 16; ! 1092: } else { ! 1093: param[i] -= 30; ! 1094: } ! 1095: if(param[i] & 1) { ! 1096: wAttributes |= FOREGROUND_RED; ! 1097: } ! 1098: if(param[i] & 2) { ! 1099: wAttributes |= FOREGROUND_GREEN; ! 1100: } ! 1101: if(param[i] & 4) { ! 1102: wAttributes |= FOREGROUND_BLUE; ! 1103: } ! 1104: } else if(param[i] >= 40 && param[i] <= 47) { ! 1105: wAttributes &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE); ! 1106: if((param[i] - 40) & 1) { ! 1107: wAttributes |= BACKGROUND_RED; ! 1108: } ! 1109: if((param[i] - 40) & 2) { ! 1110: wAttributes |= BACKGROUND_GREEN; ! 1111: } ! 1112: if((param[i] - 40) & 4) { ! 1113: wAttributes |= BACKGROUND_BLUE; ! 1114: } ! 1115: } ! 1116: } ! 1117: if(reverse) { ! 1118: wAttributes &= ~0xff; ! 1119: wAttributes |= BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE; ! 1120: } ! 1121: if(hidden) { ! 1122: wAttributes &= ~0x0f; ! 1123: wAttributes |= (wAttributes >> 4) & 0x0f; ! 1124: } ! 1125: } else if(data == 'n') { ! 1126: if(param[0] == 6) { ! 1127: char tmp[16]; ! 1128: sprintf(tmp, "\x1b[%d;%dR", co.Y + 1, co.X + 1); ! 1129: int len = strlen(tmp); ! 1130: for(int i = 0; i < len; i++) { ! 1131: key_buf_char->write(tmp[i]); ! 1132: key_buf_scan->write(0x00); ! 1133: } ! 1134: } ! 1135: } else if(data == 's') { ! 1136: stored_x = co.X; ! 1137: stored_y = co.Y; ! 1138: stored_a = wAttributes; ! 1139: } else if(data == 'u') { ! 1140: co.X = stored_x; ! 1141: co.Y = stored_y; ! 1142: wAttributes = stored_a; ! 1143: } ! 1144: } ! 1145: if(co.X < 0) { ! 1146: co.X = 0; ! 1147: } else if(co.X >= csbi.dwSize.X) { ! 1148: co.X = csbi.dwSize.X - 1; ! 1149: } ! 1150: if(co.Y < 0) { ! 1151: co.Y = 0; ! 1152: } else if(co.Y >= csbi.dwSize.Y) { ! 1153: co.Y = csbi.dwSize.Y - 1; ! 1154: } ! 1155: if(co.X != csbi.dwCursorPosition.X || co.Y != csbi.dwCursorPosition.Y) { ! 1156: SetConsoleCursorPosition(hStdout, co); ! 1157: mem[0x450 + mem[0x462] * 2] = co.X; ! 1158: mem[0x451 + mem[0x462] * 2] = co.Y; ! 1159: cursor_moved = false; ! 1160: } ! 1161: if(wAttributes != csbi.wAttributes) { ! 1162: SetConsoleTextAttribute(hStdout, wAttributes); ! 1163: } ! 1164: p = is_esc = 0; ! 1165: } ! 1166: return; ! 1167: } else { ! 1168: if(msdos_lead_byte_check(data)) { ! 1169: is_kanji = 1; ! 1170: return; ! 1171: } else if(data == 0x1b) { ! 1172: is_esc = 1; ! 1173: return; ! 1174: } ! 1175: } ! 1176: tmp[p++] = '\0'; ! 1177: p = 0; ! 1178: printf("%s", tmp); ! 1179: cursor_moved = true; ! 1180: } ! 1181: ! 1182: int msdos_aux_in() ! 1183: { ! 1184: #ifdef SUPPORT_AUX_PRN ! 1185: if(file_handler[3].valid && !eof(3)) { ! 1186: char data = 0; ! 1187: _read(3, &data, 1); ! 1188: return(data); ! 1189: } else { ! 1190: return(EOF); ! 1191: } ! 1192: #else ! 1193: return(0); ! 1194: #endif ! 1195: } ! 1196: ! 1197: void msdos_aux_out(char data) ! 1198: { ! 1199: #ifdef SUPPORT_AUX_PRN ! 1200: if(file_handler[3].valid) { ! 1201: msdos_write(3, &data, 1); ! 1202: } ! 1203: #endif ! 1204: } ! 1205: ! 1206: void msdos_prn_out(char data) ! 1207: { ! 1208: #ifdef SUPPORT_AUX_PRN ! 1209: if(file_handler[4].valid) { ! 1210: msdos_write(4, &data, 1); ! 1211: } ! 1212: #endif ! 1213: } ! 1214: ! 1215: // memory control ! 1216: ! 1217: mcb_t *msdos_mcb_create(int mcb_seg, UINT8 mz, UINT16 psp, UINT16 paragraphs) ! 1218: { ! 1219: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 1220: ! 1221: mcb->mz = mz; ! 1222: mcb->psp = psp; ! 1223: mcb->paragraphs = paragraphs; ! 1224: return(mcb); ! 1225: } ! 1226: ! 1227: void msdos_mcb_check(mcb_t *mcb) ! 1228: { ! 1229: if(!(mcb->mz == 'M' || mcb->mz == 'Z')) { ! 1230: fatalerror("broken mcb\n"); ! 1231: } ! 1232: } ! 1233: ! 1234: int msdos_mem_split(int seg, int paragraphs) ! 1235: { ! 1236: int mcb_seg = seg - 1; ! 1237: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 1238: msdos_mcb_check(mcb); ! 1239: ! 1240: if(mcb->paragraphs > paragraphs) { ! 1241: int new_seg = mcb_seg + 1 + paragraphs; ! 1242: int new_paragraphs = mcb->paragraphs - paragraphs - 1; ! 1243: ! 1244: msdos_mcb_create(new_seg, mcb->mz, 0, new_paragraphs); ! 1245: mcb->mz = 'M'; ! 1246: mcb->paragraphs = paragraphs; ! 1247: return(0); ! 1248: } ! 1249: return(-1); ! 1250: } ! 1251: ! 1252: void msdos_mem_merge(int seg) ! 1253: { ! 1254: int mcb_seg = seg - 1; ! 1255: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 1256: msdos_mcb_check(mcb); ! 1257: ! 1258: while(1) { ! 1259: if(mcb->mz == 'Z') { ! 1260: break; ! 1261: } ! 1262: int next_seg = mcb_seg + 1 + mcb->paragraphs; ! 1263: mcb_t *next_mcb = (mcb_t *)(mem + (next_seg << 4)); ! 1264: msdos_mcb_check(next_mcb); ! 1265: ! 1266: if(next_mcb->psp != 0) { ! 1267: break; ! 1268: } ! 1269: mcb->mz = next_mcb->mz; ! 1270: mcb->paragraphs += 1 + next_mcb->paragraphs; ! 1271: } ! 1272: } ! 1273: ! 1274: int msdos_mem_alloc(int paragraphs, int new_process) ! 1275: { ! 1276: int mcb_seg = current_psp - 1; ! 1277: ! 1278: while(1) { ! 1279: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 1280: msdos_mcb_check(mcb); ! 1281: ! 1282: if(!new_process || mcb->mz == 'Z') { ! 1283: if(mcb->psp == 0 && mcb->paragraphs >= paragraphs) { ! 1284: msdos_mem_split(mcb_seg + 1, paragraphs); ! 1285: mcb->psp = current_psp; ! 1286: return(mcb_seg + 1); ! 1287: } ! 1288: } ! 1289: if(mcb->mz == 'Z') { ! 1290: break; ! 1291: } ! 1292: mcb_seg += 1 + mcb->paragraphs; ! 1293: } ! 1294: return(-1); ! 1295: } ! 1296: ! 1297: int msdos_mem_realloc(int seg, int paragraphs, int *max_paragraphs) ! 1298: { ! 1299: int mcb_seg = seg - 1; ! 1300: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 1301: msdos_mcb_check(mcb); ! 1302: int current_paragraphs = mcb->paragraphs; ! 1303: ! 1304: msdos_mem_merge(seg); ! 1305: if(paragraphs > mcb->paragraphs) { ! 1306: *max_paragraphs = mcb->paragraphs; ! 1307: msdos_mem_split(seg, current_paragraphs); ! 1308: return(-1); ! 1309: } ! 1310: msdos_mem_split(seg, paragraphs); ! 1311: return(0); ! 1312: } ! 1313: ! 1314: void msdos_mem_free(int seg) ! 1315: { ! 1316: int mcb_seg = seg - 1; ! 1317: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 1318: msdos_mcb_check(mcb); ! 1319: ! 1320: mcb->psp = 0; ! 1321: msdos_mem_merge(seg); ! 1322: } ! 1323: ! 1324: int msdos_mem_get_free(int new_process) ! 1325: { ! 1326: int mcb_seg = current_psp - 1; ! 1327: int max_paragraphs = 0; ! 1328: ! 1329: while(1) { ! 1330: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 1331: msdos_mcb_check(mcb); ! 1332: ! 1333: if(!new_process || mcb->mz == 'Z') { ! 1334: if(mcb->psp == 0 && mcb->paragraphs > max_paragraphs) { ! 1335: max_paragraphs = mcb->paragraphs; ! 1336: } ! 1337: } ! 1338: if(mcb->mz == 'Z') { ! 1339: break; ! 1340: } ! 1341: mcb_seg += 1 + mcb->paragraphs; ! 1342: } ! 1343: return(max_paragraphs); ! 1344: } ! 1345: ! 1346: // environment ! 1347: ! 1348: void msdos_env_set_argv(int env_seg, char *argv) ! 1349: { ! 1350: char *dst = (char *)(mem + (env_seg << 4)); ! 1351: ! 1352: while(1) { ! 1353: if(dst[0] == 0) { ! 1354: break; ! 1355: } ! 1356: dst += strlen(dst) + 1; ! 1357: } ! 1358: *dst++ = 0; // end of environment ! 1359: *dst++ = 1; // top of argv[0] ! 1360: *dst++ = 0; ! 1361: memcpy(dst, argv, strlen(argv)); ! 1362: dst += strlen(argv); ! 1363: *dst++ = 0; ! 1364: *dst++ = 0; ! 1365: } ! 1366: ! 1367: char *msdos_env_get_argv(int env_seg) ! 1368: { ! 1369: static char env[ENV_SIZE]; ! 1370: char *src = env; ! 1371: ! 1372: memcpy(src, mem + (env_seg << 4), ENV_SIZE); ! 1373: while(1) { ! 1374: if(src[0] == 0) { ! 1375: if(src[1] == 1) { ! 1376: return(src + 3); ! 1377: } ! 1378: break; ! 1379: } ! 1380: src += strlen(src) + 1; ! 1381: } ! 1382: return(NULL); ! 1383: } ! 1384: ! 1385: char *msdos_env_get(int env_seg, const char *name) ! 1386: { ! 1387: static char env[ENV_SIZE]; ! 1388: char *src = env; ! 1389: ! 1390: memcpy(src, mem + (env_seg << 4), ENV_SIZE); ! 1391: while(1) { ! 1392: if(src[0] == 0) { ! 1393: break; ! 1394: } ! 1395: int len = strlen(src); ! 1396: char *n = my_strtok(src, "="); ! 1397: char *v = src + strlen(n) + 1; ! 1398: ! 1399: if(_stricmp(name, n) == 0) { ! 1400: return(v); ! 1401: } ! 1402: src += len + 1; ! 1403: } ! 1404: return(NULL); ! 1405: } ! 1406: ! 1407: void msdos_env_set(int env_seg, char *name, char *value) ! 1408: { ! 1409: char env[ENV_SIZE]; ! 1410: char *src = env; ! 1411: char *dst = (char *)(mem + (env_seg << 4)); ! 1412: char *argv = msdos_env_get_argv(env_seg); ! 1413: int done = 0; ! 1414: ! 1415: memcpy(src, dst, ENV_SIZE); ! 1416: memset(dst, 0, ENV_SIZE); ! 1417: while(1) { ! 1418: if(src[0] == 0) { ! 1419: break; ! 1420: } ! 1421: int len = strlen(src); ! 1422: char *n = my_strtok(src, "="); ! 1423: char *v = src + strlen(n) + 1; ! 1424: char tmp[1024]; ! 1425: ! 1426: if(_stricmp(name, n) == 0) { ! 1427: sprintf(tmp, "%s=%s", n, value); ! 1428: done = 1; ! 1429: } else { ! 1430: sprintf(tmp, "%s=%s", n, v); ! 1431: } ! 1432: memcpy(dst, tmp, strlen(tmp)); ! 1433: dst += strlen(tmp) + 1; ! 1434: src += len + 1; ! 1435: } ! 1436: if(!done) { ! 1437: char tmp[1024]; ! 1438: ! 1439: sprintf(tmp, "%s=%s", name, value); ! 1440: memcpy(dst, tmp, strlen(tmp)); ! 1441: dst += strlen(tmp) + 1; ! 1442: } ! 1443: if(argv) { ! 1444: *dst++ = 0; // end of environment ! 1445: *dst++ = 1; // top of argv[0] ! 1446: *dst++ = 0; ! 1447: memcpy(dst, argv, strlen(argv)); ! 1448: dst += strlen(argv); ! 1449: *dst++ = 0; ! 1450: *dst++ = 0; ! 1451: } ! 1452: } ! 1453: ! 1454: // process ! 1455: ! 1456: psp_t *msdos_psp_create(int psp_seg, UINT16 first_mcb, UINT16 parent_psp, UINT16 env_seg) ! 1457: { ! 1458: psp_t *psp = (psp_t *)(mem + (psp_seg << 4)); ! 1459: ! 1460: memset(psp, 0, PSP_SIZE); ! 1461: psp->exit[0] = 0xcd; ! 1462: psp->exit[1] = 0x20; ! 1463: psp->first_mcb = first_mcb; ! 1464: psp->far_call = 0xea; ! 1465: psp->cpm_entry.w.l = 0xfff1; // int 21h, retf ! 1466: psp->cpm_entry.w.h = 0xf000; ! 1467: psp->int_22h.dw = *(UINT32 *)(mem + 4 * 0x22); ! 1468: psp->int_23h.dw = *(UINT32 *)(mem + 4 * 0x23); ! 1469: psp->int_24h.dw = *(UINT32 *)(mem + 4 * 0x24); ! 1470: psp->parent_psp = parent_psp; ! 1471: for(int i = 0; i < 20; i++) { ! 1472: if(file_handler[i].valid) { ! 1473: psp->file_table[i] = i; ! 1474: } else { ! 1475: psp->file_table[i] = 0xff; ! 1476: } ! 1477: } ! 1478: psp->env_seg = env_seg; ! 1479: psp->stack.w.l = REG16(SP); ! 1480: psp->stack.w.h = cpustate->sreg[SS].selector; ! 1481: psp->service[0] = 0xcd; ! 1482: psp->service[1] = 0x21; ! 1483: psp->service[2] = 0xcb; ! 1484: return(psp); ! 1485: } ! 1486: ! 1487: int msdos_process_exec(char *cmd, param_block_t *param, UINT8 al) ! 1488: { ! 1489: // load command file ! 1490: int fd = -1; ! 1491: int dos_command = 0; ! 1492: char command[MAX_PATH], path[MAX_PATH], opt[MAX_PATH], *name; ! 1493: ! 1494: strcpy(command, cmd); ! 1495: int opt_ofs = (param->cmd_line.w.h << 4) + param->cmd_line.w.l; ! 1496: int opt_len = mem[opt_ofs]; ! 1497: memset(opt, 0, sizeof(opt)); ! 1498: memcpy(opt, mem + opt_ofs + 1, opt_len); ! 1499: ! 1500: // check command.com ! 1501: GetFullPathName(command, MAX_PATH, path, &name); ! 1502: if(_stricmp(name, "COMMAND.COM") == 0 || _stricmp(name, "CMD.EXE") == 0) { ! 1503: for(int i = 0; i < opt_len; i++) { ! 1504: if(opt[i] == ' ') { ! 1505: continue; ! 1506: } ! 1507: if(opt[i] == '/' && (opt[i + 1] == 'c' || opt[i + 1] == 'C') && opt[i + 2] == ' ') { ! 1508: dos_command = 1; ! 1509: for(int j = i + 3; j < opt_len; j++) { ! 1510: if(opt[j] == ' ') { ! 1511: continue; ! 1512: } ! 1513: char *token = my_strtok(opt + j, " "); ! 1514: strcpy(command, token); ! 1515: char tmp[MAX_PATH]; ! 1516: strcpy(tmp, token + strlen(token) + 1); ! 1517: strcpy(opt, tmp); ! 1518: opt_len = strlen(opt); ! 1519: mem[opt_ofs] = opt_len; ! 1520: strcpy((char *)(mem + opt_ofs + 1), opt); ! 1521: break; ! 1522: } ! 1523: } ! 1524: break; ! 1525: } ! 1526: } ! 1527: ! 1528: // load command file ! 1529: strcpy(path, command); ! 1530: if((fd = _open(path, _O_RDONLY | _O_BINARY)) == -1) { ! 1531: sprintf(path, "%s.COM", command); ! 1532: if((fd = _open(path, _O_RDONLY | _O_BINARY)) == -1) { ! 1533: sprintf(path, "%s.EXE", command); ! 1534: if((fd = _open(path, _O_RDONLY | _O_BINARY)) == -1) { ! 1535: // search path in parent environments ! 1536: psp_t *parent_psp = (psp_t *)(mem + (current_psp << 4)); ! 1537: char *env = msdos_env_get(parent_psp->env_seg, "PATH"); ! 1538: ! 1539: if(env != NULL) { ! 1540: char env_path[1024]; ! 1541: strcpy(env_path, env); ! 1542: char *token = my_strtok(env_path, ";"); ! 1543: ! 1544: while(token != NULL) { ! 1545: sprintf(path, "%s\\%s", token, command); ! 1546: if((fd = _open(path, _O_RDONLY | _O_BINARY)) != -1) { ! 1547: break; ! 1548: } ! 1549: sprintf(path, "%s\\%s.COM", token, command); ! 1550: if((fd = _open(path, _O_RDONLY | _O_BINARY)) != -1) { ! 1551: break; ! 1552: } ! 1553: sprintf(path, "%s\\%s.EXE", token, command); ! 1554: if((fd = _open(path, _O_RDONLY | _O_BINARY)) != -1) { ! 1555: break; ! 1556: } ! 1557: token = my_strtok(NULL, ";"); ! 1558: } ! 1559: } ! 1560: } ! 1561: } ! 1562: } ! 1563: if(fd == -1) { ! 1564: if(dos_command) { ! 1565: // may be dos command ! 1566: char tmp[MAX_PATH]; ! 1567: sprintf(tmp, "%s %s", command, opt); ! 1568: system(tmp); ! 1569: return(0); ! 1570: } else { ! 1571: return(-1); ! 1572: } ! 1573: } ! 1574: _read(fd, file_buffer, sizeof(file_buffer)); ! 1575: _close(fd); ! 1576: ! 1577: // copy environment ! 1578: int env_seg, psp_seg; ! 1579: ! 1580: if((env_seg = msdos_mem_alloc(ENV_SIZE >> 4, 1)) == -1) { ! 1581: return(-1); ! 1582: } ! 1583: if(param->env_seg == 0) { ! 1584: psp_t *parent_psp = (psp_t *)(mem + (current_psp << 4)); ! 1585: memcpy(mem + (env_seg << 4), mem + (parent_psp->env_seg << 4), ENV_SIZE); ! 1586: } else { ! 1587: memcpy(mem + (env_seg << 4), mem + (param->env_seg << 4), ENV_SIZE); ! 1588: } ! 1589: msdos_env_set_argv(env_seg, msdos_short_full_path(path)); ! 1590: ! 1591: // check exe header ! 1592: exe_header_t *header = (exe_header_t *)file_buffer; ! 1593: int paragraphs, free_paragraphs = msdos_mem_get_free(1); ! 1594: UINT16 cs, ss, ip, sp; ! 1595: ! 1596: if(header->mz == 0x4d5a || header->mz == 0x5a4d) { ! 1597: // memory allocation ! 1598: int header_size = header->header_size * 16; ! 1599: int load_size = header->pages * 512 - header_size; ! 1600: if(header_size + load_size < 512) { ! 1601: load_size = 512 - header_size; ! 1602: } ! 1603: paragraphs = (PSP_SIZE + load_size) >> 4; ! 1604: if(paragraphs + header->min_alloc > free_paragraphs) { ! 1605: msdos_mem_free(env_seg); ! 1606: return(-1); ! 1607: } ! 1608: paragraphs += header->max_alloc ? header->max_alloc : header->min_alloc; ! 1609: if(paragraphs > free_paragraphs) { ! 1610: paragraphs = free_paragraphs; ! 1611: } ! 1612: if((psp_seg = msdos_mem_alloc(paragraphs, 1)) == -1) { ! 1613: msdos_mem_free(env_seg); ! 1614: return(-1); ! 1615: } ! 1616: // relocation ! 1617: int start_seg = psp_seg + (PSP_SIZE >> 4); ! 1618: for(int i = 0; i < header->relocations; i++) { ! 1619: int ofs = *(UINT16 *)(file_buffer + header->relocation_table + i * 4 + 0); ! 1620: int seg = *(UINT16 *)(file_buffer + header->relocation_table + i * 4 + 2); ! 1621: *(UINT16 *)(file_buffer + header_size + (seg << 4) + ofs) += start_seg; ! 1622: } ! 1623: memcpy(mem + (start_seg << 4), file_buffer + header_size, load_size); ! 1624: // segments ! 1625: cs = header->init_cs + start_seg; ! 1626: ss = header->init_ss + start_seg; ! 1627: ip = header->init_ip; ! 1628: sp = header->init_sp - 2; // for symdeb ! 1629: } else { ! 1630: // memory allocation ! 1631: paragraphs = free_paragraphs; ! 1632: if((psp_seg = msdos_mem_alloc(paragraphs, 1)) == -1) { ! 1633: msdos_mem_free(env_seg); ! 1634: return(-1); ! 1635: } ! 1636: int start_seg = psp_seg + (PSP_SIZE >> 4); ! 1637: memcpy(mem + (start_seg << 4), file_buffer, 0x10000 - PSP_SIZE); ! 1638: // segments ! 1639: cs = ss = psp_seg; ! 1640: ip = 0x100; ! 1641: sp = 0xfffe; ! 1642: } ! 1643: ! 1644: // create psp ! 1645: *(UINT16 *)(mem + 4 * 0x22 + 0) = cpustate->eip; ! 1646: *(UINT16 *)(mem + 4 * 0x22 + 2) = cpustate->sreg[CS].selector; ! 1647: psp_t *psp = msdos_psp_create(psp_seg, psp_seg + paragraphs, current_psp, env_seg); ! 1648: memcpy(psp->fcb1, mem + (param->fcb1.w.h << 4) + param->fcb1.w.l, sizeof(psp->fcb1)); ! 1649: memcpy(psp->fcb2, mem + (param->fcb2.w.h << 4) + param->fcb2.w.l, sizeof(psp->fcb2)); ! 1650: memcpy(psp->buffer, mem + (param->cmd_line.w.h << 4) + param->cmd_line.w.l, sizeof(psp->buffer)); ! 1651: ! 1652: mcb_t *mcb_env = (mcb_t *)(mem + ((env_seg - 1) << 4)); ! 1653: mcb_t *mcb_psp = (mcb_t *)(mem + ((psp_seg - 1) << 4)); ! 1654: mcb_psp->psp = mcb_env->psp = psp_seg; ! 1655: ! 1656: // process info ! 1657: process_t *process = msdos_process_info_create(psp_seg); ! 1658: strcpy(process->module_dir, msdos_short_full_dir(path)); ! 1659: process->dta.w.l = 0x80; ! 1660: process->dta.w.h = psp_seg; ! 1661: process->switchar = '/'; ! 1662: process->max_files = 20; ! 1663: process->find_handle = INVALID_HANDLE_VALUE; ! 1664: process->parent_int_10h_feh_called = int_10h_feh_called; ! 1665: process->parent_int_10h_ffh_called = int_10h_ffh_called; ! 1666: ! 1667: current_psp = psp_seg; ! 1668: ! 1669: if(al == 0x00) { ! 1670: int_10h_feh_called = int_10h_ffh_called = false; ! 1671: ! 1672: // registers and segments ! 1673: REG16(AX) = REG16(BX) = 0x00; ! 1674: REG16(CX) = 0xff; ! 1675: REG16(DX) = psp_seg; ! 1676: REG16(SI) = ip; ! 1677: REG16(DI) = sp; ! 1678: REG16(SP) = sp; ! 1679: cpustate->sreg[DS].selector = cpustate->sreg[ES].selector = psp_seg; ! 1680: cpustate->sreg[SS].selector = ss; ! 1681: i386_load_segment_descriptor(cpustate, DS); ! 1682: i386_load_segment_descriptor(cpustate, ES); ! 1683: i386_load_segment_descriptor(cpustate, SS); ! 1684: ! 1685: *(UINT16 *)(mem + (ss << 4) + sp) = 0; ! 1686: i386_jmp_far(cs, ip); ! 1687: } else if(al == 0x01) { ! 1688: // copy ss:sp and cs:ip to param block ! 1689: param->sp = sp; ! 1690: param->ss = ss; ! 1691: param->ip = ip; ! 1692: param->cs = cs; ! 1693: } ! 1694: return(0); ! 1695: } ! 1696: ! 1697: void msdos_process_terminate(int psp_seg, int ret, int mem_free) ! 1698: { ! 1699: psp_t *psp = (psp_t *)(mem + (psp_seg << 4)); ! 1700: ! 1701: *(UINT32 *)(mem + 4 * 0x22) = psp->int_22h.dw; ! 1702: *(UINT32 *)(mem + 4 * 0x23) = psp->int_23h.dw; ! 1703: *(UINT32 *)(mem + 4 * 0x24) = psp->int_24h.dw; ! 1704: ! 1705: cpustate->sreg[SS].selector = psp->stack.w.h; ! 1706: i386_load_segment_descriptor(cpustate, SS); ! 1707: REG16(SP) = psp->stack.w.l; ! 1708: i386_jmp_far(psp->int_22h.w.h, psp->int_22h.w.l); ! 1709: ! 1710: process_t *process = msdos_process_info_get(psp_seg); ! 1711: int_10h_feh_called = process->parent_int_10h_feh_called; ! 1712: int_10h_ffh_called = process->parent_int_10h_ffh_called; ! 1713: ! 1714: if(mem_free) { ! 1715: int mcb_seg = psp->env_seg - 1; ! 1716: msdos_mcb_create(mcb_seg, 'Z', 0, (MEMORY_END >> 4) - mcb_seg - 1); ! 1717: ! 1718: for(int i = 0; i < MAX_FILES; i++) { ! 1719: if(file_handler[i].valid && file_handler[i].psp == psp_seg) { ! 1720: _close(i); ! 1721: msdos_file_handler_close(i, psp_seg); ! 1722: } ! 1723: } ! 1724: msdos_stdio_reopen(); ! 1725: ! 1726: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 1727: FindClose(process->find_handle); ! 1728: process->find_handle = INVALID_HANDLE_VALUE; ! 1729: } ! 1730: } ! 1731: ! 1732: memset(process, 0, sizeof(process_t)); ! 1733: ! 1734: current_psp = psp->parent_psp; ! 1735: retval = ret; ! 1736: } ! 1737: ! 1738: // drive ! 1739: ! 1740: int msdos_drive_param_block_update(int drive_num, UINT16 *seg, UINT16 *ofs, int force_update) ! 1741: { ! 1742: *seg = DPB_TOP >> 4; ! 1743: *ofs = sizeof(dpb_t) * drive_num; ! 1744: dpb_t *dpb = (dpb_t *)(mem + (*seg << 4) + *ofs); ! 1745: ! 1746: if(!force_update && dpb->free_clusters != 0) { ! 1747: return(dpb->bytes_per_sector ? 1 : 0); ! 1748: } ! 1749: memset(dpb, 0, sizeof(dpb_t)); ! 1750: ! 1751: int res = 0; ! 1752: char dev[64]; ! 1753: sprintf(dev, "\\\\.\\%c:", 'A' + drive_num); ! 1754: ! 1755: HANDLE hFile = CreateFile(dev, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); ! 1756: if(hFile != INVALID_HANDLE_VALUE) { ! 1757: DISK_GEOMETRY geo; ! 1758: DWORD dwSize; ! 1759: if(DeviceIoControl(hFile, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &geo, sizeof(geo), &dwSize, NULL)) { ! 1760: dpb->bytes_per_sector = (UINT16)geo.BytesPerSector; ! 1761: dpb->highest_sector_num = (UINT8)(geo.SectorsPerTrack - 1); ! 1762: dpb->highest_cluster_num = (UINT16)(geo.TracksPerCylinder * geo.Cylinders.QuadPart + 1); ! 1763: switch(geo.MediaType) { ! 1764: case F5_320_512: // floppy, double-sided, 8 sectors per track (320K) ! 1765: dpb->media_type = 0xff; ! 1766: break; ! 1767: case F5_160_512: // floppy, single-sided, 8 sectors per track (160K) ! 1768: dpb->media_type = 0xfe; ! 1769: break; ! 1770: case F5_360_512: // floppy, double-sided, 9 sectors per track (360K) ! 1771: dpb->media_type = 0xfd; ! 1772: break; ! 1773: case F5_180_512: // floppy, single-sided, 9 sectors per track (180K) ! 1774: dpb->media_type = 0xfc; ! 1775: break; ! 1776: case F5_1Pt2_512: // floppy, double-sided, 15 sectors per track (1.2M) ! 1777: case F3_720_512: // floppy, double-sided, 9 sectors per track (720K,3.5") ! 1778: dpb->media_type = 0xf9; ! 1779: break; ! 1780: case FixedMedia: // hard disk ! 1781: case RemovableMedia: ! 1782: dpb->media_type = 0xf8; ! 1783: break; ! 1784: default: ! 1785: dpb->media_type = 0xf0; ! 1786: break; ! 1787: } ! 1788: res = 1; ! 1789: } ! 1790: dpb->drive_num = drive_num; ! 1791: dpb->unit_num = drive_num; ! 1792: dpb->next_dpb_ofs = *ofs + sizeof(dpb_t); ! 1793: dpb->next_dpb_seg = *seg; ! 1794: dpb->free_clusters = 0xffff; ! 1795: CloseHandle(hFile); ! 1796: } ! 1797: return(res); ! 1798: } ! 1799: ! 1800: // pc bios ! 1801: ! 1802: int get_tvram_address(int page) ! 1803: { ! 1804: if(/*mem[0x449] == 0x03 || */mem[0x449] == 0x70 || mem[0x449] == 0x71 || mem[0x449] == 0x73) { ! 1805: return TVRAM_TOP; ! 1806: } else { ! 1807: return TVRAM_TOP + 0x1000 * (page & 7); ! 1808: } ! 1809: } ! 1810: ! 1811: inline int get_tvram_address(int page, int x, int y) ! 1812: { ! 1813: return get_tvram_address(page) + (x + y * 80) * 2; ! 1814: } ! 1815: ! 1816: inline void pcbios_int_10h_00h() ! 1817: { ! 1818: mem[0x449] = REG8(AL) & 0x7f; ! 1819: tvram_base_address = get_tvram_address(mem[0x462]); ! 1820: ! 1821: if(REG8(AL) & 0x80) { ! 1822: mem[0x487] |= 0x80; ! 1823: } else { ! 1824: for(int y = 0, ofs = get_tvram_address(mem[0x462]); y < 25; y++) { ! 1825: for(int x = 0; x < 80; x++) { ! 1826: scr_buf[y][x].Char.AsciiChar = ' '; ! 1827: scr_buf[y][x].Attributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; ! 1828: mem[ofs++] = 0x20; ! 1829: mem[ofs++] = 0x07; ! 1830: } ! 1831: } ! 1832: SMALL_RECT rect; ! 1833: SET_RECT(rect, 0, 0, 79, 24); ! 1834: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1835: mem[0x487] &= ~0x80; ! 1836: } ! 1837: } ! 1838: ! 1839: inline void pcbios_int_10h_01h() ! 1840: { ! 1841: mem[0x460] = REG8(CL); ! 1842: mem[0x461] = REG8(CH); ! 1843: } ! 1844: ! 1845: inline void pcbios_int_10h_02h() ! 1846: { ! 1847: if(mem[0x462] == REG8(BH)) { ! 1848: COORD co; ! 1849: co.X = REG8(DL); ! 1850: co.Y = REG8(DH); ! 1851: SetConsoleCursorPosition(hStdout, co); ! 1852: } ! 1853: mem[0x450 + (REG8(BH) & 7) * 2] = REG8(DL); ! 1854: mem[0x451 + (REG8(BH) & 7) * 2] = REG8(DH); ! 1855: } ! 1856: ! 1857: inline void pcbios_int_10h_03h() ! 1858: { ! 1859: REG8(DL) = mem[0x450 + (REG8(BH) & 7) * 2]; ! 1860: REG8(DH) = mem[0x451 + (REG8(BH) & 7) * 2]; ! 1861: REG8(CL) = mem[0x460]; ! 1862: REG8(CH) = mem[0x461]; ! 1863: } ! 1864: ! 1865: inline void pcbios_int_10h_05h() ! 1866: { ! 1867: if(mem[0x462] != REG8(BH)) { ! 1868: SMALL_RECT rect; ! 1869: SET_RECT(rect, 0, 0, 79, 24); ! 1870: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1871: ! 1872: for(int y = 0, ofs = get_tvram_address(mem[0x462]); y < 25; y++) { ! 1873: for(int x = 0; x < 80; x++) { ! 1874: mem[ofs++] = scr_buf[y][x].Char.AsciiChar; ! 1875: mem[ofs++] = scr_buf[y][x].Attributes; ! 1876: } ! 1877: } ! 1878: for(int y = 0, ofs = get_tvram_address(REG8(BH)); y < 25; y++) { ! 1879: for(int x = 0; x < 80; x++) { ! 1880: scr_buf[y][x].Char.AsciiChar = mem[ofs++]; ! 1881: scr_buf[y][x].Attributes = mem[ofs++]; ! 1882: } ! 1883: } ! 1884: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1885: ! 1886: COORD co; ! 1887: co.X = mem[0x450 + (REG8(BH) & 7) * 2]; ! 1888: co.Y = mem[0x451 + (REG8(BH) & 7) * 2]; ! 1889: SetConsoleCursorPosition(hStdout, co); ! 1890: } ! 1891: mem[0x462] = REG8(BH) & 7; ! 1892: mem[0x44e] = 0; ! 1893: mem[0x44f] = REG8(BH) << 4; ! 1894: tvram_base_address = get_tvram_address(mem[0x462]); ! 1895: } ! 1896: ! 1897: inline void pcbios_int_10h_06h() ! 1898: { ! 1899: SMALL_RECT rect; ! 1900: SET_RECT(rect, 0, 0, 79, 24); ! 1901: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1902: ! 1903: if(REG8(AL) == 0) { ! 1904: for(int y = REG8(CH); y <= REG8(DH); y++) { ! 1905: for(int x = REG8(CL), ofs = get_tvram_address(mem[0x462], REG8(CL), y); x <= REG8(DL); x++) { ! 1906: scr_buf[y][x].Char.AsciiChar = ' '; ! 1907: scr_buf[y][x].Attributes = REG8(BH); ! 1908: mem[ofs++] = scr_buf[y][x].Char.AsciiChar; ! 1909: mem[ofs++] = scr_buf[y][x].Attributes; ! 1910: } ! 1911: } ! 1912: } else { ! 1913: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1914: for(int y = REG8(CH), y2 = REG8(CH) + REG8(AL); y <= REG8(DH); y++, y2++) { ! 1915: for(int x = REG8(CL), ofs = get_tvram_address(mem[0x462], REG8(CL), y); x <= REG8(DL); x++) { ! 1916: if(y2 <= REG8(DH) && y2 >= 0 && y2 < SCR_BUF_SIZE) { ! 1917: scr_buf[y][x] = scr_buf[y2][x]; ! 1918: } else { ! 1919: scr_buf[y][x].Char.AsciiChar = ' '; ! 1920: scr_buf[y][x].Attributes = REG8(BH); ! 1921: } ! 1922: mem[ofs++] = scr_buf[y][x].Char.AsciiChar; ! 1923: mem[ofs++] = scr_buf[y][x].Attributes; ! 1924: } ! 1925: } ! 1926: } ! 1927: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1928: } ! 1929: ! 1930: inline void pcbios_int_10h_07h() ! 1931: { ! 1932: SMALL_RECT rect; ! 1933: SET_RECT(rect, 0, 0, 79, 24); ! 1934: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1935: ! 1936: if(REG8(AL) == 0) { ! 1937: for(int y = REG8(CH); y <= REG8(DH); y++) { ! 1938: for(int x = REG8(CL), ofs = get_tvram_address(mem[0x462], REG8(CL), y); x <= REG8(DL); x++) { ! 1939: scr_buf[y][x].Char.AsciiChar = ' '; ! 1940: scr_buf[y][x].Attributes = REG8(BH); ! 1941: mem[ofs++] = scr_buf[y][x].Char.AsciiChar; ! 1942: mem[ofs++] = scr_buf[y][x].Attributes; ! 1943: } ! 1944: } ! 1945: } else { ! 1946: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1947: for(int y = REG8(DH), y2 = REG8(DH) - REG8(AL); y >= REG8(CH); y--, y2--) { ! 1948: for(int x = REG8(CL), ofs = get_tvram_address(mem[0x462], REG8(CL), y); x <= REG8(DL); x++) { ! 1949: if(y2 >= REG8(CH) && y2 >= 0 && y2 < SCR_BUF_SIZE) { ! 1950: scr_buf[y][x] = scr_buf[y2][x]; ! 1951: } else { ! 1952: scr_buf[y][x].Char.AsciiChar = ' '; ! 1953: scr_buf[y][x].Attributes = REG8(BH); ! 1954: } ! 1955: mem[ofs++] = scr_buf[y][x].Char.AsciiChar; ! 1956: mem[ofs++] = scr_buf[y][x].Attributes; ! 1957: } ! 1958: } ! 1959: } ! 1960: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 1961: } ! 1962: ! 1963: inline void pcbios_int_10h_08h() ! 1964: { ! 1965: COORD co; ! 1966: DWORD num; ! 1967: ! 1968: co.X = mem[0x450 + (REG8(BH) & 7) * 2]; ! 1969: co.Y = mem[0x451 + (REG8(BH) & 7) * 2]; ! 1970: ! 1971: if(mem[0x462] == REG8(BH)) { ! 1972: ReadConsoleOutputCharacter(hStdout, scr_char, 1, co, &num); ! 1973: ReadConsoleOutputAttribute(hStdout, scr_attr, 1, co, &num); ! 1974: REG8(AL) = scr_char[0]; ! 1975: REG8(AH) = scr_attr[0]; ! 1976: } else { ! 1977: REG16(AX) = *(UINT16 *)(mem + get_tvram_address(REG8(BH), co.X, co.Y)); ! 1978: } ! 1979: } ! 1980: ! 1981: inline void pcbios_int_10h_09h() ! 1982: { ! 1983: COORD co; ! 1984: DWORD num; ! 1985: ! 1986: co.X = mem[0x450 + (REG8(BH) & 7) * 2]; ! 1987: co.Y = mem[0x451 + (REG8(BH) & 7) * 2]; ! 1988: ! 1989: if(mem[0x462] == REG8(BH)) { ! 1990: for(int i = 0; i < REG16(CX) && i < 80 * 25; i++) { ! 1991: scr_char[i] = REG8(AL); ! 1992: scr_attr[i] = REG8(BL); ! 1993: } ! 1994: WriteConsoleOutputCharacter(hStdout, scr_char, REG16(CX), co, &num); ! 1995: WriteConsoleOutputAttribute(hStdout, scr_attr, REG16(CX), co, &num); ! 1996: } else { ! 1997: for(int i = 0, dest = get_tvram_address(REG8(BH), co.X, co.Y); i < REG16(CX); i++) { ! 1998: mem[dest++] = REG8(AL); ! 1999: mem[dest++] = REG8(BL); ! 2000: if(++co.X == 80) { ! 2001: if(++co.Y == 25) { ! 2002: break; ! 2003: } ! 2004: co.X = 0; ! 2005: } ! 2006: } ! 2007: } ! 2008: } ! 2009: ! 2010: inline void pcbios_int_10h_0ah() ! 2011: { ! 2012: COORD co; ! 2013: DWORD num; ! 2014: ! 2015: co.X = mem[0x450 + (REG8(BH) & 7) * 2]; ! 2016: co.Y = mem[0x451 + (REG8(BH) & 7) * 2]; ! 2017: ! 2018: if(mem[0x462] == REG8(BH)) { ! 2019: for(int i = 0; i < REG16(CX) && i < 80 * 25; i++) { ! 2020: scr_char[i] = REG8(AL); ! 2021: // scr_attr[i] = REG8(BL); ! 2022: } ! 2023: WriteConsoleOutputCharacter(hStdout, scr_char, REG16(CX), co, &num); ! 2024: // WriteConsoleOutputAttribute(hStdout, scr_attr, REG16(CX), co, &num); ! 2025: } else { ! 2026: for(int i = 0, dest = get_tvram_address(REG8(BH), co.X, co.Y); i < REG16(CX); i++) { ! 2027: mem[dest++] = REG8(AL); ! 2028: // mem[dest++] = REG8(BL); ! 2029: dest++; ! 2030: if(++co.X == 80) { ! 2031: if(++co.Y == 25) { ! 2032: break; ! 2033: } ! 2034: co.X = 0; ! 2035: } ! 2036: } ! 2037: } ! 2038: } ! 2039: ! 2040: inline void pcbios_int_10h_0eh() ! 2041: { ! 2042: msdos_putch(REG8(AL)); ! 2043: } ! 2044: ! 2045: inline void pcbios_int_10h_0fh() ! 2046: { ! 2047: REG8(AL) = mem[0x449]; ! 2048: REG8(AH) = mem[0x44a]; ! 2049: REG8(BH) = mem[0x462]; ! 2050: } ! 2051: ! 2052: inline void pcbios_int_10h_13h() ! 2053: { ! 2054: int ofs = cpustate->sreg[ES].base + REG16(BP); ! 2055: COORD co; ! 2056: DWORD num; ! 2057: ! 2058: co.X = REG8(DL); ! 2059: co.Y = REG8(DH); ! 2060: ! 2061: switch(REG8(AL)) { ! 2062: case 0x00: ! 2063: case 0x01: ! 2064: if(mem[0x462] == REG8(BH)) { ! 2065: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 2066: GetConsoleScreenBufferInfo(hStdout, &csbi); ! 2067: SetConsoleCursorPosition(hStdout, co); ! 2068: ! 2069: if(csbi.wAttributes != REG8(BL)) { ! 2070: SetConsoleTextAttribute(hStdout, REG8(BL)); ! 2071: } ! 2072: for(int i = 0; i < REG16(CX); i++) { ! 2073: msdos_putch(mem[ofs++]); ! 2074: } ! 2075: if(csbi.wAttributes != REG8(BL)) { ! 2076: SetConsoleTextAttribute(hStdout, csbi.wAttributes); ! 2077: } ! 2078: if(REG8(AL) == 0x00) { ! 2079: co.X = mem[0x450 + (REG8(BH) & 7) * 2]; ! 2080: co.Y = mem[0x451 + (REG8(BH) & 7) * 2]; ! 2081: SetConsoleCursorPosition(hStdout, co); ! 2082: } else { ! 2083: cursor_moved = true; ! 2084: } ! 2085: } else { ! 2086: cpustate->CF = 1; ! 2087: } ! 2088: break; ! 2089: case 0x02: ! 2090: case 0x03: ! 2091: if(mem[0x462] == REG8(BH)) { ! 2092: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 2093: GetConsoleScreenBufferInfo(hStdout, &csbi); ! 2094: SetConsoleCursorPosition(hStdout, co); ! 2095: ! 2096: WORD wAttributes = csbi.wAttributes; ! 2097: for(int i = 0; i < REG16(CX); i++, ofs += 2) { ! 2098: if(wAttributes != mem[ofs + 1]) { ! 2099: SetConsoleTextAttribute(hStdout, mem[ofs + 1]); ! 2100: wAttributes = mem[ofs + 1]; ! 2101: } ! 2102: msdos_putch(mem[ofs]); ! 2103: } ! 2104: if(csbi.wAttributes != wAttributes) { ! 2105: SetConsoleTextAttribute(hStdout, csbi.wAttributes); ! 2106: } ! 2107: if(REG8(AL) == 0x02) { ! 2108: co.X = mem[0x450 + (REG8(BH) & 7) * 2]; ! 2109: co.Y = mem[0x451 + (REG8(BH) & 7) * 2]; ! 2110: SetConsoleCursorPosition(hStdout, co); ! 2111: } else { ! 2112: cursor_moved = true; ! 2113: } ! 2114: } else { ! 2115: cpustate->CF = 1; ! 2116: } ! 2117: break; ! 2118: case 0x10: ! 2119: case 0x11: ! 2120: if(mem[0x462] == REG8(BH)) { ! 2121: ReadConsoleOutputCharacter(hStdout, scr_char, REG16(CX), co, &num); ! 2122: ReadConsoleOutputAttribute(hStdout, scr_attr, REG16(CX), co, &num); ! 2123: for(int i = 0; i < num; i++) { ! 2124: mem[ofs++] = scr_char[i]; ! 2125: mem[ofs++] = scr_attr[i]; ! 2126: if(REG8(AL) == 0x11) { ! 2127: mem[ofs++] = 0; ! 2128: mem[ofs++] = 0; ! 2129: } ! 2130: } ! 2131: } else { ! 2132: for(int i = 0, src = get_tvram_address(REG8(BH), co.X, co.Y); i < REG16(CX); i++) { ! 2133: mem[ofs++] = mem[src++]; ! 2134: mem[ofs++] = mem[src++]; ! 2135: if(REG8(AL) == 0x11) { ! 2136: mem[ofs++] = 0; ! 2137: mem[ofs++] = 0; ! 2138: } ! 2139: if(++co.X == 80) { ! 2140: if(++co.Y == 25) { ! 2141: break; ! 2142: } ! 2143: co.X = 0; ! 2144: } ! 2145: } ! 2146: } ! 2147: break; ! 2148: case 0x20: ! 2149: case 0x21: ! 2150: if(mem[0x462] == REG8(BH)) { ! 2151: for(int i = 0; i < REG16(CX) && i < 80 * 25; i++) { ! 2152: scr_char[i] = mem[ofs++]; ! 2153: scr_attr[i] = mem[ofs++]; ! 2154: if(REG8(AL) == 0x21) { ! 2155: ofs += 2; ! 2156: } ! 2157: } ! 2158: WriteConsoleOutputCharacter(hStdout, scr_char, REG16(CX), co, &num); ! 2159: WriteConsoleOutputAttribute(hStdout, scr_attr, REG16(CX), co, &num); ! 2160: } else { ! 2161: for(int i = 0, dest = get_tvram_address(REG8(BH), co.X, co.Y); i < REG16(CX); i++) { ! 2162: mem[dest++] = mem[ofs++]; ! 2163: mem[dest++] = mem[ofs++]; ! 2164: if(REG8(AL) == 0x21) { ! 2165: ofs += 2; ! 2166: } ! 2167: if(++co.X == 80) { ! 2168: if(++co.Y == 25) { ! 2169: break; ! 2170: } ! 2171: co.X = 0; ! 2172: } ! 2173: } ! 2174: } ! 2175: break; ! 2176: default: ! 2177: cpustate->CF = 1; ! 2178: break; ! 2179: } ! 2180: } ! 2181: ! 2182: inline void pcbios_int_10h_1dh() ! 2183: { ! 2184: switch(REG8(AL)) { ! 2185: case 0x01: ! 2186: break; ! 2187: case 0x02: ! 2188: REG16(BX) = 0; ! 2189: break; ! 2190: default: ! 2191: cpustate->CF = 1; ! 2192: break; ! 2193: } ! 2194: } ! 2195: ! 2196: inline void pcbios_int_10h_82h() ! 2197: { ! 2198: static UINT8 mode = 0; ! 2199: ! 2200: switch(REG8(AL)) { ! 2201: case 0: ! 2202: if(REG8(BL) != 0xff) { ! 2203: mode = REG8(BL); ! 2204: } ! 2205: REG8(AL) = mode; ! 2206: break; ! 2207: default: ! 2208: cpustate->CF = 1; ! 2209: break; ! 2210: } ! 2211: } ! 2212: ! 2213: inline void pcbios_int_10h_feh() ! 2214: { ! 2215: if(mem[0x449] == 0x03 || mem[0x449] == 0x70 || mem[0x449] == 0x71 || mem[0x449] == 0x73) { ! 2216: cpustate->sreg[ES].selector = (TVRAM_TOP >> 4); ! 2217: i386_load_segment_descriptor(cpustate, ES); ! 2218: REG16(DI) = (TVRAM_TOP & 0x0f); ! 2219: } ! 2220: int_10h_feh_called = true; ! 2221: } ! 2222: ! 2223: inline void pcbios_int_10h_ffh() ! 2224: { ! 2225: if(mem[0x449] == 0x03 || mem[0x449] == 0x70 || mem[0x449] == 0x71 || mem[0x449] == 0x73) { ! 2226: COORD co; ! 2227: DWORD num; ! 2228: ! 2229: co.X = (REG16(DI) >> 1) % 80; ! 2230: co.Y = (REG16(DI) >> 1) / 80; ! 2231: for(int i = 0, ofs = get_tvram_address(0, co.X, co.Y); i < REG16(CX) && i < 80 * 25; i++) { ! 2232: scr_char[i] = mem[ofs++]; ! 2233: scr_attr[i] = mem[ofs++]; ! 2234: } ! 2235: WriteConsoleOutputCharacter(hStdout, scr_char, REG16(CX), co, &num); ! 2236: WriteConsoleOutputAttribute(hStdout, scr_attr, REG16(CX), co, &num); ! 2237: } ! 2238: int_10h_ffh_called = true; ! 2239: } ! 2240: ! 2241: inline void pcbios_int_15h_23h() ! 2242: { ! 2243: switch(REG8(AL)) { ! 2244: case 0: ! 2245: REG8(CL) = cmos[0x2d]; ! 2246: REG8(CH) = cmos[0x2e]; ! 2247: break; ! 2248: case 1: ! 2249: cmos[0x2d] = REG8(CL); ! 2250: cmos[0x2e] = REG8(CH); ! 2251: break; ! 2252: default: ! 2253: REG8(AH) = 0x86; ! 2254: cpustate->CF = 1; ! 2255: break; ! 2256: } ! 2257: } ! 2258: ! 2259: inline void pcbios_int_15h_24h() ! 2260: { ! 2261: switch(REG8(AL)) { ! 2262: case 0: ! 2263: i386_set_a20_line(cpustate, 0); ! 2264: REG8(AH) = 0; ! 2265: break; ! 2266: case 1: ! 2267: i386_set_a20_line(cpustate, 1); ! 2268: REG8(AH) = 0; ! 2269: break; ! 2270: case 2: ! 2271: REG8(AH) = 0; ! 2272: REG8(AL) = (cpustate->a20_mask >> 20) & 1; ! 2273: REG16(CX) = 0; ! 2274: break; ! 2275: case 3: ! 2276: REG16(AX) = 0; ! 2277: REG16(BX) = 0; ! 2278: break; ! 2279: } ! 2280: } ! 2281: ! 2282: inline void pcbios_int_15h_49h() ! 2283: { ! 2284: REG8(AL) = 0; ! 2285: REG8(BL) = 0; // DOS/V; ! 2286: } ! 2287: ! 2288: inline void pcbios_int_15h_86h() ! 2289: { ! 2290: UINT32 usec = (REG16(CX) << 16) | REG16(DX); ! 2291: Sleep(usec / 1000); ! 2292: } ! 2293: ! 2294: inline void pcbios_int_15h_87h() ! 2295: { ! 2296: #if 1 ! 2297: // copy extended memory (from DOSBox) ! 2298: int len = REG16(CX) * 2; ! 2299: int ofs = cpustate->sreg[ES].base + REG16(SI); ! 2300: int src = (*(UINT32 *)(mem + ofs + 0x12) & 0xffffff); // + (mem[ofs + 0x16] << 24); ! 2301: int dst = (*(UINT32 *)(mem + ofs + 0x1a) & 0xffffff); // + (mem[ofs + 0x1e] << 24); ! 2302: memcpy(mem + dst, mem + src, len); ! 2303: REG16(AX) = 0x00; ! 2304: #else ! 2305: REG8(AH) = 0x86; ! 2306: cpustate->CF = 1; ! 2307: #endif ! 2308: } ! 2309: ! 2310: inline void pcbios_int_15h_88h() ! 2311: { ! 2312: REG16(AX) = ((min(MAX_MEM, 0x1000000) - 0x100000) >> 10); ! 2313: } ! 2314: ! 2315: inline void pcbios_int_15h_89h() ! 2316: { ! 2317: #if 1 ! 2318: // switch to protected mode (from DOSBox) ! 2319: write_io_byte(0x20, 0x10); ! 2320: write_io_byte(0x21, REG8(BH)); ! 2321: write_io_byte(0x21, 0x00); ! 2322: write_io_byte(0xa0, 0x10); ! 2323: write_io_byte(0xa1, REG8(BL)); ! 2324: write_io_byte(0xa1, 0x00); ! 2325: i386_set_a20_line(cpustate, 1); ! 2326: int ofs = cpustate->sreg[ES].base + REG16(SI); ! 2327: cpustate->gdtr.limit = *(UINT16 *)(mem + ofs + 0x08); ! 2328: cpustate->gdtr.base = *(UINT32 *)(mem + ofs + 0x08 + 0x02) & 0xffffff; ! 2329: cpustate->idtr.limit = *(UINT16 *)(mem + ofs + 0x10); ! 2330: cpustate->idtr.base = *(UINT32 *)(mem + ofs + 0x10 + 0x02) & 0xffffff; ! 2331: cpustate->cr[0] |= 1; ! 2332: cpustate->sreg[DS].selector = 0x18; ! 2333: cpustate->sreg[ES].selector = 0x20; ! 2334: cpustate->sreg[SS].selector = 0x28; ! 2335: i386_load_segment_descriptor(cpustate, DS); ! 2336: i386_load_segment_descriptor(cpustate, ES); ! 2337: i386_load_segment_descriptor(cpustate, SS); ! 2338: REG16(SP) += 6; ! 2339: set_flags(cpustate, 0); // ??? ! 2340: REG16(AX) = 0x00; ! 2341: i386_jmp_far(0x30, REG16(CX)); ! 2342: #else ! 2343: REG8(AH) = 0x86; ! 2344: cpustate->CF = 1; ! 2345: #endif ! 2346: } ! 2347: ! 2348: inline void pcbios_int_15h_c9h() ! 2349: { ! 2350: REG8(AH) = 0x00; ! 2351: REG8(CH) = cpu_type; ! 2352: REG8(CL) = cpu_step; ! 2353: } ! 2354: ! 2355: inline void pcbios_int_15h_cah() ! 2356: { ! 2357: switch(REG8(AL)) { ! 2358: case 0: ! 2359: if(REG8(BL) > 0x3f) { ! 2360: REG8(AH) = 0x03; ! 2361: cpustate->CF = 1; ! 2362: } else if(REG8(BL) < 0x0e) { ! 2363: REG8(AH) = 0x04; ! 2364: cpustate->CF = 1; ! 2365: } else { ! 2366: REG8(CL) = cmos[REG8(BL)]; ! 2367: } ! 2368: break; ! 2369: case 1: ! 2370: if(REG8(BL) > 0x3f) { ! 2371: REG8(AH) = 0x03; ! 2372: cpustate->CF = 1; ! 2373: } else if(REG8(BL) < 0x0e) { ! 2374: REG8(AH) = 0x04; ! 2375: cpustate->CF = 1; ! 2376: } else { ! 2377: cmos[REG8(BL)] = REG8(CL); ! 2378: } ! 2379: break; ! 2380: default: ! 2381: REG8(AH) = 0x86; ! 2382: cpustate->CF = 1; ! 2383: break; ! 2384: } ! 2385: } ! 2386: ! 2387: UINT32 get_key_code(bool clear_buffer) ! 2388: { ! 2389: UINT32 code = 0; ! 2390: ! 2391: if(key_buf_char->count() == 0) { ! 2392: update_key_buffer(); ! 2393: } ! 2394: if(!clear_buffer) { ! 2395: key_buf_char->store_buffer(); ! 2396: key_buf_scan->store_buffer(); ! 2397: } ! 2398: if(key_buf_char->count() != 0) { ! 2399: code = key_buf_char->read() | (key_buf_scan->read() << 8); ! 2400: } ! 2401: if(key_buf_char->count() != 0) { ! 2402: code |= (key_buf_char->read() << 16) | (key_buf_scan->read() << 24); ! 2403: } ! 2404: if(!clear_buffer) { ! 2405: key_buf_char->restore_buffer(); ! 2406: key_buf_scan->restore_buffer(); ! 2407: } ! 2408: return code; ! 2409: } ! 2410: ! 2411: inline void pcbios_int_16h_00h() ! 2412: { ! 2413: static UINT32 key_code = 0; ! 2414: ! 2415: while(key_code == 0) { ! 2416: key_code = get_key_code(true); ! 2417: } ! 2418: if((key_code & 0xffff) == 0x0000 || (key_code & 0xffff) == 0xe000) { ! 2419: if(REG8(AH) == 0x10) { ! 2420: key_code = ((key_code >> 8) & 0xff) | ((key_code >> 16) & 0xff00); ! 2421: } else { ! 2422: key_code = ((key_code >> 16) & 0xff00); ! 2423: } ! 2424: } ! 2425: REG16(AX) = key_code & 0xffff; ! 2426: key_code >>= 16; ! 2427: } ! 2428: ! 2429: inline void pcbios_int_16h_01h() ! 2430: { ! 2431: UINT32 key_code = get_key_code(false); ! 2432: ! 2433: if(key_code != 0) { ! 2434: if((key_code & 0xffff) == 0x0000 || (key_code & 0xffff) == 0xe000) { ! 2435: if(REG8(AH) == 0x11) { ! 2436: key_code = ((key_code >> 8) & 0xff) | ((key_code >> 16) & 0xff00); ! 2437: } else { ! 2438: key_code = ((key_code >> 16) & 0xff00); ! 2439: } ! 2440: } ! 2441: } ! 2442: if(key_code != 0) { ! 2443: REG16(AX) = key_code & 0xffff; ! 2444: } ! 2445: cpustate->ZF = (key_code == 0); ! 2446: } ! 2447: ! 2448: inline void pcbios_int_16h_02h() ! 2449: { ! 2450: REG8(AL) = (GetAsyncKeyState(VK_INSERT ) & 0x0001) ? 0x80 : 0; ! 2451: REG8(AL) |= (GetAsyncKeyState(VK_CAPITAL) & 0x0001) ? 0x40 : 0; ! 2452: REG8(AL) |= (GetAsyncKeyState(VK_NUMLOCK) & 0x0001) ? 0x20 : 0; ! 2453: REG8(AL) |= (GetAsyncKeyState(VK_SCROLL ) & 0x0001) ? 0x10 : 0; ! 2454: REG8(AL) |= (GetAsyncKeyState(VK_MENU ) & 0x8000) ? 0x08 : 0; ! 2455: REG8(AL) |= (GetAsyncKeyState(VK_CONTROL) & 0x8000) ? 0x04 : 0; ! 2456: REG8(AL) |= (GetAsyncKeyState(VK_LSHIFT ) & 0x8000) ? 0x02 : 0; ! 2457: REG8(AL) |= (GetAsyncKeyState(VK_RSHIFT ) & 0x8000) ? 0x01 : 0; ! 2458: } ! 2459: ! 2460: inline void pcbios_int_16h_03h() ! 2461: { ! 2462: static UINT16 status = 0; ! 2463: ! 2464: switch(REG8(AL)) { ! 2465: case 0x05: ! 2466: status = REG16(BX); ! 2467: break; ! 2468: case 0x06: ! 2469: REG16(BX) = status; ! 2470: break; ! 2471: default: ! 2472: cpustate->CF = 1; ! 2473: break; ! 2474: } ! 2475: } ! 2476: ! 2477: inline void pcbios_int_16h_05h() ! 2478: { ! 2479: _ungetch(REG8(CL)); ! 2480: REG8(AL) = 0x00; ! 2481: } ! 2482: ! 2483: inline void pcbios_int_16h_12h() ! 2484: { ! 2485: pcbios_int_16h_02h(); ! 2486: ! 2487: REG8(AH) = 0;//(GetAsyncKeyState(VK_SYSREQ ) & 0x8000) ? 0x80 : 0; ! 2488: REG8(AH) |= (GetAsyncKeyState(VK_CAPITAL ) & 0x8000) ? 0x40 : 0; ! 2489: REG8(AH) |= (GetAsyncKeyState(VK_NUMLOCK ) & 0x8000) ? 0x20 : 0; ! 2490: REG8(AH) |= (GetAsyncKeyState(VK_SCROLL ) & 0x8000) ? 0x10 : 0; ! 2491: REG8(AH) |= (GetAsyncKeyState(VK_RMENU ) & 0x8000) ? 0x08 : 0; ! 2492: REG8(AH) |= (GetAsyncKeyState(VK_RCONTROL) & 0x8000) ? 0x04 : 0; ! 2493: REG8(AH) |= (GetAsyncKeyState(VK_LMENU ) & 0x8000) ? 0x02 : 0; ! 2494: REG8(AH) |= (GetAsyncKeyState(VK_LCONTROL) & 0x8000) ? 0x01 : 0; ! 2495: } ! 2496: ! 2497: inline void pcbios_int_16h_13h() ! 2498: { ! 2499: static UINT16 status = 0; ! 2500: ! 2501: switch(REG8(AL)) { ! 2502: case 0x00: ! 2503: status = REG16(DX); ! 2504: break; ! 2505: case 0x01: ! 2506: REG16(DX) = status; ! 2507: break; ! 2508: default: ! 2509: cpustate->CF = 1; ! 2510: break; ! 2511: } ! 2512: } ! 2513: ! 2514: inline void pcbios_int_16h_14h() ! 2515: { ! 2516: static UINT8 status = 0; ! 2517: ! 2518: switch(REG8(AL)) { ! 2519: case 0x00: ! 2520: case 0x01: ! 2521: status = REG8(AL); ! 2522: break; ! 2523: case 0x02: ! 2524: REG8(AL) = status; ! 2525: break; ! 2526: default: ! 2527: cpustate->CF = 1; ! 2528: break; ! 2529: } ! 2530: } ! 2531: ! 2532: inline void pcbios_int_1ah_00h() ! 2533: { ! 2534: static WORD prev_day = 0; ! 2535: SYSTEMTIME time; ! 2536: ! 2537: GetLocalTime(&time); ! 2538: unsigned __int64 msec = ((time.wHour * 60 + time.wMinute) * 60 + time.wSecond) * 1000 + time.wMilliseconds; ! 2539: unsigned __int64 tick = msec * 0x1800b0 / 24 / 60 / 60 / 1000; ! 2540: REG16(CX) = (tick >> 16) & 0xffff; ! 2541: REG16(DX) = (tick ) & 0xffff; ! 2542: REG8(AL) = (prev_day != 0 && prev_day != time.wDay) ? 1 : 0; ! 2543: prev_day = time.wDay; ! 2544: } ! 2545: ! 2546: inline int to_bcd(int t) ! 2547: { ! 2548: int u = (t % 100) / 10; ! 2549: return (u << 4) | (t % 10); ! 2550: } ! 2551: ! 2552: inline void pcbios_int_1ah_02h() ! 2553: { ! 2554: SYSTEMTIME time; ! 2555: ! 2556: GetLocalTime(&time); ! 2557: REG8(CH) = to_bcd(time.wHour); ! 2558: REG8(CL) = to_bcd(time.wMinute); ! 2559: REG8(DH) = to_bcd(time.wSecond); ! 2560: REG8(DL) = 0x00; ! 2561: } ! 2562: ! 2563: inline void pcbios_int_1ah_04h() ! 2564: { ! 2565: SYSTEMTIME time; ! 2566: ! 2567: GetLocalTime(&time); ! 2568: REG8(CH) = to_bcd(time.wYear / 100); ! 2569: REG8(CL) = to_bcd(time.wYear); ! 2570: REG8(DH) = to_bcd(time.wMonth); ! 2571: REG8(DL) = to_bcd(time.wDay); ! 2572: } ! 2573: ! 2574: inline void pcbios_int_1ah_0ah() ! 2575: { ! 2576: SYSTEMTIME time; ! 2577: FILETIME file_time; ! 2578: WORD dos_date, dos_time; ! 2579: ! 2580: GetLocalTime(&time); ! 2581: SystemTimeToFileTime(&time, &file_time); ! 2582: FileTimeToDosDateTime(&file_time, &dos_date, &dos_time); ! 2583: REG16(CX) = dos_date; ! 2584: } ! 2585: ! 2586: // msdos system call ! 2587: ! 2588: inline void msdos_int_21h_00h() ! 2589: { ! 2590: msdos_process_terminate(cpustate->sreg[CS].selector, retval, 1); ! 2591: } ! 2592: ! 2593: inline void msdos_int_21h_01h() ! 2594: { ! 2595: REG8(AL) = msdos_getche(); ! 2596: #ifdef SUPPORT_HARDWARE ! 2597: hardware_update(); ! 2598: #endif ! 2599: } ! 2600: ! 2601: inline void msdos_int_21h_02h() ! 2602: { ! 2603: msdos_putch(REG8(DL)); ! 2604: } ! 2605: ! 2606: inline void msdos_int_21h_03h() ! 2607: { ! 2608: REG8(AL) = msdos_aux_in(); ! 2609: } ! 2610: ! 2611: inline void msdos_int_21h_04h() ! 2612: { ! 2613: msdos_aux_out(REG8(DL)); ! 2614: } ! 2615: ! 2616: inline void msdos_int_21h_05h() ! 2617: { ! 2618: msdos_prn_out(REG8(DL)); ! 2619: } ! 2620: ! 2621: inline void msdos_int_21h_06h() ! 2622: { ! 2623: if(REG8(DL) == 0xff) { ! 2624: if(msdos_kbhit()) { ! 2625: REG8(AL) = msdos_getch(); ! 2626: cpustate->ZF = 0; ! 2627: } else { ! 2628: REG8(AL) = 0; ! 2629: cpustate->ZF = 1; ! 2630: Sleep(10); ! 2631: } ! 2632: } else { ! 2633: msdos_putch(REG8(DL)); ! 2634: } ! 2635: } ! 2636: ! 2637: inline void msdos_int_21h_07h() ! 2638: { ! 2639: REG8(AL) = msdos_getch(); ! 2640: #ifdef SUPPORT_HARDWARE ! 2641: hardware_update(); ! 2642: #endif ! 2643: } ! 2644: ! 2645: inline void msdos_int_21h_08h() ! 2646: { ! 2647: REG8(AL) = msdos_getch(); ! 2648: #ifdef SUPPORT_HARDWARE ! 2649: hardware_update(); ! 2650: #endif ! 2651: } ! 2652: ! 2653: inline void msdos_int_21h_09h() ! 2654: { ! 2655: char tmp[0x10000]; ! 2656: memcpy(tmp, mem + cpustate->sreg[DS].base + REG16(DX), sizeof(tmp)); ! 2657: tmp[sizeof(tmp) - 1] = '\0'; ! 2658: int len = strlen(my_strtok(tmp, "$")); ! 2659: ! 2660: if(file_handler[1].valid && !file_handler[1].atty) { ! 2661: // stdout is redirected to file ! 2662: msdos_write(1, tmp, len); ! 2663: } else { ! 2664: for(int i = 0; i < len; i++) { ! 2665: msdos_putch(tmp[i]); ! 2666: } ! 2667: } ! 2668: } ! 2669: ! 2670: inline void msdos_int_21h_0ah() ! 2671: { ! 2672: int ofs = cpustate->sreg[DS].base + REG16(DX); ! 2673: int max = mem[ofs] - 1; ! 2674: UINT8 *buf = mem + ofs + 2; ! 2675: int chr, p = 0; ! 2676: ! 2677: while((chr = msdos_getch()) != 0x0d) { ! 2678: if(chr == 0x00) { ! 2679: // skip 2nd byte ! 2680: msdos_getch(); ! 2681: } else if(chr == 0x08) { ! 2682: // back space ! 2683: if(p > 0) { ! 2684: p--; ! 2685: msdos_putch(chr); ! 2686: msdos_putch(' '); ! 2687: msdos_putch(chr); ! 2688: } ! 2689: } else if(p < max) { ! 2690: buf[p++] = chr; ! 2691: msdos_putch(chr); ! 2692: } ! 2693: } ! 2694: buf[p] = 0x0d; ! 2695: mem[ofs + 1] = p; ! 2696: #ifdef SUPPORT_HARDWARE ! 2697: hardware_update(); ! 2698: #endif ! 2699: } ! 2700: ! 2701: inline void msdos_int_21h_0bh() ! 2702: { ! 2703: if(msdos_kbhit()) { ! 2704: REG8(AL) = 0xff; ! 2705: } else { ! 2706: REG8(AL) = 0x00; ! 2707: Sleep(10); ! 2708: } ! 2709: } ! 2710: ! 2711: inline void msdos_int_21h_0ch() ! 2712: { ! 2713: // clear key buffer ! 2714: if(file_handler[0].valid && !file_handler[0].atty) { ! 2715: // stdin is redirected to file ! 2716: } else { ! 2717: while(msdos_kbhit()) { ! 2718: msdos_getch(); ! 2719: } ! 2720: } ! 2721: ! 2722: switch(REG8(AL)) { ! 2723: case 0x01: ! 2724: msdos_int_21h_01h(); ! 2725: break; ! 2726: case 0x06: ! 2727: msdos_int_21h_06h(); ! 2728: break; ! 2729: case 0x07: ! 2730: msdos_int_21h_07h(); ! 2731: break; ! 2732: case 0x08: ! 2733: msdos_int_21h_08h(); ! 2734: break; ! 2735: case 0x0a: ! 2736: msdos_int_21h_0ah(); ! 2737: break; ! 2738: default: ! 2739: REG16(AX) = 0x01; ! 2740: cpustate->CF = 1; ! 2741: break; ! 2742: } ! 2743: } ! 2744: ! 2745: inline void msdos_int_21h_0dh() ! 2746: { ! 2747: } ! 2748: ! 2749: inline void msdos_int_21h_0eh() ! 2750: { ! 2751: if(REG8(DL) < 26) { ! 2752: _chdrive(REG8(DL) + 1); ! 2753: msdos_cds_update(REG8(DL)); ! 2754: } ! 2755: REG8(AL) = 26; // zdrive ! 2756: } ! 2757: ! 2758: inline void msdos_int_21h_11h() ! 2759: { ! 2760: ext_fcb_t *ext_fcb = (ext_fcb_t *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 2761: fcb_t *fcb = (fcb_t *)(mem + cpustate->sreg[DS].base + REG16(DX) + (ext_fcb->flag == 0xff ? 7 : 0)); ! 2762: ! 2763: process_t *process = msdos_process_info_get(current_psp); ! 2764: ext_fcb_t *ext_find = (ext_fcb_t *)(mem + (process->dta.w.h << 4) + process->dta.w.l); ! 2765: find_fcb_t *find = (find_fcb_t *)(mem + (process->dta.w.h << 4) + process->dta.w.l + (ext_fcb->flag == 0xff ? 7 : 0)); ! 2766: char *path = msdos_fcb_path(fcb); ! 2767: WIN32_FIND_DATA fd; ! 2768: ! 2769: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 2770: FindClose(process->find_handle); ! 2771: process->find_handle = INVALID_HANDLE_VALUE; ! 2772: } ! 2773: strcpy(process->volume_label, msdos_volume_label(path)); ! 2774: process->allowable_mask = (ext_fcb->flag == 0xff) ? ext_fcb->attribute : 0x20; ! 2775: ! 2776: if((process->allowable_mask & 8) && !msdos_match_volume_label(path, msdos_short_volume_label(process->volume_label))) { ! 2777: process->allowable_mask &= ~8; ! 2778: } ! 2779: if((process->find_handle = FindFirstFile(path, &fd)) != INVALID_HANDLE_VALUE) { ! 2780: while(!msdos_find_file_check_attribute(fd.dwFileAttributes, process->allowable_mask, 0)) { ! 2781: if(!FindNextFile(process->find_handle, &fd)) { ! 2782: FindClose(process->find_handle); ! 2783: process->find_handle = INVALID_HANDLE_VALUE; ! 2784: break; ! 2785: } ! 2786: } ! 2787: } ! 2788: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 2789: if(ext_fcb->flag == 0xff) { ! 2790: ext_find->flag = 0xff; ! 2791: memset(ext_find->reserved, 0, 5); ! 2792: ext_find->attribute = (UINT8)(fd.dwFileAttributes & 0x3f); ! 2793: } ! 2794: find->drive = _getdrive(); ! 2795: msdos_set_fcb_path((fcb_t *)find, msdos_short_path(fd.cFileName)); ! 2796: find->attribute = (UINT8)(fd.dwFileAttributes & 0x3f); ! 2797: find->nt_res = 0; ! 2798: msdos_find_file_conv_local_time(&fd); ! 2799: find->create_time_ms = 0; ! 2800: FileTimeToDosDateTime(&fd.ftCreationTime, &find->creation_date, &find->creation_time); ! 2801: FileTimeToDosDateTime(&fd.ftLastAccessTime, &find->last_access_date, &find->last_write_time); ! 2802: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->last_write_date, &find->last_write_time); ! 2803: find->cluster_hi = find->cluster_lo = 0; ! 2804: find->file_size = fd.nFileSizeLow; ! 2805: REG8(AL) = 0x00; ! 2806: } else if(process->allowable_mask & 8) { ! 2807: if(ext_fcb->flag == 0xff) { ! 2808: ext_find->flag = 0xff; ! 2809: memset(ext_find->reserved, 0, 5); ! 2810: ext_find->attribute = 8; ! 2811: } ! 2812: find->drive = _getdrive(); ! 2813: msdos_set_fcb_path((fcb_t *)find, msdos_short_volume_label(process->volume_label)); ! 2814: find->attribute = 8; ! 2815: find->nt_res = 0; ! 2816: msdos_find_file_conv_local_time(&fd); ! 2817: find->create_time_ms = 0; ! 2818: FileTimeToDosDateTime(&fd.ftCreationTime, &find->creation_date, &find->creation_time); ! 2819: FileTimeToDosDateTime(&fd.ftLastAccessTime, &find->last_access_date, &find->last_write_time); ! 2820: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->last_write_date, &find->last_write_time); ! 2821: find->cluster_hi = find->cluster_lo = 0; ! 2822: find->file_size = 0; ! 2823: process->allowable_mask &= ~8; ! 2824: REG8(AL) = 0x00; ! 2825: } else { ! 2826: REG8(AL) = 0xff; ! 2827: } ! 2828: } ! 2829: ! 2830: inline void msdos_int_21h_12h() ! 2831: { ! 2832: ext_fcb_t *ext_fcb = (ext_fcb_t *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 2833: fcb_t *fcb = (fcb_t *)(mem + cpustate->sreg[DS].base + REG16(DX) + (ext_fcb->flag == 0xff ? 7 : 0)); ! 2834: ! 2835: process_t *process = msdos_process_info_get(current_psp); ! 2836: ext_fcb_t *ext_find = (ext_fcb_t *)(mem + (process->dta.w.h << 4) + process->dta.w.l); ! 2837: find_fcb_t *find = (find_fcb_t *)(mem + (process->dta.w.h << 4) + process->dta.w.l + (ext_fcb->flag == 0xff ? 7 : 0)); ! 2838: WIN32_FIND_DATA fd; ! 2839: ! 2840: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 2841: if(FindNextFile(process->find_handle, &fd)) { ! 2842: while(!msdos_find_file_check_attribute(fd.dwFileAttributes, process->allowable_mask, 0)) { ! 2843: if(!FindNextFile(process->find_handle, &fd)) { ! 2844: FindClose(process->find_handle); ! 2845: process->find_handle = INVALID_HANDLE_VALUE; ! 2846: break; ! 2847: } ! 2848: } ! 2849: } else { ! 2850: FindClose(process->find_handle); ! 2851: process->find_handle = INVALID_HANDLE_VALUE; ! 2852: } ! 2853: } ! 2854: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 2855: if(ext_fcb->flag == 0xff) { ! 2856: ext_find->flag = 0xff; ! 2857: memset(ext_find->reserved, 0, 5); ! 2858: ext_find->attribute = (UINT8)(fd.dwFileAttributes & 0x3f); ! 2859: } ! 2860: find->drive = _getdrive(); ! 2861: msdos_set_fcb_path((fcb_t *)find, msdos_short_path(fd.cFileName)); ! 2862: find->attribute = (UINT8)(fd.dwFileAttributes & 0x3f); ! 2863: find->nt_res = 0; ! 2864: msdos_find_file_conv_local_time(&fd); ! 2865: find->create_time_ms = 0; ! 2866: FileTimeToDosDateTime(&fd.ftCreationTime, &find->creation_date, &find->creation_time); ! 2867: FileTimeToDosDateTime(&fd.ftLastAccessTime, &find->last_access_date, &find->last_write_time); ! 2868: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->last_write_date, &find->last_write_time); ! 2869: find->cluster_hi = find->cluster_lo = 0; ! 2870: find->file_size = fd.nFileSizeLow; ! 2871: REG8(AL) = 0x00; ! 2872: } else if(process->allowable_mask & 8) { ! 2873: if(ext_fcb->flag == 0xff) { ! 2874: ext_find->flag = 0xff; ! 2875: memset(ext_find->reserved, 0, 5); ! 2876: ext_find->attribute = 8; ! 2877: } ! 2878: find->drive = _getdrive(); ! 2879: msdos_set_fcb_path((fcb_t *)find, msdos_short_volume_label(process->volume_label)); ! 2880: find->attribute = 8; ! 2881: find->nt_res = 0; ! 2882: msdos_find_file_conv_local_time(&fd); ! 2883: find->create_time_ms = 0; ! 2884: FileTimeToDosDateTime(&fd.ftCreationTime, &find->creation_date, &find->creation_time); ! 2885: FileTimeToDosDateTime(&fd.ftLastAccessTime, &find->last_access_date, &find->last_write_time); ! 2886: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->last_write_date, &find->last_write_time); ! 2887: find->cluster_hi = find->cluster_lo = 0; ! 2888: find->file_size = 0; ! 2889: process->allowable_mask &= ~8; ! 2890: REG8(AL) = 0x00; ! 2891: } else { ! 2892: REG8(AL) = 0xff; ! 2893: } ! 2894: } ! 2895: ! 2896: inline void msdos_int_21h_13h() ! 2897: { ! 2898: if(remove(msdos_fcb_path((fcb_t *)(mem + cpustate->sreg[DS].base + REG16(DX))))) { ! 2899: REG8(AL) = 0xff; ! 2900: } else { ! 2901: REG8(AL) = 0x00; ! 2902: } ! 2903: } ! 2904: ! 2905: inline void msdos_int_21h_18h() ! 2906: { ! 2907: REG8(AL) = 0x00; ! 2908: } ! 2909: ! 2910: inline void msdos_int_21h_19h() ! 2911: { ! 2912: REG8(AL) = _getdrive() - 1; ! 2913: } ! 2914: ! 2915: inline void msdos_int_21h_1ah() ! 2916: { ! 2917: process_t *process = msdos_process_info_get(current_psp); ! 2918: ! 2919: process->dta.w.l = REG16(DX); ! 2920: process->dta.w.h = cpustate->sreg[DS].selector; ! 2921: } ! 2922: ! 2923: inline void msdos_int_21h_1bh() ! 2924: { ! 2925: int drive_num = _getdrive() - 1; ! 2926: UINT16 seg, ofs; ! 2927: ! 2928: if(msdos_drive_param_block_update(drive_num, &seg, &ofs, 1)) { ! 2929: dpb_t *dpb = (dpb_t *)(mem + (seg << 4) + ofs); ! 2930: REG8(AL) = dpb->highest_sector_num + 1; ! 2931: REG16(CX) = dpb->bytes_per_sector; ! 2932: REG16(DX) = dpb->highest_cluster_num - 1; ! 2933: *(UINT8 *)(mem + cpustate->sreg[DS].base + REG16(BX)) = dpb->media_type; ! 2934: } else { ! 2935: REG8(AL) = 0xff; ! 2936: cpustate->CF = 1; ! 2937: } ! 2938: ! 2939: } ! 2940: ! 2941: inline void msdos_int_21h_1ch() ! 2942: { ! 2943: int drive_num = REG8(DL) ? (REG8(DL) - 1) : (_getdrive() - 1); ! 2944: UINT16 seg, ofs; ! 2945: ! 2946: if(msdos_drive_param_block_update(drive_num, &seg, &ofs, 1)) { ! 2947: dpb_t *dpb = (dpb_t *)(mem + (seg << 4) + ofs); ! 2948: REG8(AL) = dpb->highest_sector_num + 1; ! 2949: REG16(CX) = dpb->bytes_per_sector; ! 2950: REG16(DX) = dpb->highest_cluster_num - 1; ! 2951: *(UINT8 *)(mem + cpustate->sreg[DS].base + REG16(BX)) = dpb->media_type; ! 2952: } else { ! 2953: REG8(AL) = 0xff; ! 2954: cpustate->CF = 1; ! 2955: } ! 2956: ! 2957: } ! 2958: ! 2959: inline void msdos_int_21h_1dh() ! 2960: { ! 2961: REG8(AL) = 0; ! 2962: } ! 2963: ! 2964: inline void msdos_int_21h_1eh() ! 2965: { ! 2966: REG8(AL) = 0; ! 2967: } ! 2968: ! 2969: inline void msdos_int_21h_1fh() ! 2970: { ! 2971: int drive_num = _getdrive() - 1; ! 2972: UINT16 seg, ofs; ! 2973: ! 2974: if(msdos_drive_param_block_update(drive_num, &seg, &ofs, 1)) { ! 2975: REG8(AL) = 0; ! 2976: cpustate->sreg[DS].selector = seg; ! 2977: i386_load_segment_descriptor(cpustate, DS); ! 2978: REG16(BX) = ofs; ! 2979: } else { ! 2980: REG8(AL) = 0xff; ! 2981: cpustate->CF = 1; ! 2982: } ! 2983: } ! 2984: ! 2985: inline void msdos_int_21h_20h() ! 2986: { ! 2987: REG8(AL) = 0; ! 2988: } ! 2989: ! 2990: inline void msdos_int_21h_25h() ! 2991: { ! 2992: *(UINT16 *)(mem + 4 * REG8(AL) + 0) = REG16(DX); ! 2993: *(UINT16 *)(mem + 4 * REG8(AL) + 2) = cpustate->sreg[DS].selector; ! 2994: } ! 2995: ! 2996: inline void msdos_int_21h_26h() ! 2997: { ! 2998: psp_t *psp = (psp_t *)(mem + (REG16(DX) << 4)); ! 2999: ! 3000: memcpy(mem + (REG16(DX) << 4), mem + (current_psp << 4), sizeof(psp_t)); ! 3001: psp->first_mcb = REG16(DX) + 16; ! 3002: psp->int_22h.dw = *(UINT32 *)(mem + 4 * 0x22); ! 3003: psp->int_23h.dw = *(UINT32 *)(mem + 4 * 0x23); ! 3004: psp->int_24h.dw = *(UINT32 *)(mem + 4 * 0x24); ! 3005: psp->parent_psp = 0; ! 3006: } ! 3007: ! 3008: inline void msdos_int_21h_29h() ! 3009: { ! 3010: int ofs = cpustate->sreg[DS].base + REG16(SI); ! 3011: char name[MAX_PATH], ext[MAX_PATH]; ! 3012: UINT8 drv = 0; ! 3013: char sep_chars[] = ":.;,=+"; ! 3014: char end_chars[] = "\\<>|/\"[]"; ! 3015: char spc_chars[] = " \t"; ! 3016: ! 3017: if(REG8(AL) & 1) { ! 3018: ofs += strspn((char *)&mem[ofs], spc_chars); ! 3019: if(my_strchr(sep_chars, mem[ofs]) && mem[ofs] != '\0') { ! 3020: ofs++; ! 3021: } ! 3022: } ! 3023: ofs += strspn((char *)&mem[ofs], spc_chars); ! 3024: ! 3025: if(mem[ofs + 1] == ':') { ! 3026: UINT8 c = mem[ofs]; ! 3027: if(c <= 0x20 || my_strchr(end_chars, c) || my_strchr(sep_chars, c)) { ! 3028: ; // invalid drive letter ! 3029: } else { ! 3030: if(c >= 'a' && c <= 'z') { ! 3031: drv = c - 'a' + 1; ! 3032: } else { ! 3033: drv = c - 'A' + 1; ! 3034: } ! 3035: ofs += 2; ! 3036: } ! 3037: } ! 3038: memset(name, 0x20, sizeof(name)); ! 3039: memset(ext, 0x20, sizeof(ext)); ! 3040: for(int i = 0; i < MAX_PATH; i++) { ! 3041: UINT8 c = mem[ofs]; ! 3042: if(c <= 0x20 || my_strchr(end_chars, c) || my_strchr(sep_chars, c)) { ! 3043: break; ! 3044: } else if(c >= 'a' && c <= 'z') { ! 3045: c -= 0x20; ! 3046: } ! 3047: ofs++; ! 3048: name[i] = c; ! 3049: } ! 3050: if(mem[ofs] == '.') { ! 3051: ofs++; ! 3052: for(int i = 0; i < MAX_PATH; i++) { ! 3053: UINT8 c = mem[ofs]; ! 3054: if(c <= 0x20 || my_strchr(end_chars, c) || my_strchr(sep_chars, c)) { ! 3055: break; ! 3056: } else if(c >= 'a' && c <= 'z') { ! 3057: c -= 0x20; ! 3058: } ! 3059: ofs++; ! 3060: ext[i] = c; ! 3061: } ! 3062: } ! 3063: int si = ofs - cpustate->sreg[DS].base; ! 3064: int ds = cpustate->sreg[DS].selector; ! 3065: while(si > 0xffff) { ! 3066: si -= 0x10; ! 3067: ds++; ! 3068: } ! 3069: REG16(SI) = si; ! 3070: cpustate->sreg[DS].selector = ds; ! 3071: i386_load_segment_descriptor(cpustate, DS); ! 3072: ! 3073: UINT8 *fcb = mem + cpustate->sreg[ES].base + REG16(DI); ! 3074: fcb[0] = drv; ! 3075: memcpy(fcb + 1, name, 8); ! 3076: int found_star = 0; ! 3077: for(int i = 1; i < 1 + 8; i++) { ! 3078: if(fcb[i] == '*') { ! 3079: found_star = 1; ! 3080: } ! 3081: if(found_star) { ! 3082: fcb[i] = '?'; ! 3083: } ! 3084: } ! 3085: memcpy(fcb + 9, ext, 3); ! 3086: found_star = 0; ! 3087: for(int i = 9; i < 9 + 3; i++) { ! 3088: if(fcb[i] == '*') { ! 3089: found_star = 1; ! 3090: } ! 3091: if(found_star) { ! 3092: fcb[i] = '?'; ! 3093: } ! 3094: } ! 3095: ! 3096: REG8(AL) = 0x00; ! 3097: if(drv == 0 || (drv > 0 && drv <= 26 && (GetLogicalDrives() & ( 1 << (drv - 1) )))) { ! 3098: if(memchr(fcb + 1, '?', 8 + 3)) { ! 3099: REG8(AL) = 0x01; ! 3100: } ! 3101: } else { ! 3102: REG8(AL) = 0xff; ! 3103: } ! 3104: } ! 3105: ! 3106: inline void msdos_int_21h_2ah() ! 3107: { ! 3108: SYSTEMTIME sTime; ! 3109: ! 3110: GetLocalTime(&sTime); ! 3111: REG16(CX) = sTime.wYear; ! 3112: REG8(DH) = (UINT8)sTime.wMonth; ! 3113: REG8(DL) = (UINT8)sTime.wDay; ! 3114: REG8(AL) = (UINT8)sTime.wDayOfWeek; ! 3115: } ! 3116: ! 3117: inline void msdos_int_21h_2bh() ! 3118: { ! 3119: REG8(AL) = 0x00; ! 3120: } ! 3121: ! 3122: inline void msdos_int_21h_2ch() ! 3123: { ! 3124: SYSTEMTIME sTime; ! 3125: ! 3126: GetLocalTime(&sTime); ! 3127: REG8(CH) = (UINT8)sTime.wHour; ! 3128: REG8(CL) = (UINT8)sTime.wMinute; ! 3129: REG8(DH) = (UINT8)sTime.wSecond; ! 3130: } ! 3131: ! 3132: inline void msdos_int_21h_2dh() ! 3133: { ! 3134: REG8(AL) = 0x00; ! 3135: } ! 3136: ! 3137: inline void msdos_int_21h_2eh() ! 3138: { ! 3139: process_t *process = msdos_process_info_get(current_psp); ! 3140: ! 3141: process->verify = REG8(AL); ! 3142: } ! 3143: ! 3144: inline void msdos_int_21h_2fh() ! 3145: { ! 3146: process_t *process = msdos_process_info_get(current_psp); ! 3147: ! 3148: REG16(BX) = process->dta.w.l; ! 3149: cpustate->sreg[ES].selector = process->dta.w.h; ! 3150: i386_load_segment_descriptor(cpustate, ES); ! 3151: } ! 3152: ! 3153: inline void msdos_int_21h_30h() ! 3154: { ! 3155: // Version Flag / OEM ! 3156: if(REG8(AL) == 1) { ! 3157: REG8(BH) = 0x00; // not in ROM ! 3158: } else { ! 3159: REG8(BH) = 0xff; // OEM = Microsoft ! 3160: } ! 3161: // MS-DOS version (7.10) ! 3162: REG8(AL) = 7; ! 3163: REG8(AH) = 10; ! 3164: } ! 3165: ! 3166: inline void msdos_int_21h_31h() ! 3167: { ! 3168: int mcb_seg = current_psp - 1; ! 3169: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 3170: ! 3171: mcb->paragraphs = REG16(DX); ! 3172: mcb_seg += mcb->paragraphs + 1; ! 3173: msdos_mcb_create(mcb_seg, 'Z', 0, (MEMORY_END >> 4) - mcb_seg - 1); ! 3174: ! 3175: msdos_process_terminate(current_psp, REG8(AL) | 0x300, 0); ! 3176: } ! 3177: ! 3178: inline void msdos_int_21h_32h() ! 3179: { ! 3180: int drive_num = (REG8(DL) == 0) ? (_getdrive() - 1) : (REG8(DL) - 1); ! 3181: UINT16 seg, ofs; ! 3182: ! 3183: if(msdos_drive_param_block_update(drive_num, &seg, &ofs, 1)) { ! 3184: REG8(AL) = 0; ! 3185: cpustate->sreg[DS].selector = seg; ! 3186: i386_load_segment_descriptor(cpustate, DS); ! 3187: REG16(BX) = ofs; ! 3188: } else { ! 3189: REG8(AL) = 0xff; ! 3190: cpustate->CF = 1; ! 3191: } ! 3192: } ! 3193: ! 3194: inline void msdos_int_21h_33h() ! 3195: { ! 3196: static UINT8 state = 0x00; ! 3197: char path[MAX_PATH]; ! 3198: ! 3199: switch(REG8(AL)) { ! 3200: case 0x00: ! 3201: REG8(DL) = state; ! 3202: break; ! 3203: case 0x01: ! 3204: state = REG8(DL); ! 3205: break; ! 3206: case 0x05: ! 3207: GetSystemDirectory(path, MAX_PATH); ! 3208: if(path[0] >= 'a' && path[0] <= 'z') { ! 3209: REG8(DL) = path[0] - 'a' + 1; ! 3210: } else { ! 3211: REG8(DL) = path[0] - 'A' + 1; ! 3212: } ! 3213: break; ! 3214: case 0x06: ! 3215: // MS-DOS version (7.00) ! 3216: REG8(BL) = 7; ! 3217: REG8(BH) = 0; ! 3218: REG8(DL) = 0; ! 3219: REG8(DH) = 0x10; // in HMA ! 3220: break; ! 3221: default: ! 3222: REG16(AX) = 0x01; ! 3223: cpustate->CF = 1; ! 3224: break; ! 3225: } ! 3226: } ! 3227: ! 3228: inline void msdos_int_21h_35h() ! 3229: { ! 3230: REG16(BX) = *(UINT16 *)(mem + 4 * REG8(AL) + 0); ! 3231: cpustate->sreg[ES].selector = *(UINT16 *)(mem + 4 * REG8(AL) + 2); ! 3232: i386_load_segment_descriptor(cpustate, ES); ! 3233: } ! 3234: ! 3235: inline void msdos_int_21h_36h() ! 3236: { ! 3237: struct _diskfree_t df = {0}; ! 3238: ! 3239: if(_getdiskfree(REG8(DL), &df) == 0) { ! 3240: REG16(AX) = (UINT16)df.sectors_per_cluster; ! 3241: REG16(CX) = (UINT16)df.bytes_per_sector; ! 3242: REG16(BX) = (UINT16)df.avail_clusters; ! 3243: REG16(DX) = (UINT16)df.total_clusters; ! 3244: } else { ! 3245: REG16(AX) = 0xffff; ! 3246: } ! 3247: } ! 3248: ! 3249: inline void msdos_int_21h_37h() ! 3250: { ! 3251: process_t *process = msdos_process_info_get(current_psp); ! 3252: ! 3253: switch(REG8(AL)) { ! 3254: case 0x00: ! 3255: REG8(AL) = 0x00; ! 3256: REG8(DL) = process->switchar; ! 3257: break; ! 3258: case 0x01: ! 3259: REG8(AL) = 0x00; ! 3260: process->switchar = REG8(DL); ! 3261: break; ! 3262: default: ! 3263: REG16(AX) = 1; ! 3264: break; ! 3265: } ! 3266: } ! 3267: ! 3268: inline void msdos_int_21h_39h(int lfn) ! 3269: { ! 3270: if(_mkdir(msdos_trimmed_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), lfn))) { ! 3271: REG16(AX) = errno; ! 3272: cpustate->CF = 1; ! 3273: } ! 3274: } ! 3275: ! 3276: inline void msdos_int_21h_3ah(int lfn) ! 3277: { ! 3278: if(_rmdir(msdos_trimmed_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), lfn))) { ! 3279: REG16(AX) = errno; ! 3280: cpustate->CF = 1; ! 3281: } ! 3282: } ! 3283: ! 3284: inline void msdos_int_21h_3bh(int lfn) ! 3285: { ! 3286: if(_chdir(msdos_trimmed_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), lfn))) { ! 3287: REG16(AX) = errno; ! 3288: cpustate->CF = 1; ! 3289: } ! 3290: } ! 3291: ! 3292: inline void msdos_int_21h_3ch() ! 3293: { ! 3294: char *path = msdos_local_file_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), 0); ! 3295: int attr = GetFileAttributes(path); ! 3296: int fd = -1; ! 3297: ! 3298: if(_stricmp(path, "CON") == 0) { ! 3299: fd = _open(path, _O_WRONLY | _O_BINARY); ! 3300: } else { ! 3301: fd = _open(path, _O_RDWR | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE); ! 3302: } ! 3303: if(fd != -1) { ! 3304: if(attr == -1) { ! 3305: attr = msdos_file_attribute_create(REG16(CX)) & ~FILE_ATTRIBUTE_READONLY; ! 3306: } ! 3307: SetFileAttributes(path, attr); ! 3308: REG16(AX) = fd; ! 3309: msdos_file_handler_open(fd, path, _isatty(fd), 2, msdos_drive_number(path), current_psp); ! 3310: } else { ! 3311: REG16(AX) = errno; ! 3312: cpustate->CF = 1; ! 3313: } ! 3314: } ! 3315: ! 3316: inline void msdos_int_21h_3dh() ! 3317: { ! 3318: char *path = msdos_local_file_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), 0); ! 3319: int mode = REG8(AL) & 0x03; ! 3320: ! 3321: if(mode < 0x03) { ! 3322: int fd = _open(path, file_mode[mode].mode); ! 3323: ! 3324: if(fd != -1) { ! 3325: REG16(AX) = fd; ! 3326: msdos_file_handler_open(fd, path, _isatty(fd), mode, msdos_drive_number(path), current_psp); ! 3327: } else { ! 3328: REG16(AX) = errno; ! 3329: cpustate->CF = 1; ! 3330: } ! 3331: } else { ! 3332: REG16(AX) = 0x0c; ! 3333: cpustate->CF = 1; ! 3334: } ! 3335: } ! 3336: ! 3337: inline void msdos_int_21h_3eh() ! 3338: { ! 3339: process_t *process = msdos_process_info_get(current_psp); ! 3340: ! 3341: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3342: _close(REG16(BX)); ! 3343: msdos_file_handler_close(REG16(BX), current_psp); ! 3344: } else { ! 3345: REG16(AX) = 0x06; ! 3346: cpustate->CF = 1; ! 3347: } ! 3348: } ! 3349: ! 3350: inline void msdos_int_21h_3fh() ! 3351: { ! 3352: process_t *process = msdos_process_info_get(current_psp); ! 3353: ! 3354: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3355: if(file_mode[file_handler[REG16(BX)].mode].in) { ! 3356: if(file_handler[REG16(BX)].atty) { ! 3357: // BX is stdin or is redirected to stdin ! 3358: UINT8 *buf = mem + cpustate->sreg[DS].base + REG16(DX); ! 3359: int max = REG16(CX); ! 3360: int p = 0; ! 3361: ! 3362: while(max > p) { ! 3363: int chr = msdos_getch(); ! 3364: ! 3365: if(chr == 0x00) { ! 3366: // skip 2nd byte ! 3367: msdos_getch(); ! 3368: } else if(chr == 0x0d) { ! 3369: // carriage return ! 3370: buf[p++] = 0x0d; ! 3371: if(max > p) { ! 3372: buf[p++] = 0x0a; ! 3373: } ! 3374: break; ! 3375: } else if(chr == 0x08) { ! 3376: // back space ! 3377: if(p > 0) { ! 3378: p--; ! 3379: msdos_putch(chr); ! 3380: msdos_putch(' '); ! 3381: msdos_putch(chr); ! 3382: } ! 3383: } else { ! 3384: buf[p++] = chr; ! 3385: msdos_putch(chr); ! 3386: } ! 3387: } ! 3388: REG16(AX) = p; ! 3389: #ifdef SUPPORT_HARDWARE ! 3390: hardware_update(); ! 3391: #endif ! 3392: } else { ! 3393: REG16(AX) = _read(REG16(BX), mem + cpustate->sreg[DS].base + REG16(DX), REG16(CX)); ! 3394: } ! 3395: } else { ! 3396: REG16(AX) = 0x05; ! 3397: cpustate->CF = 1; ! 3398: } ! 3399: } else { ! 3400: REG16(AX) = 0x06; ! 3401: cpustate->CF = 1; ! 3402: } ! 3403: } ! 3404: ! 3405: inline void msdos_int_21h_40h() ! 3406: { ! 3407: process_t *process = msdos_process_info_get(current_psp); ! 3408: ! 3409: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3410: if(file_mode[file_handler[REG16(BX)].mode].out) { ! 3411: if(REG16(CX)) { ! 3412: if(file_handler[REG16(BX)].atty) { ! 3413: // BX is stdout/stderr or is redirected to stdout ! 3414: for(int i = 0; i < REG16(CX); i++) { ! 3415: msdos_putch(mem[cpustate->sreg[DS].base + REG16(DX) + i]); ! 3416: } ! 3417: REG16(AX) = REG16(CX); ! 3418: } else { ! 3419: REG16(AX) = msdos_write(REG16(BX), mem + cpustate->sreg[DS].base + REG16(DX), REG16(CX)); ! 3420: } ! 3421: } else { ! 3422: UINT32 pos = _tell(REG16(BX)); ! 3423: _lseek(REG16(BX), 0, SEEK_END); ! 3424: UINT32 size = _tell(REG16(BX)); ! 3425: REG16(AX) = 0; ! 3426: for(UINT32 i = size; i < pos; i++) { ! 3427: UINT8 tmp = 0; ! 3428: REG16(AX) += msdos_write(REG16(BX), &tmp, 1); ! 3429: } ! 3430: _lseek(REG16(BX), pos, SEEK_SET); ! 3431: } ! 3432: } else { ! 3433: REG16(AX) = 0x05; ! 3434: cpustate->CF = 1; ! 3435: } ! 3436: } else { ! 3437: REG16(AX) = 0x06; ! 3438: cpustate->CF = 1; ! 3439: } ! 3440: } ! 3441: ! 3442: inline void msdos_int_21h_41h(int lfn) ! 3443: { ! 3444: if(remove(msdos_trimmed_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), lfn))) { ! 3445: REG16(AX) = errno; ! 3446: cpustate->CF = 1; ! 3447: } ! 3448: } ! 3449: ! 3450: inline void msdos_int_21h_42h() ! 3451: { ! 3452: process_t *process = msdos_process_info_get(current_psp); ! 3453: ! 3454: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3455: if(REG8(AL) < 0x03) { ! 3456: static int ptrname[] = { SEEK_SET, SEEK_CUR, SEEK_END }; ! 3457: _lseek(REG16(BX), (REG16(CX) << 16) | REG16(DX), ptrname[REG8(AL)]); ! 3458: UINT32 pos = _tell(REG16(BX)); ! 3459: REG16(AX) = pos & 0xffff; ! 3460: REG16(DX) = (pos >> 16); ! 3461: } else { ! 3462: REG16(AX) = 0x01; ! 3463: cpustate->CF = 1; ! 3464: } ! 3465: } else { ! 3466: REG16(AX) = 0x06; ! 3467: cpustate->CF = 1; ! 3468: } ! 3469: } ! 3470: ! 3471: inline void msdos_int_21h_43h(int lfn) ! 3472: { ! 3473: char *path = msdos_local_file_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), lfn); ! 3474: int attr; ! 3475: ! 3476: switch(REG8(AL)) { ! 3477: case 0x00: ! 3478: if((attr = GetFileAttributes(path)) != -1) { ! 3479: REG16(CX) = 0; ! 3480: if(attr & FILE_ATTRIBUTE_READONLY) { ! 3481: REG16(CX) |= 0x01; ! 3482: } ! 3483: if(attr & FILE_ATTRIBUTE_HIDDEN) { ! 3484: REG16(CX) |= 0x02; ! 3485: } ! 3486: if(attr & FILE_ATTRIBUTE_SYSTEM) { ! 3487: REG16(CX) |= 0x04; ! 3488: } ! 3489: if(attr & FILE_ATTRIBUTE_ARCHIVE) { ! 3490: REG16(CX) |= 0x20; ! 3491: } ! 3492: } else { ! 3493: REG16(AX) = (UINT16)GetLastError(); ! 3494: cpustate->CF = 1; ! 3495: } ! 3496: break; ! 3497: case 0x01: ! 3498: if(SetFileAttributes(path, msdos_file_attribute_create(REG16(CX))) != 0) { ! 3499: REG16(AX) = (UINT16)GetLastError(); ! 3500: cpustate->CF = 1; ! 3501: } ! 3502: break; ! 3503: case 0x02: ! 3504: break; ! 3505: case 0x03: ! 3506: REG16(CX) = 0x00; ! 3507: break; ! 3508: default: ! 3509: REG16(AX) = 0x01; ! 3510: cpustate->CF = 1; ! 3511: break; ! 3512: } ! 3513: } ! 3514: ! 3515: inline void msdos_int_21h_44h() ! 3516: { ! 3517: switch(REG8(AL)) { ! 3518: case 0x00: // get ioctrl data ! 3519: REG16(DX) = file_handler[REG16(BX)].info; ! 3520: break; ! 3521: case 0x01: // set ioctrl data ! 3522: file_handler[REG16(BX)].info |= REG8(DL); ! 3523: break; ! 3524: case 0x02: // recv from character device ! 3525: case 0x03: // send to character device ! 3526: REG16(AX) = 0x06; ! 3527: cpustate->CF = 1; ! 3528: break; ! 3529: case 0x04: // recv from block device ! 3530: case 0x05: // send to block device ! 3531: REG16(AX) = 0x05; ! 3532: cpustate->CF = 1; ! 3533: break; ! 3534: case 0x06: // get read status ! 3535: { ! 3536: process_t *process = msdos_process_info_get(current_psp); ! 3537: ! 3538: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3539: if(file_mode[file_handler[REG16(BX)].mode].in) { ! 3540: if(file_handler[REG16(BX)].atty) { ! 3541: REG8(AL) = msdos_kbhit() ? 0xff : 0x00; ! 3542: } else { ! 3543: REG8(AL) = eof(REG16(BX)) ? 0x00 : 0xff; ! 3544: } ! 3545: } else { ! 3546: REG8(AL) = 0x00; ! 3547: } ! 3548: } else { ! 3549: REG16(AX) = 0x06; ! 3550: cpustate->CF = 1; ! 3551: } ! 3552: } ! 3553: break; ! 3554: case 0x07: // get write status ! 3555: { ! 3556: process_t *process = msdos_process_info_get(current_psp); ! 3557: ! 3558: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3559: if(file_mode[file_handler[REG16(BX)].mode].out) { ! 3560: REG8(AL) = 0xff; ! 3561: } else { ! 3562: REG8(AL) = 0x00; ! 3563: } ! 3564: } else { ! 3565: REG16(AX) = 0x06; ! 3566: cpustate->CF = 1; ! 3567: } ! 3568: } ! 3569: break; ! 3570: case 0x08: // check removable drive ! 3571: if(REG8(BL) < ('Z' - 'A' + 1)) { ! 3572: UINT32 val; ! 3573: if(REG8(BL) == 0) { ! 3574: val = GetDriveType(NULL); ! 3575: } else if(REG8(BL) < ('Z' - 'A' + 1)) { ! 3576: char tmp[8]; ! 3577: sprintf(tmp, "%c:\\", 'A' + REG8(BL) - 1); ! 3578: val = GetDriveType(tmp); ! 3579: } ! 3580: if(val == DRIVE_NO_ROOT_DIR) { ! 3581: // no drive ! 3582: REG16(AX) = 0x0f; ! 3583: cpustate->CF = 1; ! 3584: } else if(val == DRIVE_REMOVABLE || val == DRIVE_CDROM) { ! 3585: // removable drive ! 3586: REG16(AX) = 0x00; ! 3587: } else { ! 3588: // fixed drive ! 3589: REG16(AX) = 0x01; ! 3590: } ! 3591: } else { ! 3592: // invalid drive number ! 3593: REG16(AX) = 0x0f; ! 3594: cpustate->CF = 1; ! 3595: } ! 3596: break; ! 3597: case 0x09: // check remote drive ! 3598: if(REG8(BL) < ('Z' - 'A' + 1)) { ! 3599: UINT32 val; ! 3600: if(REG8(BL) == 0) { ! 3601: val = GetDriveType(NULL); ! 3602: } else if(REG8(BL) < ('Z' - 'A' + 1)) { ! 3603: char tmp[8]; ! 3604: sprintf(tmp, "%c:\\", 'A' + REG8(BL) - 1); ! 3605: val = GetDriveType(tmp); ! 3606: } ! 3607: if(val == DRIVE_NO_ROOT_DIR) { ! 3608: // no drive ! 3609: REG16(AX) = 0x0f; ! 3610: cpustate->CF = 1; ! 3611: } else if(val == DRIVE_REMOTE) { ! 3612: // remote drive ! 3613: REG16(DX) = 0x1000; ! 3614: } else { ! 3615: // local drive ! 3616: REG16(DX) = 0x00; ! 3617: } ! 3618: } else { ! 3619: // invalid drive number ! 3620: REG16(AX) = 0x0f; ! 3621: cpustate->CF = 1; ! 3622: } ! 3623: break; ! 3624: case 0x0b: // set retry count ! 3625: break; ! 3626: default: ! 3627: REG16(AX) = 0x01; ! 3628: cpustate->CF = 1; ! 3629: break; ! 3630: } ! 3631: } ! 3632: ! 3633: inline void msdos_int_21h_45h() ! 3634: { ! 3635: process_t *process = msdos_process_info_get(current_psp); ! 3636: ! 3637: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3638: int fd = _dup(REG16(BX)); ! 3639: if(fd != -1) { ! 3640: REG16(AX) = fd; ! 3641: msdos_file_handler_dup(REG16(AX), REG16(BX), current_psp); ! 3642: } else { ! 3643: REG16(AX) = errno; ! 3644: cpustate->CF = 1; ! 3645: } ! 3646: } else { ! 3647: REG16(AX) = 0x06; ! 3648: cpustate->CF = 1; ! 3649: } ! 3650: } ! 3651: ! 3652: inline void msdos_int_21h_46h() ! 3653: { ! 3654: process_t *process = msdos_process_info_get(current_psp); ! 3655: ! 3656: if(REG16(BX) < process->max_files && REG16(CX) < process->max_files && file_handler[REG16(BX)].valid) { ! 3657: if(_dup2(REG16(BX), REG16(CX)) != -1) { ! 3658: msdos_file_handler_dup(REG16(CX), REG16(BX), current_psp); ! 3659: } else { ! 3660: REG16(AX) = errno; ! 3661: cpustate->CF = 1; ! 3662: } ! 3663: } else { ! 3664: REG16(AX) = 0x06; ! 3665: cpustate->CF = 1; ! 3666: } ! 3667: } ! 3668: ! 3669: inline void msdos_int_21h_47h(int lfn) ! 3670: { ! 3671: char path[MAX_PATH]; ! 3672: ! 3673: if(_getdcwd(REG8(DL), path, MAX_PATH) != NULL) { ! 3674: if(path[1] == ':') { ! 3675: // the returned path does not include a drive or the initial backslash ! 3676: strcpy((char *)(mem + cpustate->sreg[DS].base + REG16(SI)), (lfn ? path : msdos_short_path(path)) + 3); ! 3677: } else { ! 3678: strcpy((char *)(mem + cpustate->sreg[DS].base + REG16(SI)), lfn ? path : msdos_short_path(path)); ! 3679: } ! 3680: } else { ! 3681: REG16(AX) = errno; ! 3682: cpustate->CF = 1; ! 3683: } ! 3684: } ! 3685: ! 3686: inline void msdos_int_21h_48h() ! 3687: { ! 3688: int seg; ! 3689: ! 3690: if((seg = msdos_mem_alloc(REG16(BX), 0)) != -1) { ! 3691: REG16(AX) = seg; ! 3692: } else { ! 3693: REG16(AX) = 0x08; ! 3694: REG16(BX) = msdos_mem_get_free(0); ! 3695: cpustate->CF = 1; ! 3696: } ! 3697: } ! 3698: ! 3699: inline void msdos_int_21h_49h() ! 3700: { ! 3701: msdos_mem_free(cpustate->sreg[ES].selector); ! 3702: } ! 3703: ! 3704: inline void msdos_int_21h_4ah() ! 3705: { ! 3706: int max_paragraphs; ! 3707: ! 3708: if(msdos_mem_realloc(cpustate->sreg[ES].selector, REG16(BX), &max_paragraphs)) { ! 3709: REG16(AX) = 0x08; ! 3710: REG16(BX) = max_paragraphs; ! 3711: cpustate->CF = 1; ! 3712: } ! 3713: } ! 3714: ! 3715: inline void msdos_int_21h_4bh() ! 3716: { ! 3717: char *command = (char *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 3718: param_block_t *param = (param_block_t *)(mem + cpustate->sreg[ES].base + REG16(BX)); ! 3719: ! 3720: switch(REG8(AL)) { ! 3721: case 0x00: ! 3722: case 0x01: ! 3723: if(msdos_process_exec(command, param, REG8(AL))) { ! 3724: REG16(AX) = 0x02; ! 3725: cpustate->CF = 1; ! 3726: } ! 3727: break; ! 3728: default: ! 3729: REG16(AX) = 0x01; ! 3730: cpustate->CF = 1; ! 3731: break; ! 3732: } ! 3733: } ! 3734: ! 3735: inline void msdos_int_21h_4ch() ! 3736: { ! 3737: msdos_process_terminate(current_psp, REG8(AL), 1); ! 3738: } ! 3739: ! 3740: inline void msdos_int_21h_4dh() ! 3741: { ! 3742: REG16(AX) = retval; ! 3743: } ! 3744: ! 3745: inline void msdos_int_21h_4eh() ! 3746: { ! 3747: process_t *process = msdos_process_info_get(current_psp); ! 3748: find_t *find = (find_t *)(mem + (process->dta.w.h << 4) + process->dta.w.l); ! 3749: char *path = msdos_trimmed_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), 0); ! 3750: WIN32_FIND_DATA fd; ! 3751: ! 3752: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 3753: FindClose(process->find_handle); ! 3754: process->find_handle = INVALID_HANDLE_VALUE; ! 3755: } ! 3756: strcpy(process->volume_label, msdos_volume_label(path)); ! 3757: process->allowable_mask = REG8(CL); ! 3758: ! 3759: if((process->allowable_mask & 8) && !msdos_match_volume_label(path, msdos_short_volume_label(process->volume_label))) { ! 3760: process->allowable_mask &= ~8; ! 3761: } ! 3762: if((process->find_handle = FindFirstFile(path, &fd)) != INVALID_HANDLE_VALUE) { ! 3763: while(!msdos_find_file_check_attribute(fd.dwFileAttributes, process->allowable_mask, 0)) { ! 3764: if(!FindNextFile(process->find_handle, &fd)) { ! 3765: FindClose(process->find_handle); ! 3766: process->find_handle = INVALID_HANDLE_VALUE; ! 3767: break; ! 3768: } ! 3769: } ! 3770: } ! 3771: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 3772: find->attrib = (UINT8)(fd.dwFileAttributes & 0x3f); ! 3773: msdos_find_file_conv_local_time(&fd); ! 3774: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->date, &find->time); ! 3775: find->size = fd.nFileSizeLow; ! 3776: strcpy(find->name, msdos_short_path(fd.cFileName)); ! 3777: REG16(AX) = 0; ! 3778: } else if(process->allowable_mask & 8) { ! 3779: find->attrib = 8; ! 3780: find->size = 0; ! 3781: strcpy(find->name, msdos_short_volume_label(process->volume_label)); ! 3782: process->allowable_mask &= ~8; ! 3783: REG16(AX) = 0; ! 3784: } else { ! 3785: REG16(AX) = 0x12; // NOTE: return 0x02 if file path is invalid ! 3786: cpustate->CF = 1; ! 3787: } ! 3788: } ! 3789: ! 3790: inline void msdos_int_21h_4fh() ! 3791: { ! 3792: process_t *process = msdos_process_info_get(current_psp); ! 3793: find_t *find = (find_t *)(mem + (process->dta.w.h << 4) + process->dta.w.l); ! 3794: WIN32_FIND_DATA fd; ! 3795: ! 3796: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 3797: if(FindNextFile(process->find_handle, &fd)) { ! 3798: while(!msdos_find_file_check_attribute(fd.dwFileAttributes, process->allowable_mask, 0)) { ! 3799: if(!FindNextFile(process->find_handle, &fd)) { ! 3800: FindClose(process->find_handle); ! 3801: process->find_handle = INVALID_HANDLE_VALUE; ! 3802: break; ! 3803: } ! 3804: } ! 3805: } else { ! 3806: FindClose(process->find_handle); ! 3807: process->find_handle = INVALID_HANDLE_VALUE; ! 3808: } ! 3809: } ! 3810: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 3811: find->attrib = (UINT8)(fd.dwFileAttributes & 0x3f); ! 3812: msdos_find_file_conv_local_time(&fd); ! 3813: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->date, &find->time); ! 3814: find->size = fd.nFileSizeLow; ! 3815: strcpy(find->name, msdos_short_path(fd.cFileName)); ! 3816: REG16(AX) = 0; ! 3817: } else if(process->allowable_mask & 8) { ! 3818: find->attrib = 8; ! 3819: find->size = 0; ! 3820: strcpy(find->name, msdos_short_volume_label(process->volume_label)); ! 3821: process->allowable_mask &= ~8; ! 3822: REG16(AX) = 0; ! 3823: } else { ! 3824: REG16(AX) = 0x12; ! 3825: cpustate->CF = 1; ! 3826: } ! 3827: } ! 3828: ! 3829: inline void msdos_int_21h_50h() ! 3830: { ! 3831: current_psp = REG16(BX); ! 3832: } ! 3833: ! 3834: inline void msdos_int_21h_51h() ! 3835: { ! 3836: REG16(BX) = current_psp; ! 3837: } ! 3838: ! 3839: inline void msdos_int_21h_52h() ! 3840: { ! 3841: cpustate->sreg[ES].selector = (DOS_INFO_BASE >> 4); ! 3842: i386_load_segment_descriptor(cpustate, ES); ! 3843: REG16(BX) = (DOS_INFO_BASE & 0x0f); ! 3844: } ! 3845: ! 3846: inline void msdos_int_21h_54h() ! 3847: { ! 3848: process_t *process = msdos_process_info_get(current_psp); ! 3849: ! 3850: REG8(AL) = process->verify; ! 3851: } ! 3852: ! 3853: inline void msdos_int_21h_55h() ! 3854: { ! 3855: psp_t *psp = (psp_t *)(mem + (REG16(DX) << 4)); ! 3856: ! 3857: memcpy(mem + (REG16(DX) << 4), mem + (current_psp << 4), sizeof(psp_t)); ! 3858: psp->int_22h.dw = *(UINT32 *)(mem + 4 * 0x22); ! 3859: psp->int_23h.dw = *(UINT32 *)(mem + 4 * 0x23); ! 3860: psp->int_24h.dw = *(UINT32 *)(mem + 4 * 0x24); ! 3861: psp->parent_psp = current_psp; ! 3862: } ! 3863: ! 3864: inline void msdos_int_21h_56h(int lfn) ! 3865: { ! 3866: char src[MAX_PATH], dst[MAX_PATH]; ! 3867: strcpy(src, msdos_trimmed_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), lfn)); ! 3868: strcpy(dst, msdos_trimmed_path((char *)(mem + cpustate->sreg[ES].base + REG16(DI)), lfn)); ! 3869: ! 3870: if(rename(src, dst)) { ! 3871: REG16(AX) = errno; ! 3872: cpustate->CF = 1; ! 3873: } ! 3874: } ! 3875: ! 3876: inline void msdos_int_21h_57h() ! 3877: { ! 3878: FILETIME time, local; ! 3879: ! 3880: switch(REG8(AL)) { ! 3881: case 0x00: ! 3882: if(GetFileTime((HANDLE)_get_osfhandle(REG16(BX)), NULL, NULL, &time)) { ! 3883: FileTimeToLocalFileTime(&time, &local); ! 3884: FileTimeToDosDateTime(&local, ®16(DX), ®16(CX)); ! 3885: } else { ! 3886: REG16(AX) = (UINT16)GetLastError(); ! 3887: cpustate->CF = 1; ! 3888: } ! 3889: break; ! 3890: case 0x01: ! 3891: DosDateTimeToFileTime(REG16(DX), REG16(CX), &local); ! 3892: LocalFileTimeToFileTime(&local, &time); ! 3893: if(!SetFileTime((HANDLE)_get_osfhandle(REG16(BX)), NULL, NULL, &time)) { ! 3894: REG16(AX) = (UINT16)GetLastError(); ! 3895: cpustate->CF = 1; ! 3896: } ! 3897: break; ! 3898: default: ! 3899: REG16(AX) = 0x01; ! 3900: cpustate->CF = 1; ! 3901: break; ! 3902: } ! 3903: } ! 3904: ! 3905: inline void msdos_int_21h_58h() ! 3906: { ! 3907: switch(REG8(AL)) { ! 3908: case 0x00: ! 3909: REG16(AX) = 0x00; ! 3910: break; ! 3911: default: ! 3912: REG16(AX) = 0x01; ! 3913: cpustate->CF = 1; ! 3914: break; ! 3915: } ! 3916: } ! 3917: ! 3918: inline void msdos_int_21h_59h() ! 3919: { ! 3920: REG16(AX) = error_code; ! 3921: switch(error_code) { ! 3922: case 4: // Too many open files ! 3923: case 8: // Insufficient memory ! 3924: REG8(BH) = 1; // Out of resource ! 3925: break; ! 3926: case 5: // Access denied ! 3927: REG8(BH) = 3; // Authorization ! 3928: break; ! 3929: case 7: // Memory control block destroyed ! 3930: REG8(BH) = 4; // Internal ! 3931: break; ! 3932: case 2: // File not found ! 3933: case 3: // Path not found ! 3934: case 15: // Invaid drive specified ! 3935: case 18: // No more files ! 3936: REG8(BH) = 8; // Not found ! 3937: break; ! 3938: case 32: // Sharing violation ! 3939: case 33: // Lock violation ! 3940: REG8(BH) = 10; // Locked ! 3941: break; ! 3942: // case 16: // Removal of current directory attempted ! 3943: case 19: // Attempted write on protected disk ! 3944: case 21: // Drive not ready ! 3945: // case 29: // Write failure ! 3946: // case 30: // Read failure ! 3947: // case 82: // Cannot create subdirectory ! 3948: REG8(BH) = 11; // Media ! 3949: break; ! 3950: case 80: // File already exists ! 3951: REG8(BH) = 12; // Already exist ! 3952: break; ! 3953: default: ! 3954: REG8(BH) = 13; // Unknown ! 3955: break; ! 3956: } ! 3957: REG8(BL) = 1; // Retry ! 3958: REG8(CH) = 1; // Unknown ! 3959: } ! 3960: ! 3961: inline void msdos_int_21h_5ah() ! 3962: { ! 3963: char *path = (char *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 3964: int len = strlen(path); ! 3965: char tmp[MAX_PATH]; ! 3966: ! 3967: if(GetTempFileName(path, "TMP", 0, tmp)) { ! 3968: int fd = _open(tmp, _O_RDWR | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE); ! 3969: ! 3970: SetFileAttributes(tmp, msdos_file_attribute_create(REG16(CX)) & ~FILE_ATTRIBUTE_READONLY); ! 3971: REG16(AX) = fd; ! 3972: msdos_file_handler_open(fd, path, _isatty(fd), 2, msdos_drive_number(path), current_psp); ! 3973: ! 3974: strcpy(path, tmp); ! 3975: int dx = REG16(DX) + len; ! 3976: int ds = cpustate->sreg[DS].selector; ! 3977: while(dx > 0xffff) { ! 3978: dx -= 0x10; ! 3979: ds++; ! 3980: } ! 3981: REG16(DX) = dx; ! 3982: cpustate->sreg[DS].selector = ds; ! 3983: i386_load_segment_descriptor(cpustate, DS); ! 3984: } else { ! 3985: REG16(AX) = (UINT16)GetLastError(); ! 3986: cpustate->CF = 1; ! 3987: } ! 3988: } ! 3989: ! 3990: inline void msdos_int_21h_5bh() ! 3991: { ! 3992: char *path = msdos_local_file_path((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), 0); ! 3993: ! 3994: if(_access(path, 0) == 0) { ! 3995: // already exists ! 3996: REG16(AX) = 0x50; ! 3997: cpustate->CF = 1; ! 3998: } else { ! 3999: int fd = _open(path, _O_RDWR | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE); ! 4000: ! 4001: if(fd != -1) { ! 4002: SetFileAttributes(path, msdos_file_attribute_create(REG16(CX)) & ~FILE_ATTRIBUTE_READONLY); ! 4003: REG16(AX) = fd; ! 4004: msdos_file_handler_open(fd, path, _isatty(fd), 2, msdos_drive_number(path), current_psp); ! 4005: } else { ! 4006: REG16(AX) = errno; ! 4007: cpustate->CF = 1; ! 4008: } ! 4009: } ! 4010: } ! 4011: ! 4012: inline void msdos_int_21h_5ch() ! 4013: { ! 4014: process_t *process = msdos_process_info_get(current_psp); ! 4015: ! 4016: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 4017: if(REG8(AL) == 0 || REG8(AL) == 1) { ! 4018: static int modes[2] = {_LK_LOCK, _LK_UNLCK}; ! 4019: UINT32 pos = _tell(REG16(BX)); ! 4020: _lseek(REG16(BX), (REG16(CX) << 16) | REG16(DX), SEEK_SET); ! 4021: if(_locking(REG16(BX), modes[REG8(AL)], (REG16(SI) << 16) | REG16(DI))) { ! 4022: REG16(AX) = errno; ! 4023: cpustate->CF = 1; ! 4024: } ! 4025: _lseek(REG16(BX), pos, SEEK_SET); ! 4026: #ifdef SUPPORT_HARDWARE ! 4027: // some seconds may be passed in _locking() ! 4028: hardware_update(); ! 4029: #endif ! 4030: } else { ! 4031: REG16(AX) = 0x01; ! 4032: cpustate->CF = 1; ! 4033: } ! 4034: } else { ! 4035: REG16(AX) = 0x06; ! 4036: cpustate->CF = 1; ! 4037: } ! 4038: } ! 4039: ! 4040: inline void msdos_int_21h_60h(int lfn) ! 4041: { ! 4042: if(lfn) { ! 4043: char full[MAX_PATH], *name; ! 4044: GetFullPathName((char *)(mem + cpustate->sreg[DS].base + REG16(SI)), MAX_PATH, full, &name); ! 4045: strcpy((char *)(mem + cpustate->sreg[ES].base + REG16(DI)), full); ! 4046: } else { ! 4047: strcpy((char *)(mem + cpustate->sreg[ES].base + REG16(DI)), msdos_short_full_path((char *)(mem + cpustate->sreg[DS].base + REG16(SI)))); ! 4048: } ! 4049: } ! 4050: ! 4051: inline void msdos_int_21h_61h() ! 4052: { ! 4053: REG8(AL) = 0; ! 4054: } ! 4055: ! 4056: inline void msdos_int_21h_62h() ! 4057: { ! 4058: REG16(BX) = current_psp; ! 4059: } ! 4060: ! 4061: inline void msdos_int_21h_63h() ! 4062: { ! 4063: switch(REG8(AL)) { ! 4064: case 0x00: ! 4065: cpustate->sreg[DS].selector = (DBCS_TABLE >> 4); ! 4066: i386_load_segment_descriptor(cpustate, DS); ! 4067: REG16(SI) = (DBCS_TABLE & 0x0f); ! 4068: REG8(AL) = 0x00; ! 4069: break; ! 4070: default: ! 4071: REG16(AX) = 0x01; ! 4072: cpustate->CF = 1; ! 4073: break; ! 4074: } ! 4075: } ! 4076: ! 4077: inline void msdos_int_21h_65h() ! 4078: { ! 4079: char tmp[0x10000]; ! 4080: ! 4081: switch(REG8(AL)) { ! 4082: case 0x07: ! 4083: *(UINT8 *)(mem + cpustate->sreg[ES].base + REG16(DI) + 0) = 0x07; ! 4084: *(UINT16 *)(mem + cpustate->sreg[ES].base + REG16(DI) + 1) = (DBCS_TOP & 0x0f); ! 4085: *(UINT16 *)(mem + cpustate->sreg[ES].base + REG16(DI) + 3) = (DBCS_TOP >> 4); ! 4086: REG16(CX) = 0x05; ! 4087: break; ! 4088: case 0x20: ! 4089: sprintf(tmp, "%c", REG8(DL)); ! 4090: my_strupr(tmp); ! 4091: REG8(DL) = tmp[0]; ! 4092: break; ! 4093: case 0x21: ! 4094: memset(tmp, 0, sizeof(tmp)); ! 4095: memcpy(tmp, mem + cpustate->sreg[DS].base + REG16(DX), REG16(CX)); ! 4096: my_strupr(tmp); ! 4097: memcpy(mem + cpustate->sreg[DS].base + REG16(DX), tmp, REG16(CX)); ! 4098: break; ! 4099: case 0x22: ! 4100: my_strupr((char *)(mem + cpustate->sreg[DS].base + REG16(DX))); ! 4101: break; ! 4102: default: ! 4103: REG16(AX) = 0x01; ! 4104: cpustate->CF = 1; ! 4105: break; ! 4106: } ! 4107: } ! 4108: ! 4109: inline void msdos_int_21h_66h() ! 4110: { ! 4111: switch(REG8(AL)) { ! 4112: case 0x01: ! 4113: REG16(BX) = active_code_page; ! 4114: REG16(DX) = system_code_page; ! 4115: break; ! 4116: case 0x02: ! 4117: if(active_code_page == REG16(BX)) { ! 4118: REG16(AX) = 0xeb41; ! 4119: } else if(_setmbcp(REG16(BX)) == 0) { ! 4120: active_code_page = REG16(BX); ! 4121: msdos_dbcs_table_update(); ! 4122: REG16(AX) = 0xeb41; ! 4123: } else { ! 4124: REG16(AX) = 0x25; ! 4125: cpustate->CF = 1; ! 4126: } ! 4127: break; ! 4128: default: ! 4129: REG16(AX) = 0x01; ! 4130: cpustate->CF = 1; ! 4131: break; ! 4132: } ! 4133: } ! 4134: ! 4135: inline void msdos_int_21h_67h() ! 4136: { ! 4137: process_t *process = msdos_process_info_get(current_psp); ! 4138: ! 4139: if(REG16(BX) <= MAX_FILES) { ! 4140: process->max_files = max(REG16(BX), 20); ! 4141: } else { ! 4142: REG16(AX) = 0x08; ! 4143: cpustate->CF = 1; ! 4144: } ! 4145: } ! 4146: ! 4147: inline void msdos_int_21h_68h() ! 4148: { ! 4149: process_t *process = msdos_process_info_get(current_psp); ! 4150: ! 4151: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 4152: // fflush(_fdopen(REG16(BX), "")); ! 4153: } else { ! 4154: REG16(AX) = 0x06; ! 4155: cpustate->CF = 1; ! 4156: } ! 4157: } ! 4158: ! 4159: inline void msdos_int_21h_69h() ! 4160: { ! 4161: drive_info_t *info = (drive_info_t *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 4162: char path[] = "A:\\"; ! 4163: char volume_label[MAX_PATH]; ! 4164: DWORD serial_number = 0; ! 4165: char file_system[MAX_PATH]; ! 4166: ! 4167: if(REG8(BL) == 0) { ! 4168: path[0] = 'A' + _getdrive() - 1; ! 4169: } else { ! 4170: path[0] = 'A' + REG8(BL) - 1; ! 4171: } ! 4172: ! 4173: switch(REG8(AL)) { ! 4174: case 0x00: ! 4175: if(GetVolumeInformation(path, volume_label, MAX_PATH, &serial_number, NULL, NULL, file_system, MAX_PATH)) { ! 4176: info->info_level = 0; ! 4177: info->serial_number = serial_number; ! 4178: memset(info->volume_label, 0x20, 11); ! 4179: memcpy(info->volume_label, volume_label, min(strlen(volume_label), 11)); ! 4180: memset(info->file_system, 0x20, 8); ! 4181: memcpy(info->file_system, file_system, min(strlen(file_system), 8)); ! 4182: } else { ! 4183: REG16(AX) = errno; ! 4184: cpustate->CF = 1; ! 4185: } ! 4186: break; ! 4187: case 0x01: ! 4188: REG16(AX) = 0x03; ! 4189: cpustate->CF = 1; ! 4190: } ! 4191: } ! 4192: ! 4193: inline void msdos_int_21h_6ah() ! 4194: { ! 4195: REG8(AH) = 0x68; ! 4196: msdos_int_21h_68h(); ! 4197: } ! 4198: ! 4199: inline void msdos_int_21h_6bh() ! 4200: { ! 4201: REG8(AL) = 0; ! 4202: } ! 4203: ! 4204: inline void msdos_int_21h_6ch(int lfn) ! 4205: { ! 4206: char *path = msdos_local_file_path((char *)(mem + cpustate->sreg[DS].base + REG16(SI)), lfn); ! 4207: int mode = REG8(BL) & 0x03; ! 4208: ! 4209: if(mode < 0x03) { ! 4210: if(_access(path, 0) == 0) { ! 4211: // file exists ! 4212: if(REG8(DL) & 1) { ! 4213: int fd = _open(path, file_mode[mode].mode); ! 4214: ! 4215: if(fd != -1) { ! 4216: REG16(AX) = fd; ! 4217: REG16(CX) = 1; ! 4218: msdos_file_handler_open(fd, path, _isatty(fd), mode, msdos_drive_number(path), current_psp); ! 4219: } else { ! 4220: REG16(AX) = errno; ! 4221: cpustate->CF = 1; ! 4222: } ! 4223: } else if(REG8(DL) & 2) { ! 4224: int attr = GetFileAttributes(path); ! 4225: int fd = -1; ! 4226: ! 4227: if(_stricmp(path, "CON") == 0) { ! 4228: fd = _open(path, file_mode[mode].mode); ! 4229: } else { ! 4230: fd = _open(path, _O_RDWR | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE); ! 4231: } ! 4232: if(fd != -1) { ! 4233: if(attr == -1) { ! 4234: attr = msdos_file_attribute_create(REG16(CX)) & ~FILE_ATTRIBUTE_READONLY; ! 4235: } ! 4236: SetFileAttributes(path, attr); ! 4237: REG16(AX) = fd; ! 4238: REG16(CX) = 3; ! 4239: msdos_file_handler_open(fd, path, _isatty(fd), 2, msdos_drive_number(path), current_psp); ! 4240: } else { ! 4241: REG16(AX) = errno; ! 4242: cpustate->CF = 1; ! 4243: } ! 4244: } else { ! 4245: REG16(AX) = 0x50; ! 4246: cpustate->CF = 1; ! 4247: } ! 4248: } else { ! 4249: // file not exists ! 4250: if(REG8(DL) & 0x10) { ! 4251: int fd = _open(path, _O_RDWR | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE); ! 4252: ! 4253: if(fd != -1) { ! 4254: SetFileAttributes(path, msdos_file_attribute_create(REG16(CX)) & ~FILE_ATTRIBUTE_READONLY); ! 4255: REG16(AX) = fd; ! 4256: REG16(CX) = 2; ! 4257: msdos_file_handler_open(fd, path, _isatty(fd), 2, msdos_drive_number(path), current_psp); ! 4258: } else { ! 4259: REG16(AX) = errno; ! 4260: cpustate->CF = 1; ! 4261: } ! 4262: } else { ! 4263: REG16(AX) = 0x02; ! 4264: cpustate->CF = 1; ! 4265: } ! 4266: } ! 4267: } else { ! 4268: REG16(AX) = 0x0c; ! 4269: cpustate->CF = 1; ! 4270: } ! 4271: } ! 4272: ! 4273: inline void msdos_int_21h_710dh() ! 4274: { ! 4275: // reset drive ! 4276: } ! 4277: ! 4278: inline void msdos_int_21h_714eh() ! 4279: { ! 4280: process_t *process = msdos_process_info_get(current_psp); ! 4281: find_lfn_t *find = (find_lfn_t *)(mem + cpustate->sreg[ES].base + REG16(DI)); ! 4282: char *path = (char *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 4283: WIN32_FIND_DATA fd; ! 4284: ! 4285: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 4286: FindClose(process->find_handle); ! 4287: process->find_handle = INVALID_HANDLE_VALUE; ! 4288: } ! 4289: strcpy(process->volume_label, msdos_volume_label(path)); ! 4290: process->allowable_mask = REG8(CL); ! 4291: process->required_mask = REG8(CH); ! 4292: ! 4293: if((process->allowable_mask & 8) && !msdos_match_volume_label(path, process->volume_label) && !msdos_match_volume_label(path, msdos_short_volume_label(process->volume_label))) { ! 4294: process->allowable_mask &= ~8; ! 4295: } ! 4296: if((process->find_handle = FindFirstFile(path, &fd)) != INVALID_HANDLE_VALUE) { ! 4297: while(!msdos_find_file_check_attribute(fd.dwFileAttributes, process->allowable_mask, process->required_mask)) { ! 4298: if(!FindNextFile(process->find_handle, &fd)) { ! 4299: FindClose(process->find_handle); ! 4300: process->find_handle = INVALID_HANDLE_VALUE; ! 4301: break; ! 4302: } ! 4303: } ! 4304: } ! 4305: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 4306: find->attrib = fd.dwFileAttributes; ! 4307: msdos_find_file_conv_local_time(&fd); ! 4308: if(REG16(SI) == 0) { ! 4309: find->ctime_lo.dw = fd.ftCreationTime.dwLowDateTime; ! 4310: find->ctime_hi.dw = fd.ftCreationTime.dwHighDateTime; ! 4311: find->atime_lo.dw = fd.ftLastAccessTime.dwLowDateTime; ! 4312: find->atime_hi.dw = fd.ftLastAccessTime.dwHighDateTime; ! 4313: find->mtime_lo.dw = fd.ftLastWriteTime.dwLowDateTime; ! 4314: find->mtime_hi.dw = fd.ftLastWriteTime.dwHighDateTime; ! 4315: } else { ! 4316: FileTimeToDosDateTime(&fd.ftCreationTime, &find->ctime_lo.w.h, &find->ctime_lo.w.l); ! 4317: FileTimeToDosDateTime(&fd.ftLastAccessTime, &find->atime_lo.w.h, &find->atime_lo.w.l); ! 4318: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->mtime_lo.w.h, &find->mtime_lo.w.l); ! 4319: } ! 4320: find->size_hi = fd.nFileSizeHigh; ! 4321: find->size_lo = fd.nFileSizeLow; ! 4322: strcpy(find->full_name, fd.cFileName); ! 4323: strcpy(find->short_name, msdos_short_path(fd.cFileName)); ! 4324: } else if(process->allowable_mask & 8) { ! 4325: // volume label ! 4326: find->attrib = 8; ! 4327: find->size_hi = find->size_lo = 0; ! 4328: strcpy(find->full_name, process->volume_label); ! 4329: strcpy(find->short_name, msdos_short_volume_label(process->volume_label)); ! 4330: process->allowable_mask &= ~8; ! 4331: } else { ! 4332: REG16(AX) = 0x12; // NOTE: return 0x02 if file path is invalid ! 4333: cpustate->CF = 1; ! 4334: } ! 4335: } ! 4336: ! 4337: inline void msdos_int_21h_714fh() ! 4338: { ! 4339: process_t *process = msdos_process_info_get(current_psp); ! 4340: find_lfn_t *find = (find_lfn_t *)(mem + cpustate->sreg[ES].base + REG16(DI)); ! 4341: WIN32_FIND_DATA fd; ! 4342: ! 4343: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 4344: if(FindNextFile(process->find_handle, &fd)) { ! 4345: while(!msdos_find_file_check_attribute(fd.dwFileAttributes, process->allowable_mask, process->required_mask)) { ! 4346: if(!FindNextFile(process->find_handle, &fd)) { ! 4347: FindClose(process->find_handle); ! 4348: process->find_handle = INVALID_HANDLE_VALUE; ! 4349: break; ! 4350: } ! 4351: } ! 4352: } else { ! 4353: FindClose(process->find_handle); ! 4354: process->find_handle = INVALID_HANDLE_VALUE; ! 4355: } ! 4356: } ! 4357: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 4358: find->attrib = fd.dwFileAttributes; ! 4359: msdos_find_file_conv_local_time(&fd); ! 4360: if(REG16(SI) == 0) { ! 4361: find->ctime_lo.dw = fd.ftCreationTime.dwLowDateTime; ! 4362: find->ctime_hi.dw = fd.ftCreationTime.dwHighDateTime; ! 4363: find->atime_lo.dw = fd.ftLastAccessTime.dwLowDateTime; ! 4364: find->atime_hi.dw = fd.ftLastAccessTime.dwHighDateTime; ! 4365: find->mtime_lo.dw = fd.ftLastWriteTime.dwLowDateTime; ! 4366: find->mtime_hi.dw = fd.ftLastWriteTime.dwHighDateTime; ! 4367: } else { ! 4368: FileTimeToDosDateTime(&fd.ftCreationTime, &find->ctime_lo.w.h, &find->ctime_lo.w.l); ! 4369: FileTimeToDosDateTime(&fd.ftLastAccessTime, &find->atime_lo.w.h, &find->atime_lo.w.l); ! 4370: FileTimeToDosDateTime(&fd.ftLastWriteTime, &find->mtime_lo.w.h, &find->mtime_lo.w.l); ! 4371: } ! 4372: find->size_hi = fd.nFileSizeHigh; ! 4373: find->size_lo = fd.nFileSizeLow; ! 4374: strcpy(find->full_name, fd.cFileName); ! 4375: strcpy(find->short_name, msdos_short_path(fd.cFileName)); ! 4376: } else if(process->allowable_mask & 8) { ! 4377: // volume label ! 4378: find->attrib = 8; ! 4379: find->size_hi = find->size_lo = 0; ! 4380: strcpy(find->full_name, process->volume_label); ! 4381: strcpy(find->short_name, msdos_short_volume_label(process->volume_label)); ! 4382: process->allowable_mask &= ~8; ! 4383: } else { ! 4384: REG16(AX) = 0x12; ! 4385: cpustate->CF = 1; ! 4386: } ! 4387: } ! 4388: ! 4389: inline void msdos_int_21h_71a0h() ! 4390: { ! 4391: DWORD max_component_len, file_sys_flag; ! 4392: ! 4393: if(GetVolumeInformation((char *)(mem + cpustate->sreg[DS].base + REG16(DX)), NULL, 0, NULL, &max_component_len, &file_sys_flag, (char *)(mem + cpustate->sreg[ES].base + REG16(DI)), REG16(CX))) { ! 4394: REG16(BX) = (UINT16)file_sys_flag; ! 4395: REG16(CX) = (UINT16)max_component_len; // 255 ! 4396: REG16(DX) = (UINT16)max_component_len + 5; // 260 ! 4397: } else { ! 4398: REG16(AX) = (UINT16)GetLastError(); ! 4399: cpustate->CF = 1; ! 4400: } ! 4401: } ! 4402: ! 4403: inline void msdos_int_21h_71a1h() ! 4404: { ! 4405: process_t *process = msdos_process_info_get(current_psp); ! 4406: find_t *find = (find_t *)(mem + (process->dta.w.h << 4) + process->dta.w.l); ! 4407: ! 4408: if(process->find_handle != INVALID_HANDLE_VALUE) { ! 4409: FindClose(process->find_handle); ! 4410: process->find_handle = INVALID_HANDLE_VALUE; ! 4411: } ! 4412: } ! 4413: ! 4414: inline void msdos_int_21h_71a6h() ! 4415: { ! 4416: process_t *process = msdos_process_info_get(current_psp); ! 4417: UINT8 *buffer = (UINT8 *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 4418: struct _stat64 status; ! 4419: DWORD serial_number = 0; ! 4420: ! 4421: if(REG16(BX) < process->max_files && file_handler[REG16(BX)].valid) { ! 4422: if(_fstat64(REG16(BX), &status) == 0) { ! 4423: if(file_handler[REG16(BX)].path[1] == ':') { ! 4424: // NOTE: we need to consider the network file path "\\host\share\" ! 4425: char volume[] = "A:\\"; ! 4426: volume[0] = file_handler[REG16(BX)].path[1]; ! 4427: GetVolumeInformation(volume, NULL, 0, &serial_number, NULL, NULL, NULL, 0); ! 4428: } ! 4429: *(UINT32 *)(buffer + 0x00) = GetFileAttributes(file_handler[REG16(BX)].path); ! 4430: *(UINT32 *)(buffer + 0x04) = (UINT32)(status.st_ctime & 0xffffffff); ! 4431: *(UINT32 *)(buffer + 0x08) = (UINT32)((status.st_ctime >> 32) & 0xffffffff); ! 4432: *(UINT32 *)(buffer + 0x0c) = (UINT32)(status.st_atime & 0xffffffff); ! 4433: *(UINT32 *)(buffer + 0x10) = (UINT32)((status.st_atime >> 32) & 0xffffffff); ! 4434: *(UINT32 *)(buffer + 0x14) = (UINT32)(status.st_mtime & 0xffffffff); ! 4435: *(UINT32 *)(buffer + 0x18) = (UINT32)((status.st_mtime >> 32) & 0xffffffff); ! 4436: *(UINT32 *)(buffer + 0x1c) = serial_number; ! 4437: *(UINT32 *)(buffer + 0x20) = (UINT32)((status.st_size >> 32) & 0xffffffff); ! 4438: *(UINT32 *)(buffer + 0x24) = (UINT32)(status.st_size & 0xffffffff); ! 4439: *(UINT32 *)(buffer + 0x28) = status.st_nlink; ! 4440: // this is dummy id and it will be changed when it is reopend... ! 4441: *(UINT32 *)(buffer + 0x2c) = 0; ! 4442: *(UINT32 *)(buffer + 0x30) = file_handler[REG16(BX)].id; ! 4443: } else { ! 4444: REG16(AX) = errno; ! 4445: cpustate->CF = 1; ! 4446: } ! 4447: } else { ! 4448: REG16(AX) = 0x06; ! 4449: cpustate->CF = 1; ! 4450: } ! 4451: } ! 4452: ! 4453: inline void msdos_int_21h_71a7h() ! 4454: { ! 4455: switch(REG8(BL)) { ! 4456: case 0x00: ! 4457: if(!FileTimeToDosDateTime((FILETIME *)(mem + cpustate->sreg[DS].base + REG16(SI)), ®16(DX), ®16(CX))) { ! 4458: REG16(AX) = (UINT16)GetLastError(); ! 4459: cpustate->CF = 1; ! 4460: } ! 4461: break; ! 4462: case 0x01: ! 4463: // NOTE: we need to check BH that shows 10-millisecond untils past time in CX ! 4464: if(!DosDateTimeToFileTime(REG16(DX), REG16(CX), (FILETIME *)(mem + cpustate->sreg[ES].base + REG16(DI)))) { ! 4465: REG16(AX) = (UINT16)GetLastError(); ! 4466: cpustate->CF = 1; ! 4467: } ! 4468: break; ! 4469: default: ! 4470: REG16(AX) = 0x01; ! 4471: cpustate->CF = 1; ! 4472: break; ! 4473: } ! 4474: } ! 4475: ! 4476: inline void msdos_int_21h_71a8h() ! 4477: { ! 4478: if(REG8(DH) == 0) { ! 4479: char tmp[MAX_PATH], fcb[MAX_PATH]; ! 4480: strcpy(tmp, msdos_short_path((char *)(mem + cpustate->sreg[DS].base + REG16(SI)))); ! 4481: memset(fcb, 0x20, sizeof(fcb)); ! 4482: int len = strlen(tmp); ! 4483: int pos = 0; ! 4484: for(int i = 0; i < len; i++) { ! 4485: if(tmp[i] == '.') { ! 4486: pos = 8; ! 4487: } else { ! 4488: if(msdos_lead_byte_check(tmp[i])) { ! 4489: fcb[pos++] = tmp[i++]; ! 4490: } ! 4491: fcb[pos++] = tmp[i]; ! 4492: } ! 4493: } ! 4494: memcpy((char *)(mem + cpustate->sreg[ES].base + REG16(DI)), fcb, 11); ! 4495: } else { ! 4496: strcpy((char *)(mem + cpustate->sreg[ES].base + REG16(DI)), msdos_short_path((char *)(mem + cpustate->sreg[DS].base + REG16(SI)))); ! 4497: } ! 4498: } ! 4499: ! 4500: inline void msdos_int_21h_7303h() ! 4501: { ! 4502: char *path = (char *)(mem + cpustate->sreg[DS].base + REG16(DX)); ! 4503: ext_space_info_t *info = (ext_space_info_t *)(mem + cpustate->sreg[ES].base + REG16(DI)); ! 4504: DWORD sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters; ! 4505: ! 4506: if(GetDiskFreeSpace(path, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters)) { ! 4507: info->size_of_structure = sizeof(ext_space_info_t); ! 4508: info->structure_version = 0; ! 4509: info->sectors_per_cluster = sectors_per_cluster; ! 4510: info->bytes_per_sector = bytes_per_sector; ! 4511: info->available_clusters_on_drive = free_clusters; ! 4512: info->total_clusters_on_drive = total_clusters; ! 4513: info->available_sectors_on_drive = sectors_per_cluster * free_clusters; ! 4514: info->total_sectors_on_drive = sectors_per_cluster * total_clusters; ! 4515: info->available_allocation_units = free_clusters; // ??? ! 4516: info->total_allocation_units = total_clusters; // ??? ! 4517: } else { ! 4518: REG16(AX) = errno; ! 4519: cpustate->CF = 1; ! 4520: } ! 4521: } ! 4522: ! 4523: inline void msdos_int_25h() ! 4524: { ! 4525: UINT16 seg, ofs; ! 4526: DWORD dwSize; ! 4527: ! 4528: I386OP(pushf)(cpustate); ! 4529: ! 4530: if(!(REG8(AL) < 26)) { ! 4531: REG8(AL) = 0x01; // unit unknown ! 4532: cpustate->CF = 1; ! 4533: } else if(!msdos_drive_param_block_update(REG8(AL), &seg, &ofs, 0)) { ! 4534: REG8(AL) = 0x02; // drive not ready ! 4535: cpustate->CF = 1; ! 4536: } else { ! 4537: dpb_t *dpb = (dpb_t *)(mem + (seg << 4) + ofs); ! 4538: char dev[64]; ! 4539: sprintf(dev, "\\\\.\\%c:", 'A' + REG8(AL)); ! 4540: ! 4541: HANDLE hFile = CreateFile(dev, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING, NULL); ! 4542: if(hFile == INVALID_HANDLE_VALUE) { ! 4543: REG8(AL) = 0x02; // drive not ready ! 4544: cpustate->CF = 1; ! 4545: } else { ! 4546: if(DeviceIoControl(hFile, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL) == 0) { ! 4547: REG8(AL) = 0x02; // drive not ready ! 4548: cpustate->CF = 1; ! 4549: } else if(SetFilePointer(hFile, REG16(DX) * dpb->bytes_per_sector, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { ! 4550: REG8(AL) = 0x08; // sector not found ! 4551: cpustate->CF = 1; ! 4552: } else if(ReadFile(hFile, mem + cpustate->sreg[DS].base + REG16(BX), REG16(CX) * dpb->bytes_per_sector, &dwSize, NULL) == 0) { ! 4553: REG8(AL) = 0x0b; // read error ! 4554: cpustate->CF = 1; ! 4555: } ! 4556: CloseHandle(hFile); ! 4557: } ! 4558: } ! 4559: } ! 4560: ! 4561: inline void msdos_int_26h() ! 4562: { ! 4563: // this operation may cause serious damage for drives, so always returns error... ! 4564: UINT16 seg, ofs; ! 4565: DWORD dwSize; ! 4566: ! 4567: I386OP(pushf)(cpustate); ! 4568: ! 4569: if(!(REG8(AL) < 26)) { ! 4570: REG8(AL) = 0x01; // unit unknown ! 4571: cpustate->CF = 1; ! 4572: } else if(!msdos_drive_param_block_update(REG8(AL), &seg, &ofs, 0)) { ! 4573: REG8(AL) = 0x02; // drive not ready ! 4574: cpustate->CF = 1; ! 4575: } else { ! 4576: dpb_t *dpb = (dpb_t *)(mem + (seg << 4) + ofs); ! 4577: char dev[64]; ! 4578: sprintf(dev, "\\\\.\\%c:", 'A' + REG8(AL)); ! 4579: ! 4580: if(dpb->media_type == 0xf8) { ! 4581: // this drive is not a floppy ! 4582: REG8(AL) = 0x02; // drive not ready ! 4583: cpustate->CF = 1; ! 4584: } else { ! 4585: HANDLE hFile = CreateFile(dev, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING, NULL); ! 4586: if(hFile == INVALID_HANDLE_VALUE) { ! 4587: REG8(AL) = 0x02; // drive not ready ! 4588: cpustate->CF = 1; ! 4589: } else { ! 4590: if(DeviceIoControl(hFile, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL) == 0) { ! 4591: REG8(AL) = 0x02; // drive not ready ! 4592: cpustate->CF = 1; ! 4593: } else if(SetFilePointer(hFile, REG16(DX) * dpb->bytes_per_sector, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { ! 4594: REG8(AL) = 0x08; // sector not found ! 4595: cpustate->CF = 1; ! 4596: } else if(WriteFile(hFile, mem + cpustate->sreg[DS].base + REG16(BX), REG16(CX) * dpb->bytes_per_sector, &dwSize, NULL) == 0) { ! 4597: REG8(AL) = 0x0a; // write error ! 4598: cpustate->CF = 1; ! 4599: } ! 4600: CloseHandle(hFile); ! 4601: } ! 4602: } ! 4603: } ! 4604: } ! 4605: ! 4606: inline void msdos_int_27h() ! 4607: { ! 4608: int mcb_seg = cpustate->sreg[CS].selector - 1; ! 4609: mcb_t *mcb = (mcb_t *)(mem + (mcb_seg << 4)); ! 4610: ! 4611: mcb->paragraphs = (REG16(DX) >> 4); ! 4612: mcb_seg += mcb->paragraphs + 1; ! 4613: msdos_mcb_create(mcb_seg, 'Z', 0, (MEMORY_END >> 4) - mcb_seg - 1); ! 4614: ! 4615: msdos_process_terminate(cpustate->sreg[CS].selector, retval | 0x300, 0); ! 4616: } ! 4617: ! 4618: inline void msdos_int_29h() ! 4619: { ! 4620: msdos_putch(REG8(AL)); ! 4621: } ! 4622: ! 4623: inline void msdos_int_2eh() ! 4624: { ! 4625: char tmp[MAX_PATH], command[MAX_PATH], opt[MAX_PATH]; ! 4626: memset(tmp, 0, sizeof(tmp)); ! 4627: strcpy(tmp, (char *)(mem + cpustate->sreg[DS].base + REG16(SI))); ! 4628: char *token = my_strtok(tmp, " "); ! 4629: strcpy(command, token); ! 4630: strcpy(opt, token + strlen(token) + 1); ! 4631: ! 4632: param_block_t *param = (param_block_t *)(mem + WORK_TOP); ! 4633: param->env_seg = 0; ! 4634: param->cmd_line.w.l = 44; ! 4635: param->cmd_line.w.h = (WORK_TOP >> 4); ! 4636: param->fcb1.w.l = 24; ! 4637: param->fcb1.w.h = (WORK_TOP >> 4); ! 4638: param->fcb2.w.l = 24; ! 4639: param->fcb2.w.h = (WORK_TOP >> 4); ! 4640: ! 4641: memset(mem + WORK_TOP + 24, 0x20, 20); ! 4642: ! 4643: cmd_line_t *cmd_line = (cmd_line_t *)(mem + WORK_TOP + 44); ! 4644: cmd_line->len = strlen(opt); ! 4645: strcpy(cmd_line->cmd, opt); ! 4646: cmd_line->cmd[cmd_line->len] = 0x0d; ! 4647: ! 4648: msdos_process_exec(command, param, 0); ! 4649: REG8(AL) = 0; ! 4650: } ! 4651: ! 4652: inline void msdos_int_2fh_16h() ! 4653: { ! 4654: switch(REG8(AL)) { ! 4655: case 0x00: ! 4656: { ! 4657: OSVERSIONINFO osvi; ! 4658: ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); ! 4659: osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); ! 4660: GetVersionEx(&osvi); ! 4661: REG8(AL) = osvi.dwMajorVersion; ! 4662: REG8(AH) = osvi.dwMinorVersion; ! 4663: } ! 4664: break; ! 4665: default: ! 4666: REG16(AX) = 0x01; ! 4667: cpustate->CF = 1; ! 4668: break; ! 4669: } ! 4670: } ! 4671: ! 4672: inline void msdos_int_2fh_1ah() ! 4673: { ! 4674: switch(REG8(AL)) { ! 4675: case 0x00: ! 4676: // ansi.sys is installed ! 4677: REG8(AL) = 0xff; ! 4678: break; ! 4679: default: ! 4680: REG16(AX) = 0x01; ! 4681: cpustate->CF = 1; ! 4682: break; ! 4683: } ! 4684: } ! 4685: ! 4686: inline void msdos_int_2fh_43h() ! 4687: { ! 4688: switch(REG8(AL)) { ! 4689: case 0x00: ! 4690: // xms is not installed ! 4691: REG8(AL) = 0; ! 4692: break; ! 4693: default: ! 4694: REG16(AX) = 0x01; ! 4695: cpustate->CF = 1; ! 4696: break; ! 4697: } ! 4698: } ! 4699: ! 4700: inline void msdos_int_2fh_4ah() ! 4701: { ! 4702: switch(REG8(AL)) { ! 4703: case 0x01: ! 4704: case 0x02: ! 4705: // hma is not installed ! 4706: REG16(BX) = 0; ! 4707: cpustate->sreg[ES].selector = 0xffff; ! 4708: i386_load_segment_descriptor(cpustate, ES); ! 4709: REG16(DI) = 0xffff; ! 4710: break; ! 4711: default: ! 4712: REG16(AX) = 0x01; ! 4713: cpustate->CF = 1; ! 4714: break; ! 4715: } ! 4716: } ! 4717: ! 4718: inline void msdos_int_2fh_4fh() ! 4719: { ! 4720: switch(REG8(AL)) { ! 4721: case 0x00: ! 4722: REG16(AX) = 0; ! 4723: REG8(DL) = 1; // major version ! 4724: REG8(DH) = 0; // minor version ! 4725: break; ! 4726: case 0x01: ! 4727: REG16(AX) = 0; ! 4728: REG16(BX) = active_code_page; ! 4729: break; ! 4730: default: ! 4731: REG16(AX) = 0x01; ! 4732: cpustate->CF = 1; ! 4733: break; ! 4734: } ! 4735: } ! 4736: ! 4737: inline void msdos_int_2fh_aeh() ! 4738: { ! 4739: switch(REG8(AL)) { ! 4740: case 0x00: ! 4741: REG8(AL) = 0; ! 4742: break; ! 4743: case 0x01: ! 4744: { ! 4745: char command[MAX_PATH]; ! 4746: memset(command, 0, sizeof(command)); ! 4747: memcpy(command, mem + cpustate->sreg[DS].base + REG16(SI) + 1, mem[cpustate->sreg[DS].base + REG16(SI)]); ! 4748: ! 4749: param_block_t *param = (param_block_t *)(mem + WORK_TOP); ! 4750: param->env_seg = 0; ! 4751: param->cmd_line.w.l = 44; ! 4752: param->cmd_line.w.h = (WORK_TOP >> 4); ! 4753: param->fcb1.w.l = 24; ! 4754: param->fcb1.w.h = (WORK_TOP >> 4); ! 4755: param->fcb2.w.l = 24; ! 4756: param->fcb2.w.h = (WORK_TOP >> 4); ! 4757: ! 4758: memset(mem + WORK_TOP + 24, 0x20, 20); ! 4759: ! 4760: cmd_line_t *cmd_line = (cmd_line_t *)(mem + WORK_TOP + 44); ! 4761: cmd_line->len = mem[cpustate->sreg[DS].base + REG16(BX) + 1]; ! 4762: memcpy(cmd_line->cmd, mem + cpustate->sreg[DS].base + REG16(BX) + 2, cmd_line->len); ! 4763: cmd_line->cmd[cmd_line->len] = 0x0d; ! 4764: ! 4765: if(msdos_process_exec(command, param, 0)) { ! 4766: REG16(AX) = 0x02; ! 4767: cpustate->CF = 1; ! 4768: } ! 4769: } ! 4770: break; ! 4771: default: ! 4772: REG16(AX) = 0x01; ! 4773: cpustate->CF = 1; ! 4774: break; ! 4775: } ! 4776: } ! 4777: ! 4778: inline void msdos_int_2fh_b7h() ! 4779: { ! 4780: switch(REG8(AL)) { ! 4781: case 0x00: ! 4782: // append is not installed ! 4783: REG8(AL) = 0; ! 4784: break; ! 4785: default: ! 4786: REG16(AX) = 0x01; ! 4787: cpustate->CF = 1; ! 4788: break; ! 4789: } ! 4790: } ! 4791: ! 4792: void msdos_syscall(unsigned num) ! 4793: { ! 4794: switch(num) { ! 4795: case 0x00: ! 4796: error("division by zero\n"); ! 4797: msdos_process_terminate(current_psp, (retval & 0xff) | 0x200, 1); ! 4798: break; ! 4799: case 0x04: ! 4800: error("overflow\n"); ! 4801: msdos_process_terminate(current_psp, (retval & 0xff) | 0x200, 1); ! 4802: break; ! 4803: case 0x06: ! 4804: // NOTE: ish.com has illegal instruction... ! 4805: // error("illegal instruction\n"); ! 4806: // msdos_process_terminate(current_psp, (retval & 0xff) | 0x200, 1); ! 4807: break; ! 4808: case 0x10: ! 4809: // PC BIOS - Video ! 4810: if(scr_width != 80 || scr_height != 25) { ! 4811: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 4812: SMALL_RECT rect; ! 4813: COORD co; ! 4814: ! 4815: GetConsoleScreenBufferInfo(hStdout, &csbi); ! 4816: if(csbi.dwCursorPosition.Y > 24) { ! 4817: SET_RECT(rect, 0, 0, scr_width - 1, scr_height - 1); ! 4818: ReadConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 4819: for(int y = 0, y2 = csbi.dwCursorPosition.Y - 24; y < 25; y++, y2++) { ! 4820: for(int x = 0; x < 80; x++) { ! 4821: scr_buf[y][x] = scr_buf[y2][x]; ! 4822: } ! 4823: } ! 4824: WriteConsoleOutput(hStdout, &scr_buf[0][0], scr_buf_size, scr_buf_pos, &rect); ! 4825: ! 4826: co.X = csbi.dwCursorPosition.X; ! 4827: co.Y = 24; ! 4828: SetConsoleCursorPosition(hStdout, co); ! 4829: cursor_moved = true; ! 4830: } ! 4831: SET_RECT(rect, 0, 0, 79, 24); ! 4832: co.X = 80; ! 4833: co.Y = 25; ! 4834: SetConsoleWindowInfo(hStdout, TRUE, &rect); ! 4835: SetConsoleScreenBufferSize(hStdout, co); ! 4836: scr_width = 80; ! 4837: scr_height = 25; ! 4838: } ! 4839: cpustate->CF = 0; ! 4840: switch(REG8(AH)) { ! 4841: case 0x00: pcbios_int_10h_00h(); break; ! 4842: case 0x01: pcbios_int_10h_01h(); break; ! 4843: case 0x02: pcbios_int_10h_02h(); break; ! 4844: case 0x03: pcbios_int_10h_03h(); break; ! 4845: case 0x05: pcbios_int_10h_05h(); break; ! 4846: case 0x06: pcbios_int_10h_06h(); break; ! 4847: case 0x07: pcbios_int_10h_07h(); break; ! 4848: case 0x08: pcbios_int_10h_08h(); break; ! 4849: case 0x09: pcbios_int_10h_09h(); break; ! 4850: case 0x0a: pcbios_int_10h_0ah(); break; ! 4851: case 0x0b: break; ! 4852: case 0x0c: break; ! 4853: case 0x0d: break; ! 4854: case 0x0e: pcbios_int_10h_0eh(); break; ! 4855: case 0x0f: pcbios_int_10h_0fh(); break; ! 4856: case 0x10: break; ! 4857: case 0x11: break; ! 4858: case 0x12: REG8(AL) = 0x00; break; ! 4859: case 0x13: pcbios_int_10h_13h(); break; ! 4860: case 0x18: REG8(AL) = 0x86; break; ! 4861: case 0x1a: REG8(AL) = 0x00; break; ! 4862: case 0x1c: REG8(AL) = 0x00; break; ! 4863: case 0x1d: pcbios_int_10h_1dh(); break; ! 4864: case 0x82: pcbios_int_10h_82h(); break; ! 4865: case 0xfe: pcbios_int_10h_feh(); break; ! 4866: case 0xff: pcbios_int_10h_ffh(); break; ! 4867: default: ! 4868: fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 4869: break; ! 4870: } ! 4871: break; ! 4872: case 0x11: ! 4873: // PC BIOS - Get Equipment List ! 4874: REG16(AX) = 0x20; ! 4875: break; ! 4876: case 0x12: ! 4877: // PC BIOS - Get Memory Size ! 4878: REG16(AX) = MEMORY_END / 1024; ! 4879: break; ! 4880: case 0x13: ! 4881: // PC BIOS - Disk ! 4882: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 4883: REG8(AH) = 0xff; ! 4884: cpustate->CF = 1; ! 4885: break; ! 4886: case 0x14: ! 4887: // PC BIOS - Serial I/O ! 4888: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 4889: REG8(AH) = 0xff; ! 4890: cpustate->CF = 1; ! 4891: break; ! 4892: case 0x15: ! 4893: // PC BIOS ! 4894: cpustate->CF = 0; ! 4895: switch(REG8(AH)) { ! 4896: case 0x23: pcbios_int_15h_23h(); break; ! 4897: case 0x24: pcbios_int_15h_24h(); break; ! 4898: case 0x49: pcbios_int_15h_49h(); break; ! 4899: case 0x86: pcbios_int_15h_86h(); break; ! 4900: case 0x87: pcbios_int_15h_87h(); break; ! 4901: case 0x88: pcbios_int_15h_88h(); break; ! 4902: case 0x89: pcbios_int_15h_89h(); break; ! 4903: case 0xc9: pcbios_int_15h_c9h(); break; ! 4904: case 0xca: pcbios_int_15h_cah(); break; ! 4905: default: ! 4906: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 4907: REG8(AH)=0x86; ! 4908: cpustate->CF = 1; ! 4909: break; ! 4910: } ! 4911: break; ! 4912: case 0x16: ! 4913: // PC BIOS - Keyboard ! 4914: cpustate->CF = 0; ! 4915: switch(REG8(AH)) { ! 4916: case 0x00: pcbios_int_16h_00h(); break; ! 4917: case 0x01: pcbios_int_16h_01h(); break; ! 4918: case 0x02: pcbios_int_16h_02h(); break; ! 4919: case 0x03: pcbios_int_16h_03h(); break; ! 4920: case 0x05: pcbios_int_16h_05h(); break; ! 4921: case 0x10: pcbios_int_16h_00h(); break; ! 4922: case 0x11: pcbios_int_16h_01h(); break; ! 4923: case 0x12: pcbios_int_16h_12h(); break; ! 4924: case 0x13: pcbios_int_16h_13h(); break; ! 4925: case 0x14: pcbios_int_16h_14h(); break; ! 4926: default: ! 4927: fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 4928: break; ! 4929: } ! 4930: break; ! 4931: case 0x17: ! 4932: // PC BIOS - Printer ! 4933: fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 4934: break; ! 4935: case 0x1a: ! 4936: // PC BIOS - Timer ! 4937: cpustate->CF = 0; ! 4938: switch(REG8(AH)) { ! 4939: case 0x00: pcbios_int_1ah_00h(); break; ! 4940: case 0x01: break; ! 4941: case 0x02: pcbios_int_1ah_02h(); break; ! 4942: case 0x03: break; ! 4943: case 0x04: pcbios_int_1ah_04h(); break; ! 4944: case 0x05: break; ! 4945: case 0x0a: pcbios_int_1ah_0ah(); break; ! 4946: case 0x0b: break; ! 4947: default: ! 4948: fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 4949: break; ! 4950: } ! 4951: break; ! 4952: case 0x20: ! 4953: msdos_process_terminate(cpustate->sreg[CS].selector, retval, 1); ! 4954: break; ! 4955: case 0x21: ! 4956: // MS-DOS System Call ! 4957: cpustate->CF = 0; ! 4958: switch(REG8(AH)) { ! 4959: case 0x00: msdos_int_21h_00h(); break; ! 4960: case 0x01: msdos_int_21h_01h(); break; ! 4961: case 0x02: msdos_int_21h_02h(); break; ! 4962: case 0x03: msdos_int_21h_03h(); break; ! 4963: case 0x04: msdos_int_21h_04h(); break; ! 4964: case 0x05: msdos_int_21h_05h(); break; ! 4965: case 0x06: msdos_int_21h_06h(); break; ! 4966: case 0x07: msdos_int_21h_07h(); break; ! 4967: case 0x08: msdos_int_21h_08h(); break; ! 4968: case 0x09: msdos_int_21h_09h(); break; ! 4969: case 0x0a: msdos_int_21h_0ah(); break; ! 4970: case 0x0b: msdos_int_21h_0bh(); break; ! 4971: case 0x0c: msdos_int_21h_0ch(); break; ! 4972: case 0x0d: msdos_int_21h_0dh(); break; ! 4973: case 0x0e: msdos_int_21h_0eh(); break; ! 4974: // 0x0f: open file with fcb ! 4975: // 0x10: close file with fcb ! 4976: case 0x11: msdos_int_21h_11h(); break; ! 4977: case 0x12: msdos_int_21h_12h(); break; ! 4978: case 0x13: msdos_int_21h_13h(); break; ! 4979: // 0x14: sequential read with fcb ! 4980: // 0x15: sequential write with fcb ! 4981: // 0x16: create new file with fcb ! 4982: // 0x17: rename file with fcb ! 4983: case 0x18: msdos_int_21h_18h(); break; ! 4984: case 0x19: msdos_int_21h_19h(); break; ! 4985: case 0x1a: msdos_int_21h_1ah(); break; ! 4986: case 0x1b: msdos_int_21h_1bh(); break; ! 4987: case 0x1c: msdos_int_21h_1ch(); break; ! 4988: case 0x1d: msdos_int_21h_1dh(); break; ! 4989: case 0x1e: msdos_int_21h_1eh(); break; ! 4990: case 0x1f: msdos_int_21h_1fh(); break; ! 4991: case 0x20: msdos_int_21h_20h(); break; ! 4992: // 0x21: random read with fcb ! 4993: // 0x22: randome write with fcb ! 4994: // 0x23: get file size with fcb ! 4995: // 0x24: set relative record field with fcb ! 4996: case 0x25: msdos_int_21h_25h(); break; ! 4997: case 0x26: msdos_int_21h_26h(); break; ! 4998: // 0x27: random block read with fcb ! 4999: // 0x28: random block write with fcb ! 5000: case 0x29: msdos_int_21h_29h(); break; ! 5001: case 0x2a: msdos_int_21h_2ah(); break; ! 5002: case 0x2b: msdos_int_21h_2bh(); break; ! 5003: case 0x2c: msdos_int_21h_2ch(); break; ! 5004: case 0x2d: msdos_int_21h_2dh(); break; ! 5005: case 0x2e: msdos_int_21h_2eh(); break; ! 5006: case 0x2f: msdos_int_21h_2fh(); break; ! 5007: case 0x30: msdos_int_21h_30h(); break; ! 5008: case 0x31: msdos_int_21h_31h(); break; ! 5009: case 0x32: msdos_int_21h_32h(); break; ! 5010: case 0x33: msdos_int_21h_33h(); break; ! 5011: // 0x34: get address of indos flag ! 5012: case 0x35: msdos_int_21h_35h(); break; ! 5013: case 0x36: msdos_int_21h_36h(); break; ! 5014: case 0x37: msdos_int_21h_37h(); break; ! 5015: // 0x38: get country-specific information ! 5016: case 0x39: msdos_int_21h_39h(0); break; ! 5017: case 0x3a: msdos_int_21h_3ah(0); break; ! 5018: case 0x3b: msdos_int_21h_3bh(0); break; ! 5019: case 0x3c: msdos_int_21h_3ch(); break; ! 5020: case 0x3d: msdos_int_21h_3dh(); break; ! 5021: case 0x3e: msdos_int_21h_3eh(); break; ! 5022: case 0x3f: msdos_int_21h_3fh(); break; ! 5023: case 0x40: msdos_int_21h_40h(); break; ! 5024: case 0x41: msdos_int_21h_41h(0); break; ! 5025: case 0x42: msdos_int_21h_42h(); break; ! 5026: case 0x43: msdos_int_21h_43h(0); break; ! 5027: case 0x44: msdos_int_21h_44h(); break; ! 5028: case 0x45: msdos_int_21h_45h(); break; ! 5029: case 0x46: msdos_int_21h_46h(); break; ! 5030: case 0x47: msdos_int_21h_47h(0); break; ! 5031: case 0x48: msdos_int_21h_48h(); break; ! 5032: case 0x49: msdos_int_21h_49h(); break; ! 5033: case 0x4a: msdos_int_21h_4ah(); break; ! 5034: case 0x4b: msdos_int_21h_4bh(); break; ! 5035: case 0x4c: msdos_int_21h_4ch(); break; ! 5036: case 0x4d: msdos_int_21h_4dh(); break; ! 5037: case 0x4e: msdos_int_21h_4eh(); break; ! 5038: case 0x4f: msdos_int_21h_4fh(); break; ! 5039: case 0x50: msdos_int_21h_50h(); break; ! 5040: case 0x51: msdos_int_21h_51h(); break; ! 5041: case 0x52: msdos_int_21h_52h(); break; ! 5042: // 0x53: translate bios parameter block to drive param bock ! 5043: case 0x54: msdos_int_21h_54h(); break; ! 5044: case 0x55: msdos_int_21h_55h(); break; ! 5045: case 0x56: msdos_int_21h_56h(0); break; ! 5046: case 0x57: msdos_int_21h_57h(); break; ! 5047: case 0x58: msdos_int_21h_58h(); break; ! 5048: case 0x59: msdos_int_21h_59h(); break; ! 5049: case 0x5a: msdos_int_21h_5ah(); break; ! 5050: case 0x5b: msdos_int_21h_5bh(); break; ! 5051: case 0x5c: msdos_int_21h_5ch(); break; ! 5052: // 0x5e: ms-network ! 5053: // 0x5f: ms-network ! 5054: case 0x60: msdos_int_21h_60h(0); break; ! 5055: case 0x61: msdos_int_21h_61h(); break; ! 5056: case 0x62: msdos_int_21h_62h(); break; ! 5057: case 0x63: msdos_int_21h_63h(); break; ! 5058: // 0x64: set device driver lockahead flag ! 5059: case 0x65: msdos_int_21h_65h(); break; ! 5060: case 0x66: msdos_int_21h_66h(); break; ! 5061: case 0x67: msdos_int_21h_67h(); break; ! 5062: case 0x68: msdos_int_21h_68h(); break; ! 5063: case 0x69: msdos_int_21h_69h(); break; ! 5064: case 0x6a: msdos_int_21h_6ah(); break; ! 5065: case 0x6b: msdos_int_21h_6bh(); break; ! 5066: case 0x6c: msdos_int_21h_6ch(0); break; ! 5067: // 0x6d: find first rom program ! 5068: // 0x6e: find next rom program ! 5069: // 0x6f: get/set rom scan start address ! 5070: // 0x70: windows95 get/set internationalization information ! 5071: case 0x71: ! 5072: // windows95 long filename functions ! 5073: switch(REG8(AL)) { ! 5074: case 0x0d: msdos_int_21h_710dh(); break; ! 5075: case 0x39: msdos_int_21h_39h(1); break; ! 5076: case 0x3a: msdos_int_21h_3ah(1); break; ! 5077: case 0x3b: msdos_int_21h_3bh(1); break; ! 5078: case 0x41: msdos_int_21h_41h(1); break; ! 5079: case 0x43: msdos_int_21h_43h(1); break; ! 5080: case 0x47: msdos_int_21h_47h(1); break; ! 5081: case 0x4e: msdos_int_21h_714eh(); break; ! 5082: case 0x4f: msdos_int_21h_714fh(); break; ! 5083: case 0x56: msdos_int_21h_56h(1); break; ! 5084: case 0x60: msdos_int_21h_60h(1); break; ! 5085: case 0x6c: msdos_int_21h_6ch(1); break; ! 5086: case 0xa0: msdos_int_21h_71a0h(); break; ! 5087: case 0xa1: msdos_int_21h_71a1h(); break; ! 5088: case 0xa6: msdos_int_21h_71a6h(); break; ! 5089: case 0xa7: msdos_int_21h_71a7h(); break; ! 5090: case 0xa8: msdos_int_21h_71a8h(); break; ! 5091: // 0xa9: server create/open file ! 5092: // 0xaa: create/terminate SUBST ! 5093: default: ! 5094: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 5095: REG16(AX) = 0x7100; ! 5096: cpustate->CF = 1; ! 5097: break; ! 5098: } ! 5099: break; ! 5100: // 0x72: Windows95 beta - LFN FindClose ! 5101: case 0x73: ! 5102: // windows95 fat32 functions ! 5103: switch(REG8(AL)) { ! 5104: // 0x00: drive locking ??? ! 5105: // 0x01: drive locking ??? ! 5106: // 0x02: get extended dpb ! 5107: case 0x03: msdos_int_21h_7303h(); break; ! 5108: // 0x04: set dpb to use for formatting ! 5109: default: ! 5110: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 5111: REG16(AX) = 0x7300; ! 5112: cpustate->CF = 1; ! 5113: break; ! 5114: } ! 5115: break; ! 5116: default: ! 5117: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 5118: REG16(AX) = 0x01; ! 5119: cpustate->CF = 1; ! 5120: break; ! 5121: } ! 5122: if(cpustate->CF) { ! 5123: error_code = REG16(AX); ! 5124: } ! 5125: break; ! 5126: case 0x22: ! 5127: fatalerror("int 22h (terminate address)\n"); ! 5128: case 0x23: ! 5129: msdos_process_terminate(current_psp, (retval & 0xff) | 0x100, 1); ! 5130: break; ! 5131: case 0x24: ! 5132: msdos_process_terminate(current_psp, (retval & 0xff) | 0x200, 1); ! 5133: break; ! 5134: case 0x25: ! 5135: msdos_int_25h(); ! 5136: break; ! 5137: case 0x26: ! 5138: msdos_int_26h(); ! 5139: break; ! 5140: case 0x27: ! 5141: msdos_int_27h(); ! 5142: break; ! 5143: case 0x28: ! 5144: Sleep(10); ! 5145: break; ! 5146: case 0x29: ! 5147: msdos_int_29h(); ! 5148: break; ! 5149: case 0x2e: ! 5150: msdos_int_2eh(); ! 5151: break; ! 5152: case 0x2f: ! 5153: // multiplex interrupt ! 5154: cpustate->CF = 0; ! 5155: switch(REG8(AH)) { ! 5156: case 0x16: msdos_int_2fh_16h(); break; ! 5157: case 0x1a: msdos_int_2fh_1ah(); break; ! 5158: case 0x43: msdos_int_2fh_43h(); break; ! 5159: case 0x4a: msdos_int_2fh_4ah(); break; ! 5160: case 0x4f: msdos_int_2fh_4fh(); break; ! 5161: case 0xae: msdos_int_2fh_aeh(); break; ! 5162: case 0xb7: msdos_int_2fh_b7h(); break; ! 5163: default: ! 5164: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 5165: REG16(AX) = 0x01; // ??? ! 5166: cpustate->CF = 1; ! 5167: break; ! 5168: } ! 5169: if(cpustate->CF) { ! 5170: error_code = REG16(AX); ! 5171: } ! 5172: break; ! 5173: default: ! 5174: // fatalerror("int %02xh (ax=%04xh bx=%04xh cx=%04xh dx=%04x)\n", num, REG16(AX), REG16(BX), REG16(CX), REG16(DX)); ! 5175: break; ! 5176: } ! 5177: ! 5178: // update cursor position ! 5179: if(cursor_moved) { ! 5180: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 5181: GetConsoleScreenBufferInfo(hStdout, &csbi); ! 5182: mem[0x450 + mem[0x462] * 2] = csbi.dwCursorPosition.X; ! 5183: mem[0x451 + mem[0x462] * 2] = csbi.dwCursorPosition.Y; ! 5184: cursor_moved = false; ! 5185: } ! 5186: } ! 5187: ! 5188: // init ! 5189: ! 5190: int msdos_init(int argc, char *argv[], char *envp[], int standard_env) ! 5191: { ! 5192: // init file handler ! 5193: memset(file_handler, 0, sizeof(file_handler)); ! 5194: msdos_file_handler_open(0, "STDIN", _isatty(0), 0, 0x80d3, 0); ! 5195: msdos_file_handler_open(1, "STDOUT", _isatty(1), 1, 0x80d3, 0); ! 5196: msdos_file_handler_open(2, "STDERR", _isatty(2), 1, 0x80d3, 0); ! 5197: #ifdef SUPPORT_AUX_PRN ! 5198: if(_open("stdaux.txt", _O_RDWR | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE) == 3) { ! 5199: msdos_file_handler_open(3, 0, 2, 0x80c0, 0); ! 5200: } ! 5201: if(_open("stdprn.txt", _O_WRONLY | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE) == 4) { ! 5202: msdos_file_handler_open(4, 0, 1, 0xa8c0, 0); ! 5203: } ! 5204: #endif ! 5205: _dup2(0, DUP_STDIN); ! 5206: _dup2(1, DUP_STDOUT); ! 5207: _dup2(2, DUP_STDERR); ! 5208: ! 5209: // init process ! 5210: memset(process, 0, sizeof(process)); ! 5211: ! 5212: // init memory ! 5213: memset(mem, 0, sizeof(mem)); ! 5214: for(int i = 0; i < 0x100; i++) { ! 5215: *(UINT16 *)(mem + 4 * i + 0) = i; ! 5216: *(UINT16 *)(mem + 4 * i + 2) = (IRET_TOP >> 4); ! 5217: } ! 5218: *(UINT16 *)(mem + 4 * 0x22 + 0) = 0xfff0; ! 5219: *(UINT16 *)(mem + 4 * 0x22 + 2) = 0xf000; ! 5220: memset(mem + IRET_TOP, 0xcf, IRET_SIZE); ! 5221: ! 5222: // bios data area ! 5223: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 5224: GetConsoleScreenBufferInfo(hStdout, &csbi); ! 5225: ! 5226: *(UINT8 *)(mem + 0x411) = 0x20; ! 5227: *(UINT16 *)(mem + 0x410) = 0x20; ! 5228: *(UINT16 *)(mem + 0x413) = MEMORY_END / 1024; ! 5229: *(UINT8 *)(mem + 0x449) = 0x03;//0x73; ! 5230: *(UINT16 *)(mem + 0x44a) = 80; ! 5231: *(UINT16 *)(mem + 0x44c) = 4096; ! 5232: *(UINT16 *)(mem + 0x44e) = 0; ! 5233: *(UINT8 *)(mem + 0x450) = csbi.dwCursorPosition.X; ! 5234: *(UINT8 *)(mem + 0x451) = csbi.dwCursorPosition.Y; ! 5235: *(UINT8 *)(mem + 0x460) = 7; ! 5236: *(UINT8 *)(mem + 0x461) = 7; ! 5237: *(UINT8 *)(mem + 0x462) = 0; ! 5238: *(UINT16 *)(mem + 0x463) = 0x3d4; ! 5239: *(UINT8 *)(mem + 0x484) = 24; ! 5240: *(UINT8 *)(mem + 0x485) = 19; ! 5241: *(UINT8 *)(mem + 0x487) = 0; // is this okay? ! 5242: ! 5243: // dos info ! 5244: dos_info_t *dos_info = (dos_info_t *)(mem + DOS_INFO_TOP); ! 5245: dos_info->first_mcb = MEMORY_TOP >> 4; ! 5246: dos_info->first_dpb.w.l = 0; ! 5247: dos_info->first_dpb.w.h = DPB_TOP >> 4; ! 5248: dos_info->first_sft.w.l = 0; ! 5249: dos_info->first_sft.w.h = FILE_TABLE_TOP >> 4; ! 5250: dos_info->cds.w.l = 0; ! 5251: dos_info->cds.w.h = CDS_TOP >> 4; ! 5252: dos_info->fcb_table.w.l = 0; ! 5253: dos_info->fcb_table.w.h = FCB_TABLE_TOP >> 4; ! 5254: dos_info->last_drive = 'Z' - 'A' + 1; ! 5255: dos_info->buffers_x = 20; ! 5256: dos_info->buffers_y = 0; ! 5257: char *env; ! 5258: if((env = getenv("LASTDRIVE")) != NULL) { ! 5259: if(env[0] >= 'A' && env[0] <= 'Z') { ! 5260: dos_info->last_drive = env[0] - 'A' + 1; ! 5261: } else if(env[0] >= 'a' && env[0] <= 'z') { ! 5262: dos_info->last_drive = env[0] - 'a' + 1; ! 5263: } ! 5264: } ! 5265: if((env = getenv("windir")) != NULL) { ! 5266: if(env[0] >= 'A' && env[0] <= 'Z') { ! 5267: dos_info->boot_drive = env[0] - 'A' + 1; ! 5268: } else if(env[0] >= 'a' && env[0] <= 'z') { ! 5269: dos_info->boot_drive = env[0] - 'a' + 1; ! 5270: } ! 5271: } ! 5272: dos_info->i386_or_later = 1; ! 5273: dos_info->ext_mem_size = (MAX_MEM - 0x100000) >> 10; ! 5274: ! 5275: // environment ! 5276: int seg = MEMORY_TOP >> 4; ! 5277: msdos_mcb_create(seg++, 'M', -1, ENV_SIZE >> 4); ! 5278: int env_seg = seg; ! 5279: int ofs = 0; ! 5280: ! 5281: for(char **p = envp; p != NULL && *p != NULL; p++) { ! 5282: // lower to upper ! 5283: char tmp[ENV_SIZE], name[ENV_SIZE], value[ENV_SIZE]; ! 5284: int value_pos = 0; ! 5285: strcpy(tmp, *p); ! 5286: for(int i = 0;; i++) { ! 5287: if(tmp[i] == '=') { ! 5288: tmp[i] = '\0'; ! 5289: sprintf(name, ";%s;", tmp); ! 5290: strcpy(value, tmp + (value_pos = i + 1)); ! 5291: tmp[i] = '='; ! 5292: break; ! 5293: } else if(tmp[i] >= 'a' && tmp[i] <= 'z') { ! 5294: tmp[i] = tmp[i] - 'a' + 'A'; ! 5295: } ! 5296: } ! 5297: if(!(standard_env && strstr(";COMSPEC;INCLUDE;LIB;PATH;PROMPT;TEMP;TMP;TZ;", name) == NULL)) { ! 5298: if(strncmp(tmp, "COMSPEC=", 8) == 0) { ! 5299: char full_path[MAX_PATH], short_path[MAX_PATH], *file_name; ! 5300: GetFullPathName(argv[0], MAX_PATH, full_path, &file_name); ! 5301: if(_stricmp(file_name, "COMMAND.COM") == 0 || _stricmp(file_name, "COMMAND") == 0) { ! 5302: sprintf(file_name, "COMMAND.COM"); ! 5303: if(_access(full_path, 0) == 0) { ! 5304: GetShortPathName(full_path, short_path, MAX_PATH); ! 5305: my_strupr(short_path); ! 5306: sprintf(tmp, "COMSPEC=%s", short_path); ! 5307: } ! 5308: } ! 5309: } else if(strncmp(tmp, "PATH=", 5) == 0 || strncmp(tmp, "TEMP=", 5) == 0 || strncmp(tmp, "TMP=", 4) == 0) { ! 5310: tmp[value_pos] = '\0'; ! 5311: char *token = my_strtok(value, ";"); ! 5312: while(token != NULL) { ! 5313: if(strlen(token) != 0) { ! 5314: char path[MAX_PATH], short_path[MAX_PATH]; ! 5315: if(token[0] == '"' && token[strlen(token) - 1] == '"') { ! 5316: memset(path, 0, sizeof(path)); ! 5317: memcpy(path, token + 1, strlen(token) - 2); ! 5318: } else { ! 5319: sprintf(path, token); ! 5320: } ! 5321: GetShortPathName(path, short_path, MAX_PATH); ! 5322: strcat(tmp, short_path); ! 5323: strcat(tmp, ";"); ! 5324: } ! 5325: token = my_strtok(NULL, ";"); ! 5326: } ! 5327: tmp[strlen(tmp) - 1] = '\0'; ! 5328: my_strupr(tmp); ! 5329: } ! 5330: int len = strlen(tmp); ! 5331: if (ofs + len + 1 + (2 + (8 + 1 + 3)) + 2 > ENV_SIZE) { ! 5332: fatalerror("too many environments\n"); ! 5333: } ! 5334: memcpy(mem + (seg << 4) + ofs, tmp, len); ! 5335: ofs += len + 1; ! 5336: } ! 5337: } ! 5338: seg += (ENV_SIZE >> 4); ! 5339: ! 5340: // psp ! 5341: msdos_mcb_create(seg++, 'M', -1, PSP_SIZE >> 4); ! 5342: current_psp = seg; ! 5343: psp_t *psp = msdos_psp_create(seg, seg + (PSP_SIZE >> 4), -1, env_seg); ! 5344: seg += (PSP_SIZE >> 4); ! 5345: ! 5346: // first mcb ! 5347: msdos_mcb_create(seg, 'Z', 0, (MEMORY_END >> 4) - seg - 1); ! 5348: ! 5349: // boot ! 5350: mem[0xffff0] = 0xf4; // halt ! 5351: mem[0xffff1] = 0xcd; // int 21h ! 5352: mem[0xffff2] = 0x21; ! 5353: mem[0xffff3] = 0xcb; // retf ! 5354: ! 5355: // param block ! 5356: // + 0: param block (22bytes) ! 5357: // +24: fcb1/2 (20bytes) ! 5358: // +44: command tail (128bytes) ! 5359: param_block_t *param = (param_block_t *)(mem + WORK_TOP); ! 5360: param->env_seg = 0; ! 5361: param->cmd_line.w.l = 44; ! 5362: param->cmd_line.w.h = (WORK_TOP >> 4); ! 5363: param->fcb1.w.l = 24; ! 5364: param->fcb1.w.h = (WORK_TOP >> 4); ! 5365: param->fcb2.w.l = 24; ! 5366: param->fcb2.w.h = (WORK_TOP >> 4); ! 5367: ! 5368: memset(mem + WORK_TOP + 24, 0x20, 20); ! 5369: ! 5370: cmd_line_t *cmd_line = (cmd_line_t *)(mem + WORK_TOP + 44); ! 5371: if(argc > 1) { ! 5372: sprintf(cmd_line->cmd, " %s", argv[1]); ! 5373: for(int i = 2; i < argc; i++) { ! 5374: char tmp[128]; ! 5375: sprintf(tmp, "%s %s", cmd_line->cmd, argv[i]); ! 5376: strcpy(cmd_line->cmd, tmp); ! 5377: } ! 5378: cmd_line->len = (UINT8)strlen(cmd_line->cmd); ! 5379: } else { ! 5380: cmd_line->len = 0; ! 5381: } ! 5382: cmd_line->cmd[cmd_line->len] = 0x0d; ! 5383: ! 5384: // system file table ! 5385: *(UINT16 *)(mem + FILE_TABLE_TOP + 0) = 6; ! 5386: *(UINT16 *)(mem + FILE_TABLE_TOP + 2) = FILE_TABLE_TOP >> 4; ! 5387: *(UINT16 *)(mem + FILE_TABLE_TOP + 4) = 100; ! 5388: *(UINT32 *)(mem + FILE_TABLE_TOP + 6) = 0xffffffff; ! 5389: *(UINT16 *)(mem + FILE_TABLE_TOP + 10) = 100; ! 5390: ! 5391: // current directory structure ! 5392: msdos_cds_update(_getdrive() - 1); ! 5393: ! 5394: // fcb table ! 5395: *(UINT32 *)(mem + FCB_TABLE_TOP + 0) = 0xffffffff; ! 5396: *(UINT16 *)(mem + FCB_TABLE_TOP + 4) = 100; ! 5397: ! 5398: // dbcs table ! 5399: msdos_dbcs_table_init(); ! 5400: ! 5401: // execute command ! 5402: if(msdos_process_exec(argv[0], param, 0)) { ! 5403: fatalerror("'%s' not found\n", argv[0]); ! 5404: } ! 5405: retval = 0; ! 5406: return(0); ! 5407: } ! 5408: ! 5409: #define remove_std_file(path) { \ ! 5410: int fd = _open(path, _O_RDONLY | _O_BINARY); \ ! 5411: if(fd != -1) { \ ! 5412: _lseek(fd, 0, SEEK_END); \ ! 5413: int size = _tell(fd); \ ! 5414: _close(fd); \ ! 5415: if(size == 0) { \ ! 5416: remove(path); \ ! 5417: } \ ! 5418: } \ ! 5419: } ! 5420: ! 5421: void msdos_finish() ! 5422: { ! 5423: for(int i = 0; i < MAX_FILES; i++) { ! 5424: if(file_handler[i].valid) { ! 5425: _close(i); ! 5426: } ! 5427: } ! 5428: #ifdef SUPPORT_AUX_PRN ! 5429: remove_std_file("stdaux.txt"); ! 5430: remove_std_file("stdprn.txt"); ! 5431: #endif ! 5432: msdos_dbcs_table_finish(); ! 5433: } ! 5434: ! 5435: /* ---------------------------------------------------------------------------- ! 5436: PC/AT hardware emulation ! 5437: ---------------------------------------------------------------------------- */ ! 5438: ! 5439: void hardware_init() ! 5440: { ! 5441: cpustate = (i386_state *)CPU_INIT_CALL(CPU_MODEL); ! 5442: CPU_RESET_CALL(CPU_MODEL); ! 5443: cpu_type = (REG32(EDX) >> 8) & 0x0f; ! 5444: cpu_step = (REG32(EDX) >> 0) & 0x0f; ! 5445: i386_set_a20_line(cpustate, 0); ! 5446: #ifdef SUPPORT_HARDWARE ! 5447: pic_init(); ! 5448: //pit_init(); ! 5449: pit_active = 0; ! 5450: #endif ! 5451: } ! 5452: ! 5453: void hardware_finish() ! 5454: { ! 5455: free(cpustate); ! 5456: } ! 5457: ! 5458: void hardware_run() ! 5459: { ! 5460: int ops = 0; ! 5461: ! 5462: while(!cpustate->halted) { ! 5463: #ifdef SUPPORT_DISASSEMBLER ! 5464: if(dasm) { ! 5465: char buffer[256]; ! 5466: UINT64 eip = cpustate->eip; ! 5467: UINT8 *oprom = mem + cpustate->sreg[CS].base + cpustate->eip; ! 5468: ! 5469: if(cpustate->operand_size) { ! 5470: CPU_DISASSEMBLE_CALL(x86_32); ! 5471: } else { ! 5472: CPU_DISASSEMBLE_CALL(x86_16); ! 5473: } ! 5474: fprintf(stderr, "%04x:%04x\t%s\n", cpustate->sreg[CS].selector, cpustate->eip, buffer); ! 5475: } ! 5476: #endif ! 5477: cpustate->cycles = 1; ! 5478: CPU_EXECUTE_CALL(i386); ! 5479: #ifdef SUPPORT_HARDWARE ! 5480: if(++ops == 1024) { ! 5481: hardware_update(); ! 5482: ops = 0; ! 5483: } ! 5484: #endif ! 5485: } ! 5486: } ! 5487: ! 5488: #ifdef SUPPORT_HARDWARE ! 5489: void hardware_update() ! 5490: { ! 5491: if(pit_active) { ! 5492: pit_run(); ! 5493: } ! 5494: } ! 5495: #endif ! 5496: ! 5497: // pic ! 5498: ! 5499: void pic_init() ! 5500: { ! 5501: for(int c = 0; c < 2; c++) { ! 5502: pic[c].imr = 0xff; ! 5503: pic[c].irr = pic[c].isr = pic[c].prio = 0; ! 5504: pic[c].icw1 = pic[c].icw2 = pic[c].icw3 = pic[c].icw4 = 0; ! 5505: pic[c].ocw3 = 0; ! 5506: pic[c].icw2_r = pic[c].icw3_r = pic[c].icw4_r = 0; ! 5507: } ! 5508: ! 5509: // from bochs bios ! 5510: pic_write(0, 0, 0x11); // icw1 = 11h ! 5511: pic_write(0, 1, 0x08); // icw2 = 08h ! 5512: pic_write(0, 1, 0x04); // icw3 = 04h ! 5513: pic_write(0, 1, 0x01); // icw4 = 01h ! 5514: pic_write(0, 1, 0xb8); // ocw1 = b8h ! 5515: pic_write(1, 0, 0x11); // icw1 = 11h ! 5516: pic_write(1, 1, 0x70); // icw2 = 70h ! 5517: pic_write(1, 1, 0x02); // icw3 = 02h ! 5518: pic_write(1, 1, 0x01); // icw4 = 01h ! 5519: } ! 5520: ! 5521: void pic_write(int c, UINT32 addr, UINT8 data) ! 5522: { ! 5523: if(addr & 1) { ! 5524: if(pic[c].icw2_r) { ! 5525: // icw2 ! 5526: pic[c].icw2 = data; ! 5527: pic[c].icw2_r = 0; ! 5528: } else if(pic[c].icw3_r) { ! 5529: // icw3 ! 5530: pic[c].icw3 = data; ! 5531: pic[c].icw3_r = 0; ! 5532: } else if(pic[c].icw4_r) { ! 5533: // icw4 ! 5534: pic[c].icw4 = data; ! 5535: pic[c].icw4_r = 0; ! 5536: } else { ! 5537: // ocw1 ! 5538: pic[c].imr = data; ! 5539: } ! 5540: } else { ! 5541: if(data & 0x10) { ! 5542: // icw1 ! 5543: pic[c].icw1 = data; ! 5544: pic[c].icw2_r = 1; ! 5545: pic[c].icw3_r = (data & 2) ? 0 : 1; ! 5546: pic[c].icw4_r = data & 1; ! 5547: ! 5548: pic[c].irr = 0; ! 5549: pic[c].isr = 0; ! 5550: pic[c].imr = 0; ! 5551: pic[c].prio = 0; ! 5552: if(!(pic[c].icw1 & 1)) { ! 5553: pic[c].icw4 = 0; ! 5554: } ! 5555: pic[c].ocw3 = 0; ! 5556: } else if(data & 8) { ! 5557: // ocw3 ! 5558: if(!(data & 2)) { ! 5559: data = (data & ~1) | (pic[c].ocw3 & 1); ! 5560: } ! 5561: if(!(data & 0x40)) { ! 5562: data = (data & ~0x20) | (pic[c].ocw3 & 0x20); ! 5563: } ! 5564: pic[c].ocw3 = data; ! 5565: } else { ! 5566: // ocw2 ! 5567: int level = 0; ! 5568: if(data & 0x40) { ! 5569: level = data & 7; ! 5570: } else { ! 5571: if(!pic[c].isr) { ! 5572: return; ! 5573: } ! 5574: level = pic[c].prio; ! 5575: while(!(pic[c].isr & (1 << level))) { ! 5576: level = (level + 1) & 7; ! 5577: } ! 5578: } ! 5579: if(data & 0x80) { ! 5580: pic[c].prio = (level + 1) & 7; ! 5581: } ! 5582: if(data & 0x20) { ! 5583: pic[c].isr &= ~(1 << level); ! 5584: } ! 5585: } ! 5586: } ! 5587: pic_update(); ! 5588: } ! 5589: ! 5590: UINT8 pic_read(int c, UINT32 addr) ! 5591: { ! 5592: if(addr & 1) { ! 5593: return(pic[c].imr); ! 5594: } else { ! 5595: // polling mode is not supported... ! 5596: //if(pic[c].ocw3 & 4) { ! 5597: // return ???; ! 5598: //} ! 5599: if(pic[c].ocw3 & 1) { ! 5600: return(pic[c].isr); ! 5601: } else { ! 5602: return(pic[c].irr); ! 5603: } ! 5604: } ! 5605: } ! 5606: ! 5607: void pic_req(int c, int level, int signal) ! 5608: { ! 5609: if(signal) { ! 5610: pic[c].irr |= (1 << level); ! 5611: } else { ! 5612: pic[c].irr &= ~(1 << level); ! 5613: } ! 5614: pic_update(); ! 5615: } ! 5616: ! 5617: int pic_ack() ! 5618: { ! 5619: // ack (INTA=L) ! 5620: pic[pic_req_chip].isr |= pic_req_bit; ! 5621: pic[pic_req_chip].irr &= ~pic_req_bit; ! 5622: if(pic_req_chip > 0) { ! 5623: // update isr and irr of master ! 5624: UINT8 slave = 1 << (pic[pic_req_chip].icw3 & 7); ! 5625: pic[pic_req_chip - 1].isr |= slave; ! 5626: pic[pic_req_chip - 1].irr &= ~slave; ! 5627: } ! 5628: //if(pic[pic_req_chip].icw4 & 1) { ! 5629: // 8086 mode ! 5630: int vector = (pic[pic_req_chip].icw2 & 0xf8) | pic_req_level; ! 5631: //} else { ! 5632: // // 8080 mode ! 5633: // UINT16 addr = (UINT16)pic[pic_req_chip].icw2 << 8; ! 5634: // if(pic[pic_req_chip].icw1 & 4) { ! 5635: // addr |= (pic[pic_req_chip].icw1 & 0xe0) | (pic_req_level << 2); ! 5636: // } else { ! 5637: // addr |= (pic[pic_req_chip].icw1 & 0xc0) | (pic_req_level << 3); ! 5638: // } ! 5639: // vector = 0xcd | (addr << 8); ! 5640: //} ! 5641: if(pic[pic_req_chip].icw4 & 2) { ! 5642: // auto eoi ! 5643: pic[pic_req_chip].isr &= ~pic_req_bit; ! 5644: } ! 5645: return(vector); ! 5646: } ! 5647: ! 5648: void pic_update() ! 5649: { ! 5650: for(int c = 0; c < 2; c++) { ! 5651: UINT8 irr = pic[c].irr; ! 5652: if(c + 1 < 2) { ! 5653: // this is master ! 5654: if(pic[c + 1].irr & (~pic[c + 1].imr)) { ! 5655: // request from slave ! 5656: irr |= 1 << (pic[c + 1].icw3 & 7); ! 5657: } ! 5658: } ! 5659: irr &= (~pic[c].imr); ! 5660: if(!irr) { ! 5661: break; ! 5662: } ! 5663: if(!(pic[c].ocw3 & 0x20)) { ! 5664: irr |= pic[c].isr; ! 5665: } ! 5666: int level = pic[c].prio; ! 5667: UINT8 bit = 1 << level; ! 5668: while(!(irr & bit)) { ! 5669: level = (level + 1) & 7; ! 5670: bit = 1 << level; ! 5671: } ! 5672: if((c + 1 < 2) && (pic[c].icw3 & bit)) { ! 5673: // check slave ! 5674: continue; ! 5675: } ! 5676: if(pic[c].isr & bit) { ! 5677: break; ! 5678: } ! 5679: // interrupt request ! 5680: pic_req_chip = c; ! 5681: pic_req_level = level; ! 5682: pic_req_bit = bit; ! 5683: i386_set_irq_line(cpustate, INPUT_LINE_IRQ, HOLD_LINE); ! 5684: return; ! 5685: } ! 5686: i386_set_irq_line(cpustate, INPUT_LINE_IRQ, CLEAR_LINE); ! 5687: }; ! 5688: ! 5689: // pit ! 5690: ! 5691: #define PIT_FREQ 1193182 ! 5692: #define PIT_COUNT_VALUE(n) ((pit[n].count_reg == 0) ? 0x10000 : (pit[n].mode == 3 && pit[n].count_reg == 1) ? 0x10001 : pit[n].count_reg) ! 5693: ! 5694: void pit_init() ! 5695: { ! 5696: for(int ch = 0; ch < 3; ch++) { ! 5697: pit[ch].prev_out = 1; ! 5698: //pit[ch].gate = 1; ! 5699: pit[ch].count = 0x10000; ! 5700: pit[ch].count_reg = 0; ! 5701: pit[ch].ctrl_reg = 0x34; ! 5702: pit[ch].mode = 3; ! 5703: pit[ch].count_latched = 0; ! 5704: pit[ch].low_read = pit[ch].high_read = 0; ! 5705: pit[ch].low_write = pit[ch].high_write = 0; ! 5706: pit[ch].delay = 0; ! 5707: pit[ch].start = 0; ! 5708: pit[ch].null_count = 1; ! 5709: pit[ch].status_latched = 0; ! 5710: } ! 5711: ! 5712: // from bochs bios ! 5713: pit_write(3, 0x34); ! 5714: pit_write(0, 0x00); ! 5715: pit_write(0, 0x00); ! 5716: } ! 5717: ! 5718: void pit_write(int ch, UINT8 val) ! 5719: { ! 5720: if(!pit_active) { ! 5721: pit_active = 1; ! 5722: pit_init(); ! 5723: } ! 5724: ! 5725: switch(ch) { ! 5726: case 0: ! 5727: case 1: ! 5728: case 2: ! 5729: // write count register ! 5730: if(!pit[ch].low_write && !pit[ch].high_write) { ! 5731: if(pit[ch].ctrl_reg & 0x10) { ! 5732: pit[ch].low_write = 1; ! 5733: } ! 5734: if(pit[ch].ctrl_reg & 0x20) { ! 5735: pit[ch].high_write = 1; ! 5736: } ! 5737: } ! 5738: if(pit[ch].low_write) { ! 5739: pit[ch].count_reg = val; ! 5740: pit[ch].low_write = 0; ! 5741: } else if(pit[ch].high_write) { ! 5742: if((pit[ch].ctrl_reg & 0x30) == 0x20) { ! 5743: pit[ch].count_reg = val << 8; ! 5744: } else { ! 5745: pit[ch].count_reg |= val << 8; ! 5746: } ! 5747: pit[ch].high_write = 0; ! 5748: } ! 5749: pit[ch].null_count = 1; ! 5750: // set signal ! 5751: if(pit[ch].mode == 0) { ! 5752: pit_set_signal(ch, 0); ! 5753: } else { ! 5754: pit_set_signal(ch, 1); ! 5755: } ! 5756: // start count ! 5757: if(pit[ch].mode == 0 || pit[ch].mode == 4) { ! 5758: // restart with new count ! 5759: pit_stop_count(ch); ! 5760: pit[ch].delay = 1; ! 5761: pit_start_count(ch); ! 5762: } else if(pit[ch].mode == 2 || pit[ch].mode == 3) { ! 5763: // start with new pit after the current count is finished ! 5764: if(!pit[ch].start) { ! 5765: pit[ch].delay = 1; ! 5766: pit_start_count(ch); ! 5767: } ! 5768: } ! 5769: break; ! 5770: case 3: // ctrl reg ! 5771: if((val & 0xc0) == 0xc0) { ! 5772: // i8254 read-back command ! 5773: for(ch = 0; ch < 3; ch++) { ! 5774: UINT8 bit = 2 << ch; ! 5775: if(!(val & 0x10) && !pit[ch].status_latched) { ! 5776: pit[ch].status = pit[ch].ctrl_reg & 0x3f; ! 5777: if(pit[ch].prev_out) { ! 5778: pit[ch].status |= 0x80; ! 5779: } ! 5780: if(pit[ch].null_count) { ! 5781: pit[ch].status |= 0x40; ! 5782: } ! 5783: pit[ch].status_latched = 1; ! 5784: } ! 5785: if(!(val & 0x20) && !pit[ch].count_latched) { ! 5786: pit_latch_count(ch); ! 5787: } ! 5788: } ! 5789: break; ! 5790: } ! 5791: ch = (val >> 6) & 3; ! 5792: if(val & 0x30) { ! 5793: static int modes[8] = {0, 1, 2, 3, 4, 5, 2, 3}; ! 5794: pit[ch].mode = modes[(val >> 1) & 7]; ! 5795: pit[ch].count_latched = 0; ! 5796: pit[ch].low_read = pit[ch].high_read = 0; ! 5797: pit[ch].low_write = pit[ch].high_write = 0; ! 5798: pit[ch].ctrl_reg = val; ! 5799: // set signal ! 5800: if(pit[ch].mode == 0) { ! 5801: pit_set_signal(ch, 0); ! 5802: } else { ! 5803: pit_set_signal(ch, 1); ! 5804: } ! 5805: // stop count ! 5806: pit_stop_count(ch); ! 5807: pit[ch].count_reg = 0; ! 5808: pit[ch].null_count = 1; ! 5809: } else if(!pit[ch].count_latched) { ! 5810: pit_latch_count(ch); ! 5811: } ! 5812: break; ! 5813: } ! 5814: } ! 5815: ! 5816: UINT8 pit_read(int ch) ! 5817: { ! 5818: if(!pit_active) { ! 5819: pit_active = 1; ! 5820: pit_init(); ! 5821: } ! 5822: ! 5823: switch(ch) { ! 5824: case 0: ! 5825: case 1: ! 5826: case 2: ! 5827: if(pit[ch].status_latched) { ! 5828: pit[ch].status_latched = 0; ! 5829: return(pit[ch].status); ! 5830: } ! 5831: // if not latched, through current count ! 5832: if(!pit[ch].count_latched) { ! 5833: if(!pit[ch].low_read && !pit[ch].high_read) { ! 5834: pit_latch_count(ch); ! 5835: } ! 5836: } ! 5837: // return latched count ! 5838: if(pit[ch].low_read) { ! 5839: pit[ch].low_read = 0; ! 5840: if(!pit[ch].high_read) { ! 5841: pit[ch].count_latched = 0; ! 5842: } ! 5843: return(pit[ch].latch & 0xff); ! 5844: } else if(pit[ch].high_read) { ! 5845: pit[ch].high_read = 0; ! 5846: pit[ch].count_latched = 0; ! 5847: return((pit[ch].latch >> 8) & 0xff); ! 5848: } ! 5849: } ! 5850: return(0xff); ! 5851: } ! 5852: ! 5853: void pit_run() ! 5854: { ! 5855: static UINT32 prev_time = 0; ! 5856: UINT32 cur_time = timeGetTime(); ! 5857: ! 5858: if(prev_time == cur_time) { ! 5859: return; ! 5860: } ! 5861: prev_time = cur_time; ! 5862: ! 5863: for(int ch = 0; ch < 3; ch++) { ! 5864: if(pit[ch].start && cur_time >= pit[ch].expired_time) { ! 5865: pit_input_clock(ch, pit[ch].input_clk); ! 5866: ! 5867: // next expired time ! 5868: if(pit[ch].start) { ! 5869: pit[ch].input_clk = pit[ch].delay ? 1 : pit_get_next_count(ch); ! 5870: pit[ch].prev_time = pit[ch].expired_time; ! 5871: pit[ch].expired_time += pit_get_expired_time(pit[ch].input_clk); ! 5872: if(pit[ch].expired_time <= cur_time) { ! 5873: pit[ch].prev_time = cur_time; ! 5874: pit[ch].expired_time = cur_time + pit_get_expired_time(pit[ch].input_clk); ! 5875: } ! 5876: } ! 5877: } ! 5878: } ! 5879: } ! 5880: ! 5881: void pit_input_clock(int ch, int clock) ! 5882: { ! 5883: if(!(pit[ch].start && clock)) { ! 5884: return; ! 5885: } ! 5886: if(pit[ch].delay) { ! 5887: clock -= 1; ! 5888: pit[ch].delay = 0; ! 5889: pit[ch].count = PIT_COUNT_VALUE(ch); ! 5890: pit[ch].null_count = 0; ! 5891: } ! 5892: ! 5893: // update pit ! 5894: pit[ch].count -= clock; ! 5895: INT32 tmp = PIT_COUNT_VALUE(ch); ! 5896: loop: ! 5897: if(pit[ch].mode == 3) { ! 5898: INT32 half = tmp >> 1; ! 5899: if(pit[ch].count > half) { ! 5900: pit_set_signal(ch, 1); ! 5901: } else { ! 5902: pit_set_signal(ch, 0); ! 5903: } ! 5904: } else { ! 5905: if(pit[ch].count <= 1) { ! 5906: if(pit[ch].mode == 2 || pit[ch].mode == 4 || pit[ch].mode == 5) { ! 5907: pit_set_signal(ch, 0); ! 5908: } ! 5909: } ! 5910: if(pit[ch].count <= 0) { ! 5911: pit_set_signal(ch, 1); ! 5912: } ! 5913: } ! 5914: if(pit[ch].count <= 0) { ! 5915: if(pit[ch].mode == 0 || pit[ch].mode == 2 || pit[ch].mode == 3) { ! 5916: pit[ch].count += tmp; ! 5917: pit[ch].null_count = 0; ! 5918: goto loop; ! 5919: } else { ! 5920: pit[ch].start = 0; ! 5921: pit[ch].count = 0x10000; ! 5922: } ! 5923: } ! 5924: } ! 5925: ! 5926: void pit_start_count(int ch) ! 5927: { ! 5928: if(pit[ch].low_write || pit[ch].high_write) { ! 5929: return; ! 5930: } ! 5931: //if(!pit[ch].gate) { ! 5932: // return; ! 5933: //} ! 5934: pit[ch].start = 1; ! 5935: ! 5936: // next expired time ! 5937: pit[ch].input_clk = pit[ch].delay ? 1 : pit_get_next_count(ch); ! 5938: UINT32 cur_time = timeGetTime(); ! 5939: pit[ch].prev_time = cur_time; ! 5940: pit[ch].expired_time = cur_time + pit_get_expired_time(pit[ch].input_clk); ! 5941: } ! 5942: ! 5943: void pit_stop_count(int ch) ! 5944: { ! 5945: pit[ch].start = 0; ! 5946: } ! 5947: ! 5948: void pit_latch_count(int ch) ! 5949: { ! 5950: if(pit[ch].start) { ! 5951: // update pit ! 5952: UINT32 cur_time = timeGetTime(); ! 5953: if(cur_time > pit[ch].prev_time) { ! 5954: UINT32 input = PIT_FREQ * (cur_time - pit[ch].prev_time) / 1000; ! 5955: pit_input_clock(ch, input); ! 5956: ! 5957: if(pit[ch].input_clk <= input) { ! 5958: // next expired time ! 5959: if(pit[ch].start) { ! 5960: pit[ch].input_clk = pit[ch].delay ? 1 : pit_get_next_count(ch); ! 5961: pit[ch].prev_time = pit[ch].expired_time; ! 5962: pit[ch].expired_time += pit_get_expired_time(pit[ch].input_clk); ! 5963: if(pit[ch].expired_time <= cur_time) { ! 5964: pit[ch].prev_time = cur_time; ! 5965: pit[ch].expired_time = cur_time + pit_get_expired_time(pit[ch].input_clk); ! 5966: } ! 5967: } ! 5968: } else { ! 5969: pit[ch].input_clk -= input; ! 5970: pit[ch].prev_time = cur_time; ! 5971: } ! 5972: } ! 5973: } ! 5974: // latch pit ! 5975: pit[ch].latch = (UINT16)pit[ch].count; ! 5976: pit[ch].count_latched = 1; ! 5977: if((pit[ch].ctrl_reg & 0x30) == 0x10) { ! 5978: // lower byte ! 5979: pit[ch].low_read = 1; ! 5980: pit[ch].high_read = 0; ! 5981: } else if((pit[ch].ctrl_reg & 0x30) == 0x20) { ! 5982: // upper byte ! 5983: pit[ch].low_read = 0; ! 5984: pit[ch].high_read = 1; ! 5985: } else { ! 5986: // lower -> upper ! 5987: pit[ch].low_read = pit[ch].low_read = 1; ! 5988: } ! 5989: } ! 5990: ! 5991: void pit_set_signal(int ch, int signal) ! 5992: { ! 5993: int prev = pit[ch].prev_out; ! 5994: pit[ch].prev_out = signal; ! 5995: ! 5996: if(prev && !signal) { ! 5997: // H->L ! 5998: if(ch == 0) { ! 5999: pic_req(0, 0, 0); ! 6000: } ! 6001: } else if(!prev && signal) { ! 6002: // L->H ! 6003: if(ch == 0) { ! 6004: pic_req(0, 0, 1); ! 6005: } ! 6006: } ! 6007: } ! 6008: ! 6009: int pit_get_next_count(int ch) ! 6010: { ! 6011: if(pit[ch].mode == 2 || pit[ch].mode == 4 || pit[ch].mode == 5) { ! 6012: if(pit[ch].count > 1) { ! 6013: return(pit[ch].count - 1); ! 6014: } else { ! 6015: return(1); ! 6016: } ! 6017: } ! 6018: if(pit[ch].mode == 3) { ! 6019: INT32 half = PIT_COUNT_VALUE(ch) >> 1; ! 6020: if(pit[ch].count > half) { ! 6021: return(pit[ch].count - half); ! 6022: } else { ! 6023: return(pit[ch].count); ! 6024: } ! 6025: } ! 6026: return(pit[ch].count); ! 6027: } ! 6028: ! 6029: int pit_get_expired_time(int clock) ! 6030: { ! 6031: UINT32 val = 1000 * clock / PIT_FREQ; ! 6032: ! 6033: if(val > 0) { ! 6034: return(val); ! 6035: } else { ! 6036: return(1); ! 6037: } ! 6038: } ! 6039: ! 6040: // i/o bus ! 6041: ! 6042: UINT8 read_io_byte(offs_t addr) ! 6043: { ! 6044: switch(addr) { ! 6045: #ifdef SUPPORT_HARDWARE ! 6046: case 0x20: ! 6047: case 0x21: ! 6048: return(pic_read(0, addr)); ! 6049: case 0x40: ! 6050: case 0x41: ! 6051: case 0x42: ! 6052: case 0x43: ! 6053: return(pit_read(addr & 0x03)); ! 6054: #endif ! 6055: case 0x71: ! 6056: return(cmos[cmos_addr & 0x7f]); ! 6057: case 0x92: ! 6058: return((cpustate->a20_mask >> 19) & 2); ! 6059: #ifdef SUPPORT_HARDWARE ! 6060: case 0xa0: ! 6061: case 0xa1: ! 6062: return(pic_read(1, addr)); ! 6063: #endif ! 6064: default: ! 6065: // error("inb %4x\n", addr); ! 6066: break; ! 6067: } ! 6068: return(0xff); ! 6069: } ! 6070: ! 6071: UINT16 read_io_word(offs_t addr) ! 6072: { ! 6073: return(read_io_byte(addr) | (read_io_byte(addr + 1) << 8)); ! 6074: } ! 6075: ! 6076: UINT32 read_io_dword(offs_t addr) ! 6077: { ! 6078: return(read_io_byte(addr) | (read_io_byte(addr + 1) << 8) | (read_io_byte(addr + 2) << 16) | (read_io_byte(addr + 3) << 24)); ! 6079: } ! 6080: ! 6081: void write_io_byte(offs_t addr, UINT8 val) ! 6082: { ! 6083: switch(addr) { ! 6084: #ifdef SUPPORT_HARDWARE ! 6085: case 0x20: ! 6086: case 0x21: ! 6087: pic_write(0, addr, val); ! 6088: break; ! 6089: case 0x40: ! 6090: case 0x41: ! 6091: case 0x42: ! 6092: case 0x43: ! 6093: pit_write(addr & 0x03, val); ! 6094: break; ! 6095: #endif ! 6096: case 0x64: ! 6097: if(val == 0xfe) { ! 6098: if(cmos[0x0f] == 5) { ! 6099: // reset pic ! 6100: pic_init(); ! 6101: pic[0].irr = pic[1].irr = 0x00; ! 6102: pic[0].imr = pic[1].imr = 0xff; ! 6103: } ! 6104: CPU_RESET_CALL(CPU_MODEL); ! 6105: i386_jmp_far(0x40, 0x67); ! 6106: } ! 6107: break; ! 6108: case 0x70: ! 6109: cmos_addr = val; ! 6110: break; ! 6111: case 0x71: ! 6112: cmos[cmos_addr & 7] = val; ! 6113: break; ! 6114: case 0x92: ! 6115: i386_set_a20_line(cpustate, val & 2); ! 6116: break; ! 6117: #ifdef SUPPORT_HARDWARE ! 6118: case 0xa0: ! 6119: case 0xa1: ! 6120: pic_write(1, addr, val); ! 6121: break; ! 6122: #endif ! 6123: default: ! 6124: // error("outb %4x,%2x\n", addr, val); ! 6125: break; ! 6126: } ! 6127: } ! 6128: ! 6129: void write_io_word(offs_t addr, UINT16 val) ! 6130: { ! 6131: write_io_byte(addr + 0, (val >> 0) & 0xff); ! 6132: write_io_byte(addr + 1, (val >> 8) & 0xff); ! 6133: } ! 6134: ! 6135: void write_io_dword(offs_t addr, UINT32 val) ! 6136: { ! 6137: write_io_byte(addr + 0, (val >> 0) & 0xff); ! 6138: write_io_byte(addr + 1, (val >> 8) & 0xff); ! 6139: write_io_byte(addr + 2, (val >> 16) & 0xff); ! 6140: write_io_byte(addr + 3, (val >> 24) & 0xff); ! 6141: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.