![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hconsole.py CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / tools / hconsole|
Return to hconsole.py CVS log | Up to [HATARI the Atari ST Emulator] / hatari / tools / hconsole |
1.1 root 1: #!/usr/bin/env python
2: #
3: # Hatari console:
4: # Allows using Hatari shortcuts & debugger, changing paths, toggling
5: # devices and changing Hatari command line options (even for things you
6: # cannot change from the UI) from the console while Hatari is running.
7: #
8: # Copyright (C) 2008-2011 by Eero Tamminen <eerot at berlios>
9: #
10: # This program is free software; you can redistribute it and/or modify
11: # it under the terms of the GNU General Public License as published by
12: # the Free Software Foundation; either version 2 of the License, or
13: # (at your option) any later version.
14: #
15: # This program is distributed in the hope that it will be useful,
16: # but WITHOUT ANY WARRANTY; without even the implied warranty of
17: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18: # GNU General Public License for more details.
19:
20: import os
21: import sys
22: import time
23: import signal
24: import socket
25: import readline
26:
27: # Python v2:
28: # - lacks Python v3 encoding arg for bytes()
29: # - input() evaluates given string and fails on empty one
30: if str is bytes:
31: def bytes(s, encoding):
32: return s
33: def input(prompt):
34: return raw_input(prompt)
35:
36: # Atari scancodes for special keys, needed when wanting to
37: # output something else than alphanumberic keys to Hatari
38: # (when using keypress/down/up commands)
39: class Scancode:
40: Tab = "15"
41: Return = "28"
42: Enter = "114"
43: Space = "57"
44: Delete = "83"
45: Backspace = "14"
46: Escape = "0x1"
47: Control = "29"
48: Alternate = "56"
49: LeftShift = "42"
50: RightShift = "54"
51: CapsLock = "53"
52: Insert = "82"
53: Home = "71"
54: Help = "98"
55: Undo = "97"
56: CursorUp = "72"
57: CursorDown = "80"
58: CursorLeft = "75"
59: CursorRight = "77"
60:
61:
62: # running Hatari instance
63: class Hatari:
64: controlpath = "/tmp/hatari-console-" + str(os.getpid()) + ".socket"
65: hataribin = "hatari"
66:
67: def __init__(self, args = None):
68: # collect hatari process zombies without waitpid()
69: signal.signal(signal.SIGCHLD, signal.SIG_IGN)
70: self._assert_hatari_compatibility()
71: self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
72: if os.path.exists(self.controlpath):
73: os.unlink(self.controlpath)
74: self.server.bind(self.controlpath)
75: self.server.listen(1)
76: self.control = None
77: self.paused = False
78: self.interval = 0.2
79: self.pid = 0
80: if not self.run_hatari(args):
81: print("ERROR: failed to run Hatari")
82: sys.exit(1)
83: self.verbose = False
84:
85: def _assert_hatari_compatibility(self):
86: for line in os.popen(self.hataribin + " -h").readlines():
87: if line.find("--control-socket") >= 0:
88: return
89: print("ERROR: Hatari not found or it doesn't support the required --control-socket option!")
90: sys.exit(-1)
91:
92: def is_running(self):
93: if not self.pid:
94: return False
95: try:
96: os.waitpid(self.pid, os.WNOHANG)
97: except OSError as value:
98: print("Hatari PID %d had exited in the meanwhile:\n\t%s" % (self.pid, value))
99: self.pid = 0
100: return False
101: return True
102:
103: def run_hatari(self, args):
104: if self.control:
105: print("ERROR: Hatari is already running, stop it first")
106: return
107: pid = os.fork()
108: if pid < 0:
109: print("ERROR: fork()ing Hatari failed!")
110: return
111: if pid:
112: # in parent
113: self.pid = pid
114: print("WAIT hatari to connect to control socket...")
115: (self.control, addr) = self.server.accept()
116: print("connected!")
117: return self.control
118: else:
119: # child runs Hatari
120: allargs = [self.hataribin, "--control-socket", self.controlpath] + args
121: print("RUN:", allargs)
122: os.execvp(self.hataribin, allargs)
123:
124: def send_message(self, msg, fast = False):
125: if self.control:
126: if self.verbose:
127: print("-> '%s'" % msg)
128: self.control.sendall(bytes(msg + "\n", "ASCII"))
129: # KLUDGE: wait so that Hatari output comes before next prompt
130: if fast:
131: interval = self.interval/2
132: else:
133: interval = self.interval
134: time.sleep(interval)
135: return True
136: else:
137: print("ERROR: no Hatari (control socket)")
138: return False
139:
140: def change_option(self, option):
141: return self.send_message("hatari-option %s" % option)
142:
143: def trigger_shortcut(self, shortcut):
144: return self.send_message("hatari-shortcut %s" % shortcut)
145:
146: def send_string(self, text):
147: print("string:", text)
148: for item in text:
149: if item == ' ':
150: # white space gets stripped, use scancode instead
151: item = "57"
152: if not self.send_message("hatari-event keypress %s" % item, True):
153: return False
154: return True
155:
156: def insert_event(self, event):
157: if event.startswith("text "):
158: cmd, value = event.split(None, 1)
159: if value:
160: return self.send_string(value)
161: return self.send_message("hatari-event %s" % event, True)
162:
163: def debug_command(self, cmd):
164: return self.send_message("hatari-debug %s" % cmd)
165:
166: def change_path(self, path):
167: return self.send_message("hatari-path %s" % path)
168:
169: def toggle_device(self, device):
170: return self.send_message("hatari-toggle %s" % device)
171:
172: def toggle_pause(self):
173: self.paused = not self.paused
174: if self.paused:
175: return self.send_message("hatari-stop")
176: else:
177: return self.send_message("hatari-cont")
178:
179: def toggle_verbose(self):
180: self.verbose = not self.verbose
181: print("debug output", self.verbose)
182:
183: def kill_hatari(self):
184: if self.pid:
185: os.kill(self.pid, signal.SIGKILL)
186: print("killed hatari with PID %d" % self.pid)
187: self.control = None
188: self.pid = 0
189:
190:
191: # command line parsing with readline
192: class CommandInput:
193: prompt = "hatari-command: "
194: historysize = 99
195:
196: def __init__(self, commands):
197: readline.set_history_length(self.historysize)
198: readline.parse_and_bind("tab: complete")
199: readline.set_completer_delims(" \t\r\n")
200: readline.set_completer(self.complete)
201: self.commands = commands
202:
203: def complete(self, text, state):
204: idx = 0
205: #print "text: '%s', state '%d'" % (text, state)
206: for cmd in self.commands:
207: if cmd.startswith(text):
208: idx += 1
209: if idx > state:
210: return cmd
211:
212: def loop(self):
213: try:
214: rawline = input(self.prompt)
215: return rawline
216: except EOFError:
217: return ""
218:
219:
220: class Tokens:
221: # update with: hatari -h|grep -- --|sed 's/^ *\(--[^ ]*\).*$/ "\1",/'
222: option_tokens = [
223: "--help",
224: "--version",
225: "--confirm-quit",
226: "--configfile",
227: "--fast-forward",
228: "--mono",
229: "--monitor",
230: "--fullscreen",
231: "--window",
232: "--grab",
233: "--zoom",
234: "--max-width",
235: "--max-height",
236: "--aspect",
237: "--borders",
238: "--frameskips",
239: "--statusbar",
240: "--drive-led",
241: "--spec512",
242: "--bpp",
243: "--vdi",
244: "--vdi-planes",
245: "--vdi-width",
246: "--vdi-height",
247: "--avirecord",
248: "--avi-vcodec",
249: "--avi-fps",
250: "--avi-crop",
251: "--avi-file",
252: "--joy0",
253: "--joy1",
254: "--joy2",
255: "--joy3",
256: "--joy4",
257: "--joy5",
258: "--joystick",
259: "--printer",
260: "--midi-in",
261: "--midi-out",
262: "--rs232-in",
263: "--rs232-out",
264: "--disk-a",
265: "--disk-b",
266: "--slowfdc",
267: "--protect-floppy",
268: "--protect-hd",
269: "--harddrive",
270: "--acsi",
271: "--ide-master",
272: "--ide-slave",
273: "--memsize",
274: "--tos",
275: "--cartridge",
276: "--memstate",
277: "--cpulevel",
278: "--cpuclock",
279: "--compatible",
280: "--machine",
281: "--blitter",
282: "--timer-d",
283: "--dsp",
284: "--sound",
285: "--keymap",
286: "--debug",
287: "--bios-intercept",
288: "--trace",
289: "--trace-file",
290: "--parse",
291: "--saveconfig",
292: "--log-file",
293: "--log-level",
294: "--alert-level",
295: "--run-vbls"
296: ]
297: shortcut_tokens = [
298: "mousegrab",
299: "coldreset",
300: "warmreset",
301: "screenshot",
302: "bosskey",
303: "recanim",
304: "recsound",
305: "savemem"
306: ]
307: event_tokens = [
308: "doubleclick",
309: "rightdown",
310: "rightup",
311: "keypress",
312: "keydown",
313: "keyup",
314: "text" # simulated with keypresses
315: ]
316: device_tokens = [
317: "printer",
318: "rs232",
319: "midi",
320: ]
321: path_tokens = [
322: "memauto",
323: "memsave",
324: "midiout",
325: "printout",
326: "soundout",
327: "rs232in",
328: "rs232out"
329: ]
330: # use the long variants of the commands for clarity
331: debugger_tokens = [
332: "address",
333: "breakpoint",
334: "cd",
335: "cont",
336: "cpureg",
337: "disasm",
338: "dspaddress",
339: "dspbreak",
340: "dspcont",
341: "dspdisasm",
342: "dspmemdump",
343: "dspreg",
344: "dspsymbols",
345: "evaluate",
346: "exec",
347: "help",
348: "info",
349: "loadbin",
350: "lock",
351: "logfile",
352: "memdump",
353: "memwrite",
354: "parse",
355: "savebin",
356: "setopt",
357: "stateload",
358: "statesave",
359: "symbols",
360: "trace"
361: ]
362:
363: def __init__(self, hatari):
364: self.process_tokens = {
365: "kill": hatari.kill_hatari,
366: "pause": hatari.toggle_pause
367: }
368: self.script_tokens = {
369: "script": self.do_script,
370: "sleep": self.do_sleep
371: }
372: self.help_tokens = {
373: "usage": self.show_help,
374: "verbose": hatari.toggle_verbose
375: }
376: self.hatari = hatari
377:
378: def get_tokens(self):
379: tokens = []
380: for items in [self.option_tokens, self.shortcut_tokens,
381: self.event_tokens, self.debugger_tokens, self.device_tokens,
382: self.path_tokens, list(self.process_tokens.keys()),
383: list(self.script_tokens.keys()), list(self.help_tokens.keys())]:
384: for token in items:
385: if token in tokens:
386: print("ERROR: token '%s' already in tokens" % token)
387: sys.exit(1)
388: tokens += items
389: return tokens
390:
391: def show_help(self):
392: print("""
393: Hatari-console help
394: -------------------
395:
396: Hatari-console allows you to control Hatari through its control socket
397: from the provided console prompt, while Hatari is running. All control
398: commands support TAB completion on their names and options.
399:
400: The supported control facilities are:""")
401: self.list_items("Command line options", self.option_tokens)
402: self.list_items("Keyboard shortcuts", self.shortcut_tokens)
403: self.list_items("Event invocation", self.event_tokens)
404: self.list_items("Device toggling", self.device_tokens)
405: self.list_items("Path setting", self.path_tokens)
406: self.list_items("Debugger commands", self.debugger_tokens)
407: print("""
408: "pause" toggles Hatari paused state on/off.
409: "kill" will terminate Hatari.
410:
411: "script" command reads commands from the given file.
412: "sleep" command can be used in script to wait given number of seconds.
413: "verbose" command toggles commands debug output on/off.
414:
415: For command line options you can get further help with "--help"
416: and for debugger commands with "help". Some of the other facilities
417: give help when you give them invalid input.
418: """)
419:
420: def list_items(self, title, items):
421: print("\n%s:" % title)
422: for item in items:
423: print("*", item)
424:
425: def do_sleep(self, line):
426: items = line.split()[1:]
427: try:
428: secs = int(items[0])
429: except:
430: secs = 0
431: if secs > 0:
432: print("Sleeping for %d secs..." % secs)
433: time.sleep(secs)
434: else:
435: print("usage: sleep <seconds>")
436:
437: def do_script(self, line):
438: try:
439: filename = line.split()[1]
440: f = open(filename)
441: except:
442: print("usage: script <filename>")
443: return
444:
445: for line in f.readlines():
446: line = line.strip()
447: if not line or line[0] == '#':
448: continue
449: print(">", line)
450: self.process_command(line)
451:
452: def process_command(self, line):
453: if not self.hatari.is_running():
454: print("Exiting as there's no Hatari (anymore)...")
455: sys.exit(0)
456: if not line:
457: return
458:
459: first = line.split()[0]
460: # multiple items
461: if first in self.event_tokens:
462: self.hatari.insert_event(line)
463: elif first in self.debugger_tokens:
464: self.hatari.debug_command(line)
465: elif first in self.option_tokens:
466: self.hatari.change_option(line)
467: elif first in self.path_tokens:
468: self.hatari.change_path(line)
469: elif first in self.script_tokens:
470: self.script_tokens[first](line)
471: # single item
472: elif line in self.device_tokens:
473: self.hatari.toggle_device(line)
474: elif line in self.shortcut_tokens:
475: self.hatari.trigger_shortcut(line)
476: elif line in self.process_tokens:
477: self.process_tokens[line]()
478: elif line in self.help_tokens:
479: self.help_tokens[line]()
480: else:
481: print("ERROR: unknown hatari-console command:", line)
482:
483:
484: class Main:
485: def __init__(self):
486: args, self.file, self.exit = self.parse_args(sys.argv)
487: hatari = Hatari(args)
488: self.tokens = Tokens(hatari)
489: self.command = CommandInput(self.tokens.get_tokens())
490:
491: def parse_args(self, args):
492: if "-h" in args or "--help" in args:
493: self.usage()
494:
495: file = []
496: exit = False
497: if "--" not in args:
498: return (args[1:], file, exit)
499:
500: for arg in args:
501: if arg == "--":
502: return (args[args.index("--")+1:], file, exit)
503: if arg == "--exit":
504: exit = True
505: continue
506: if os.path.exists(arg):
507: file = arg
508: else:
509: self.usage("file '%s' not found" % arg)
510:
511: def usage(self, msg=None):
512: name = os.path.basename(sys.argv[0])
513: print("\n%s" % name)
514: print("=" * len(name))
515: print("""
516: Usage: %s [<console options/args> --] [<hatari options>]
517:
518: Hatari console options/args:
519: \t<file>\t\tread commands from given file
520: \t--exit\t\texit after executing the commands in the file
521: \t-h, --help\t\tthis help
522:
523: Except for help, console options/args will be interpreted
524: only if '--' is given as one of the arguments. Otherwise
525: all arguments are given to Hatari.
526:
527: For example:
528: %s --monitor mono test.prg
529: %s commands.txt -- --monitor mono
530: %s commands.txt --exit --
531: """ % (name, name, name, name))
532: if msg:
533: print("ERROR: %s!\n" % msg)
534: sys.exit(1)
535:
536: def loop(self):
537: print("""
538: *********************************************************
539: * To see available commands, use the TAB key or 'usage' *
540: *********************************************************
541: """)
542: if self.file:
543: self.script(self.file)
544: if self.exit:
545: sys.exit(0)
546:
547: while 1:
548: line = self.command.loop().strip()
549: self.tokens.process_command(line)
550:
551: def script(self, filename):
552: self.tokens.do_script("script " + filename)
553:
554: def run(self, line):
555: "helper method for scripts using hatari-console"
556: self.tokens.process_command(line)
557:
558:
559: if __name__ == "__main__":
560: Main().loop()
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.