Example #1
0
File: sms.go Project: remogatto/sms
func (sms *SMS) LoadROM(fileName string) {
	application.Logf("Reading from file %s", fileName)
	data, err := readROM(fileName)
	if err != nil {
		panic(err)
	}
	size := len(data)
	// Calculate number of pages from file size and create array appropriately
	numROMBanks := size / PAGE_SIZE
	sms.memory.romBanks = make([][]byte, numROMBanks)
	application.Logf("Found %d ROM banks", numROMBanks)
	for i := 0; i < numROMBanks; i++ {
		sms.memory.romBanks[i] = make([]byte, PAGE_SIZE)
		// Read file into pages array
		for j := 0; j < PAGE_SIZE; j++ {
			sms.memory.romBanks[i][j] = data[(i*PAGE_SIZE)+j]
		}

	}
	for i := 0; i < 3; i++ {
		sms.memory.pages[i] = byte(i % numROMBanks)
	}
	sms.memory.romPageMask = byte(numROMBanks - 1)
	sms.memory.maskedPage0 = sms.memory.pages[0] & sms.memory.romPageMask
	sms.memory.maskedPage1 = sms.memory.pages[1] & sms.memory.romPageMask
	sms.memory.maskedPage2 = sms.memory.pages[2] & sms.memory.romPageMask
	sms.memory.romBank0 = make([]byte, PAGE_SIZE)
	copy(sms.memory.romBank0, sms.memory.romBanks[sms.memory.maskedPage0][:])
}
Example #2
0
func (l *watcherLoop) Run() {
	// Run the tests for the first time.
	execGoTest(l.paths)

	watcher, err := fsnotify.NewWatcher()

	for _, path := range l.paths {
		err = watcher.Watch(path)
		if err != nil {
			application.Fatal(err.Error())
		}
		application.Printf("Start watching path %s", path)
	}

	for {
		select {
		case <-l.pause:
			l.pause <- 0
		case <-l.terminate:
			watcher.Close()
			l.terminate <- 0
			return
		case ev := <-watcher.Event:
			if ev.IsModify() {
				if matches(ev.Name, ".*\\.go$") {
					if application.Verbose {
						application.Logf("Event %s occured for file %s", ev, ev.Name)
					}
					// check if the same event was
					// registered for the same
					// file in the acceptable
					// TIME_DISCARD time window
					event := getEvent(ev.Name)
					if event == nil {
						event = addEvent(&eventOnFile{ev, time.Now()})
						application.Logf("Run the tests")
						execGoTest(l.paths)
					} else if time.Now().Sub(event.time) > DISCARD_TIME {
						event.time = time.Now()
						application.Logf("Run the tests")
						execGoTest(l.paths)
					} else {
						if application.Verbose {
							application.Logf("Event %s was discarded for file %s", ev, ev.Name)
						}
					}
				}
			}
		case err := <-watcher.Error:
			application.Fatal(err.Error())
		}
	}
}
Example #3
0
// Run runs the commandLoop.
// The loop waits for commands sent to sms.command channel.
func (l *commandLoop) Run() {
	for {
		select {
		case <-l.pause:
			l.pause <- 0
		case <-l.terminate:
			l.terminate <- 0
		case _cmd := <-l.emulatorLoop.sms.command:
			switch cmd := _cmd.(type) {

			case cmdRenderFrame:
				l.displayLoop.Display() <- l.emulatorLoop.sms.frame()

			case cmdLoadRom:
				l.emulatorLoop.sms.loadRom(cmd.fileName)

			case cmdJoypadEvent:
				l.emulatorLoop.sms.joypad(cmd.value, cmd.event)

			case cmdPauseEmulation:
				l.emulatorLoop.pauseEmulation <- 0
				<-l.emulatorLoop.pauseEmulation
				cmd.paused <- l.emulatorLoop.sms.paused

			case cmdShowCurrentInstruction:

				prevAddr := z80.PreviousInstruction(l.emulatorLoop.sms.memory, l.emulatorLoop.sms.cpu.PC())
				res, address, shift := z80.Disassemble(l.emulatorLoop.sms.memory, prevAddr, 0)
				if res != "shift " {
					application.Logf("0x%04x %s\n", l.emulatorLoop.sms.cpu.PC(), res)
				}

				res, address, shift = z80.Disassemble(l.emulatorLoop.sms.memory, l.emulatorLoop.sms.cpu.PC(), 0)
				if res != "shift " {
					application.Logf("0x%04x %s\n", l.emulatorLoop.sms.cpu.PC(), res)
				}
				for i := 0; i < 20; i++ {
					oldAddress := address
					res, address, shift = z80.Disassemble(l.emulatorLoop.sms.memory, address, shift)
					if res != "shift " {
						application.Logf("0x%04x %s\n", oldAddress, res)
					}
					//					address++
				}

			}
		}
	}
}
Example #4
0
func (p *Ports) WritePortInternal(address uint16, b byte, contend bool) {
	switch byte(address) {
	case 0x3f:
		// Nationalisation, pretend we're British.
		natbit := ((b >> 5) & 1)
		if (b & 1) == 0 {
			natbit = 1
		}
		p.sms.joystick = (p.sms.joystick & ^(1 << 6)) | int(natbit<<6)
		natbit = ((b >> 7) & 1)
		if (b & 4) == 0 {
			natbit = 1
		}
		p.sms.joystick = (p.sms.joystick & ^(1 << 7)) | int(natbit<<7)
		break
	case 0x7e, 0x7f:
		//	soundChip.poke(val);
		break
	case 0xbd, 0xbf:
		p.sms.vdp.writeAddr(uint16(b))
		break
	case 0xbe:
		p.sms.vdp.writeByte(b)
		break
	case 0xde, 0xdf:
		break // Unknown use
	case 0xf0, 0xf1, 0xf2:
		break // YM2413 sound support: TODO
		// default:
		// 	console.log('IO port ' + hexbyte(addr) + ' = ' + val);
		// 	break;
	default:
		application.Logf("Write to IO port %x\n", address)
	}
}
Example #5
0
func newSDL2xScreen(fullScreen bool) *sdl2xScreen {
	sdlMode := uint32(sdl.SWSURFACE)
	if fullScreen {
		application.Logf("%s", "Activate fullscreen mode")
		sdlMode = sdl.FULLSCREEN
		sdl.ShowCursor(sdl.DISABLE)
	}
	screenSurface := &sdlSurface{sdl.SetVideoMode(SCREEN_WIDTH*2, SCREEN_HEIGHT*2, 32, sdlMode)}
	if screenSurface.surface == nil {
		log.Printf("%s", sdl.GetError())
		application.Exit()
		return nil
	}
	borderSurface := &sdlSurface{sdl.CreateRGBSurface(sdl.SWSURFACE, SCREEN_WIDTH*2, SCREEN_HEIGHT*2, 32, 0, 0, 0, 0)}
	if borderSurface.surface == nil {
		log.Printf("%s", sdl.GetError())
		application.Exit()
		return nil
	}
	displaySurface := &sdlSurface{sdl.CreateRGBSurface(sdl.SWSURFACE, DISPLAY_WIDTH*2, DISPLAY_HEIGHT*2, 32, 0, 0, 0, 0)}
	if displaySurface.surface == nil {
		log.Printf("%s", sdl.GetError())
		application.Exit()
		return nil
	}
	return &sdl2xScreen{screenSurface, borderSurface, displaySurface}
}
Example #6
0
File: main.go Project: Sas0ri/sms
// showDisassembled prints out disassembled code.
func showDisassembled(instructions []z80.DebugInstruction) {
	arrow := ""
	for line, instr := range instructions {
		if line == 0 {
			arrow = "=>>"
		} else {
			arrow = ""
		}
		application.Logf(arrow+"\t0x%04x %s\n", instr.Address, instr.Mnemonic)
	}
}
Example #7
0
func (sms *SMS) joypad(value int, event byte) {
	switch event {
	case JOYPAD_DOWN:
		sms.joystick &= ^value
		break
	case JOYPAD_UP:
		sms.joystick |= value
		break
	default:
		application.Logf("%s", "Unknown joypad event")
		break
	}
}
Example #8
0
func (l *inputLoop) Run() {
	for {
		select {
		case <-l.pause:
			l.pause <- 0

		case <-l.terminate:
			l.terminate <- 0

		case _event := <-sdl.Events:
			switch e := _event.(type) {
			case sdl.QuitEvent:
				application.Exit()
			case sdl.KeyboardEvent:
				keyName := sdl.GetKeyName(sdl.Key(e.Keysym.Sym))
				application.Logf("%d: %s\n", e.Keysym.Sym, keyName)
				if e.Type == sdl.KEYDOWN {
					l.sms.command <- cmdJoypadEvent{keyMap[keyName], JOYPAD_DOWN}
				} else if e.Type == sdl.KEYUP {
					l.sms.command <- cmdJoypadEvent{keyMap[keyName], JOYPAD_UP}
				}
				if e.Type == sdl.KEYDOWN && keyName == "p" {
					paused := make(chan bool)
					l.sms.paused = !l.sms.paused
					l.sms.command <- cmdPauseEmulation{paused}
					<-paused
				}
				if e.Type == sdl.KEYDOWN && keyName == "d" {
					l.sms.paused = true
					paused := make(chan bool)
					l.sms.command <- cmdPauseEmulation{paused}
					<-paused
					l.sms.command <- cmdShowCurrentInstruction{}
				}
				if e.Keysym.Sym == sdl.K_ESCAPE {
					application.Exit()
				}

			}
		}
	}
}