Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/DebugClientBase.py

DebugClients/Python3/DebugClientBase.py

changeset 1112
8a7d1b9d18db
parent 1029
0fb3d1d26eab
child 1179
7661ab683f7b
equal deleted inserted replaced
1109:9552b5e16a07 1112:8a7d1b9d18db
16 import time 16 import time
17 import imp 17 import imp
18 import re 18 import re
19 19
20 20
21 from DebugProtocol import * 21 import DebugProtocol
22 import DebugClientCapabilities 22 import DebugClientCapabilities
23 from DebugBase import setRecursionLimit, printerr # __IGNORE_WARNING__ 23 from DebugBase import setRecursionLimit, printerr # __IGNORE_WARNING__
24 from AsyncFile import * 24 from AsyncFile import AsyncFile, AsyncPendingWrite
25 from DebugConfig import ConfigVarTypeStrings 25 from DebugConfig import ConfigVarTypeStrings
26 from FlexCompleter import Completer 26 from FlexCompleter import Completer
27 27
28 28
29 DebugClientInstance = None 29 DebugClientInstance = None
178 178
179 # The list of regexp objects to filter variables against 179 # The list of regexp objects to filter variables against
180 self.globalsFilterObjects = [] 180 self.globalsFilterObjects = []
181 self.localsFilterObjects = [] 181 self.localsFilterObjects = []
182 182
183 self.pendingResponse = ResponseOK 183 self.pendingResponse = DebugProtocol.ResponseOK
184 self.fncache = {} 184 self.fncache = {}
185 self.dircache = [] 185 self.dircache = []
186 self.inRawMode = False 186 self.inRawMode = False
187 self.mainProcStr = None # used for the passive mode 187 self.mainProcStr = None # used for the passive mode
188 self.passive = False # used to indicate the passive mode 188 self.passive = False # used to indicate the passive mode
284 d["id"] = -1 284 d["id"] = -1
285 d["name"] = "MainThread" 285 d["name"] = "MainThread"
286 d["broken"] = self.isBroken() 286 d["broken"] = self.isBroken()
287 threadList.append(d) 287 threadList.append(d)
288 288
289 self.write("{0}{1!r}\n".format(ResponseThreadList, (currentId, threadList))) 289 self.write("{0}{1!r}\n".format(DebugProtocol.ResponseThreadList,
290 (currentId, threadList)))
290 291
291 def input(self, prompt, echo=True): 292 def input(self, prompt, echo=True):
292 """ 293 """
293 Public method to implement input() using the event loop. 294 Public method to implement input() using the event loop.
294 295
295 @param prompt the prompt to be shown (string) 296 @param prompt the prompt to be shown (string)
296 @param echo Flag indicating echoing of the input (boolean) 297 @param echo Flag indicating echoing of the input (boolean)
297 @return the entered string 298 @return the entered string
298 """ 299 """
299 self.write("{0}{1!r}\n".format(ResponseRaw, (prompt, echo))) 300 self.write("{0}{1!r}\n".format(DebugProtocol.ResponseRaw, (prompt, echo)))
300 self.inRawMode = True 301 self.inRawMode = True
301 self.eventLoop(True) 302 self.eventLoop(True)
302 return self.rawLine 303 return self.rawLine
303 304
304 def __exceptionRaised(self): 305 def __exceptionRaised(self):
305 """ 306 """
306 Private method called in the case of an exception 307 Private method called in the case of an exception
307 308
308 It ensures that the debug server is informed of the raised exception. 309 It ensures that the debug server is informed of the raised exception.
309 """ 310 """
310 self.pendingResponse = ResponseException 311 self.pendingResponse = DebugProtocol.ResponseException
311 312
312 def sessionClose(self, exit=True): 313 def sessionClose(self, exit=True):
313 """ 314 """
314 Public method to close the session with the debugger and optionally terminate. 315 Public method to close the session with the debugger and optionally terminate.
315 316
355 except ValueError: 356 except ValueError:
356 exclist = [] 357 exclist = []
357 else: 358 else:
358 exclist = [message, [filename, linenr, charnr]] 359 exclist = [message, [filename, linenr, charnr]]
359 360
360 self.write("{0}{1}\n".format(ResponseSyntax, str(exclist))) 361 self.write("{0}{1}\n".format(DebugProtocol.ResponseSyntax, str(exclist)))
361 return None 362 return None
362 363
363 return code 364 return code
364 365
365 def handleLine(self, line): 366 def handleLine(self, line):
382 if eoc >= 0 and line[0] == '>': 383 if eoc >= 0 and line[0] == '>':
383 # Get the command part and any argument. 384 # Get the command part and any argument.
384 cmd = line[:eoc + 1] 385 cmd = line[:eoc + 1]
385 arg = line[eoc + 1:] 386 arg = line[eoc + 1:]
386 387
387 if cmd == RequestVariables: 388 if cmd == DebugProtocol.RequestVariables:
388 frmnr, scope, filter = eval(arg.replace("u'", "'")) 389 frmnr, scope, filter = eval(arg.replace("u'", "'"))
389 self.__dumpVariables(int(frmnr), int(scope), filter) 390 self.__dumpVariables(int(frmnr), int(scope), filter)
390 return 391 return
391 392
392 if cmd == RequestVariable: 393 if cmd == DebugProtocol.RequestVariable:
393 var, frmnr, scope, filter = eval(arg.replace("u'", "'")) 394 var, frmnr, scope, filter = eval(arg.replace("u'", "'"))
394 self.__dumpVariable(var, int(frmnr), int(scope), filter) 395 self.__dumpVariable(var, int(frmnr), int(scope), filter)
395 return 396 return
396 397
397 if cmd == RequestThreadList: 398 if cmd == DebugProtocol.RequestThreadList:
398 self.__dumpThreadList() 399 self.__dumpThreadList()
399 return 400 return
400 401
401 if cmd == RequestThreadSet: 402 if cmd == DebugProtocol.RequestThreadSet:
402 tid = eval(arg) 403 tid = eval(arg)
403 if tid in self.threads: 404 if tid in self.threads:
404 self.setCurrentThread(tid) 405 self.setCurrentThread(tid)
405 self.write(ResponseThreadSet + '\n') 406 self.write(DebugProtocol.ResponseThreadSet + '\n')
406 stack = self.currentThread.getStack() 407 stack = self.currentThread.getStack()
407 self.write('{0}{1!r}\n'.format(ResponseStack, stack)) 408 self.write('{0}{1!r}\n'.format(DebugProtocol.ResponseStack, stack))
408 return 409 return
409 410
410 if cmd == RequestStep: 411 if cmd == DebugProtocol.RequestStep:
411 self.currentThread.step(True) 412 self.currentThread.step(True)
412 self.eventExit = True 413 self.eventExit = True
413 return 414 return
414 415
415 if cmd == RequestStepOver: 416 if cmd == DebugProtocol.RequestStepOver:
416 self.currentThread.step(False) 417 self.currentThread.step(False)
417 self.eventExit = True 418 self.eventExit = True
418 return 419 return
419 420
420 if cmd == RequestStepOut: 421 if cmd == DebugProtocol.RequestStepOut:
421 self.currentThread.stepOut() 422 self.currentThread.stepOut()
422 self.eventExit = True 423 self.eventExit = True
423 return 424 return
424 425
425 if cmd == RequestStepQuit: 426 if cmd == DebugProtocol.RequestStepQuit:
426 if self.passive: 427 if self.passive:
427 self.progTerminated(42) 428 self.progTerminated(42)
428 else: 429 else:
429 self.set_quit() 430 self.set_quit()
430 self.eventExit = True 431 self.eventExit = True
431 return 432 return
432 433
433 if cmd == RequestContinue: 434 if cmd == DebugProtocol.RequestContinue:
434 special = int(arg) 435 special = int(arg)
435 self.currentThread.go(special) 436 self.currentThread.go(special)
436 self.eventExit = True 437 self.eventExit = True
437 return 438 return
438 439
439 if cmd == RequestOK: 440 if cmd == DebugProtocol.RequestOK:
440 self.write(self.pendingResponse + '\n') 441 self.write(self.pendingResponse + '\n')
441 self.pendingResponse = ResponseOK 442 self.pendingResponse = DebugProtocol.ResponseOK
442 return 443 return
443 444
444 if cmd == RequestEnv: 445 if cmd == DebugProtocol.RequestEnv:
445 env = eval(arg.replace("u'", "'")) 446 env = eval(arg.replace("u'", "'"))
446 for key, value in env.items(): 447 for key, value in env.items():
447 if key.endswith("+"): 448 if key.endswith("+"):
448 if key[:-1] in os.environ: 449 if key[:-1] in os.environ:
449 os.environ[key[:-1]] += value 450 os.environ[key[:-1]] += value
451 os.environ[key[:-1]] = value 452 os.environ[key[:-1]] = value
452 else: 453 else:
453 os.environ[key] = value 454 os.environ[key] = value
454 return 455 return
455 456
456 if cmd == RequestLoad: 457 if cmd == DebugProtocol.RequestLoad:
457 self.fncache = {} 458 self.fncache = {}
458 self.dircache = [] 459 self.dircache = []
459 sys.argv = [] 460 sys.argv = []
460 wd, fn, args, tracePython = arg.split('|') 461 wd, fn, args, tracePython = arg.split('|')
461 self.__setCoding(fn) 462 self.__setCoding(fn)
495 if code: 496 if code:
496 res = self.mainThread.run(code, self.debugMod.__dict__) 497 res = self.mainThread.run(code, self.debugMod.__dict__)
497 self.progTerminated(res) 498 self.progTerminated(res)
498 return 499 return
499 500
500 if cmd == RequestRun: 501 if cmd == DebugProtocol.RequestRun:
501 sys.argv = [] 502 sys.argv = []
502 wd, fn, args = arg.split('|') 503 wd, fn, args = arg.split('|')
503 self.__setCoding(fn) 504 self.__setCoding(fn)
504 sys.argv.append(fn) 505 sys.argv.append(fn)
505 sys.argv.extend(eval(args.replace("u'", "'"))) 506 sys.argv.extend(eval(args.replace("u'", "'")))
528 exec(open(sys.argv[0], encoding=self.__coding).read(), 529 exec(open(sys.argv[0], encoding=self.__coding).read(),
529 self.debugMod.__dict__) 530 self.debugMod.__dict__)
530 self.writestream.flush() 531 self.writestream.flush()
531 return 532 return
532 533
533 if cmd == RequestProfile: 534 if cmd == DebugProtocol.RequestProfile:
534 sys.setprofile(None) 535 sys.setprofile(None)
535 import PyProfile 536 import PyProfile
536 sys.argv = [] 537 sys.argv = []
537 wd, fn, args, erase = arg.split('|') 538 wd, fn, args, erase = arg.split('|')
538 self.__setCoding(fn) 539 self.__setCoding(fn)
564 self.prof.run("exec({0!r}\n)".format(script)) 565 self.prof.run("exec({0!r}\n)".format(script))
565 self.prof.save() 566 self.prof.save()
566 self.writestream.flush() 567 self.writestream.flush()
567 return 568 return
568 569
569 if cmd == RequestCoverage: 570 if cmd == DebugProtocol.RequestCoverage:
570 from coverage import coverage 571 from coverage import coverage
571 sys.argv = [] 572 sys.argv = []
572 wd, fn, args, erase = arg.split('@@') 573 wd, fn, args, erase = arg.split('@@')
573 self.__setCoding(fn) 574 self.__setCoding(fn)
574 sys.argv.append(fn) 575 sys.argv.append(fn)
598 self.cover.stop() 599 self.cover.stop()
599 self.cover.save() 600 self.cover.save()
600 self.writestream.flush() 601 self.writestream.flush()
601 return 602 return
602 603
603 if cmd == RequestShutdown: 604 if cmd == DebugProtocol.RequestShutdown:
604 self.sessionClose() 605 self.sessionClose()
605 return 606 return
606 607
607 if cmd == RequestBreak: 608 if cmd == DebugProtocol.RequestBreak:
608 fn, line, temporary, set, cond = arg.split('@@') 609 fn, line, temporary, set, cond = arg.split('@@')
609 line = int(line) 610 line = int(line)
610 set = int(set) 611 set = int(set)
611 temporary = int(temporary) 612 temporary = int(temporary)
612 613
616 else: 617 else:
617 try: 618 try:
618 compile(cond, '<string>', 'eval') 619 compile(cond, '<string>', 'eval')
619 except SyntaxError: 620 except SyntaxError:
620 self.write('{0}{1},{2:d}\n'.format( 621 self.write('{0}{1},{2:d}\n'.format(
621 ResponseBPConditionError, fn, line)) 622 DebugProtocol.ResponseBPConditionError, fn, line))
622 return 623 return
623 self.mainThread.set_break(fn, line, temporary, cond) 624 self.mainThread.set_break(fn, line, temporary, cond)
624 else: 625 else:
625 self.mainThread.clear_break(fn, line) 626 self.mainThread.clear_break(fn, line)
626 627
627 return 628 return
628 629
629 if cmd == RequestBreakEnable: 630 if cmd == DebugProtocol.RequestBreakEnable:
630 fn, line, enable = arg.split(',') 631 fn, line, enable = arg.split(',')
631 line = int(line) 632 line = int(line)
632 enable = int(enable) 633 enable = int(enable)
633 634
634 bp = self.mainThread.get_break(fn, line) 635 bp = self.mainThread.get_break(fn, line)
638 else: 639 else:
639 bp.disable() 640 bp.disable()
640 641
641 return 642 return
642 643
643 if cmd == RequestBreakIgnore: 644 if cmd == DebugProtocol.RequestBreakIgnore:
644 fn, line, count = arg.split(',') 645 fn, line, count = arg.split(',')
645 line = int(line) 646 line = int(line)
646 count = int(count) 647 count = int(count)
647 648
648 bp = self.mainThread.get_break(fn, line) 649 bp = self.mainThread.get_break(fn, line)
649 if bp is not None: 650 if bp is not None:
650 bp.ignore = count 651 bp.ignore = count
651 652
652 return 653 return
653 654
654 if cmd == RequestWatch: 655 if cmd == DebugProtocol.RequestWatch:
655 cond, temporary, set = arg.split('@@') 656 cond, temporary, set = arg.split('@@')
656 set = int(set) 657 set = int(set)
657 temporary = int(temporary) 658 temporary = int(temporary)
658 659
659 if set: 660 if set:
660 if not cond.endswith('??created??') and \ 661 if not cond.endswith('??created??') and \
661 not cond.endswith('??changed??'): 662 not cond.endswith('??changed??'):
662 try: 663 try:
663 compile(cond, '<string>', 'eval') 664 compile(cond, '<string>', 'eval')
664 except SyntaxError: 665 except SyntaxError:
665 self.write('{0}{1}\n'.format(ResponseWPConditionError, cond)) 666 self.write('{0}{1}\n'.format(
667 DebugProtocol.ResponseWPConditionError, cond))
666 return 668 return
667 self.mainThread.set_watch(cond, temporary) 669 self.mainThread.set_watch(cond, temporary)
668 else: 670 else:
669 self.mainThread.clear_watch(cond) 671 self.mainThread.clear_watch(cond)
670 672
671 return 673 return
672 674
673 if cmd == RequestWatchEnable: 675 if cmd == DebugProtocol.RequestWatchEnable:
674 cond, enable = arg.split(',') 676 cond, enable = arg.split(',')
675 enable = int(enable) 677 enable = int(enable)
676 678
677 bp = self.mainThread.get_watch(cond) 679 bp = self.mainThread.get_watch(cond)
678 if bp is not None: 680 if bp is not None:
681 else: 683 else:
682 bp.disable() 684 bp.disable()
683 685
684 return 686 return
685 687
686 if cmd == RequestWatchIgnore: 688 if cmd == DebugProtocol.RequestWatchIgnore:
687 cond, count = arg.split(',') 689 cond, count = arg.split(',')
688 count = int(count) 690 count = int(count)
689 691
690 bp = self.mainThread.get_watch(cond) 692 bp = self.mainThread.get_watch(cond)
691 if bp is not None: 693 if bp is not None:
692 bp.ignore = count 694 bp.ignore = count
693 695
694 return 696 return
695 697
696 if cmd == RequestEval: 698 if cmd == DebugProtocol.RequestEval:
697 try: 699 try:
698 value = eval(arg, self.currentThread.getCurrentFrame().f_globals, 700 value = eval(arg, self.currentThread.getCurrentFrame().f_globals,
699 self.currentThread.getCurrentFrameLocals()) 701 self.currentThread.getCurrentFrameLocals())
700 except: 702 except:
701 # Report the exception and the traceback 703 # Report the exception and the traceback
715 tblist = tb = None 717 tblist = tb = None
716 718
717 for l in list: 719 for l in list:
718 self.write(l) 720 self.write(l)
719 721
720 self.write(ResponseException + '\n') 722 self.write(DebugProtocol.ResponseException + '\n')
721 723
722 else: 724 else:
723 self.write(str(value) + '\n') 725 self.write(str(value) + '\n')
724 self.write(ResponseOK + '\n') 726 self.write(DebugProtocol.ResponseOK + '\n')
725 727
726 return 728 return
727 729
728 if cmd == RequestExec: 730 if cmd == DebugProtocol.RequestExec:
729 _globals = self.currentThread.getCurrentFrame().f_globals 731 _globals = self.currentThread.getCurrentFrame().f_globals
730 _locals = self.currentThread.getCurrentFrameLocals() 732 _locals = self.currentThread.getCurrentFrameLocals()
731 try: 733 try:
732 code = compile(arg + '\n', '<stdin>', 'single') 734 code = compile(arg + '\n', '<stdin>', 'single')
733 exec(code, _globals, _locals) 735 exec(code, _globals, _locals)
749 tblist = tb = None 751 tblist = tb = None
750 752
751 for l in list: 753 for l in list:
752 self.write(l) 754 self.write(l)
753 755
754 self.write(ResponseException + '\n') 756 self.write(DebugProtocol.ResponseException + '\n')
755 757
756 return 758 return
757 759
758 if cmd == RequestBanner: 760 if cmd == DebugProtocol.RequestBanner:
759 self.write('{0}{1}\n'.format(ResponseBanner, 761 self.write('{0}{1}\n'.format(DebugProtocol.ResponseBanner,
760 str(("Python {0}".format(sys.version), 762 str(("Python {0}".format(sys.version),
761 socket.gethostname(), self.variant)))) 763 socket.gethostname(), self.variant))))
762 return 764 return
763 765
764 if cmd == RequestCapabilities: 766 if cmd == DebugProtocol.RequestCapabilities:
765 self.write('{0}{1:d}, "Python3"\n'.format(ResponseCapabilities, 767 self.write('{0}{1:d}, "Python3"\n'.format(
768 DebugProtocol.ResponseCapabilities,
766 self.__clientCapabilities())) 769 self.__clientCapabilities()))
767 return 770 return
768 771
769 if cmd == RequestCompletion: 772 if cmd == DebugProtocol.RequestCompletion:
770 self.__completionList(arg.replace("u'", "'")) 773 self.__completionList(arg.replace("u'", "'"))
771 return 774 return
772 775
773 if cmd == RequestSetFilter: 776 if cmd == DebugProtocol.RequestSetFilter:
774 scope, filterString = eval(arg.replace("u'", "'")) 777 scope, filterString = eval(arg.replace("u'", "'"))
775 self.__generateFilterObjects(int(scope), filterString) 778 self.__generateFilterObjects(int(scope), filterString)
776 return 779 return
777 780
778 if cmd == RequestUTPrepare: 781 if cmd == DebugProtocol.RequestUTPrepare:
779 fn, tn, tfn, cov, covname, erase = arg.split('|') 782 fn, tn, tfn, cov, covname, erase = arg.split('|')
780 sys.path.insert(0, os.path.dirname(os.path.abspath(fn))) 783 sys.path.insert(0, os.path.dirname(os.path.abspath(fn)))
781 os.chdir(sys.path[0]) 784 os.chdir(sys.path[0])
782 785
783 # set the system exception handling function to ensure, that 786 # set the system exception handling function to ensure, that
793 except AttributeError: 796 except AttributeError:
794 self.test = unittest.defaultTestLoader\ 797 self.test = unittest.defaultTestLoader\
795 .loadTestsFromModule(utModule) 798 .loadTestsFromModule(utModule)
796 except: 799 except:
797 exc_type, exc_value, exc_tb = sys.exc_info() 800 exc_type, exc_value, exc_tb = sys.exc_info()
798 self.write('{0}{1}\n'.format(ResponseUTPrepared, 801 self.write('{0}{1}\n'.format(DebugProtocol.ResponseUTPrepared,
799 str((0, str(exc_type), str(exc_value))))) 802 str((0, str(exc_type), str(exc_value)))))
800 self.__exceptionRaised() 803 self.__exceptionRaised()
801 return 804 return
802 805
803 # generate a coverage object 806 # generate a coverage object
809 if int(erase): 812 if int(erase):
810 self.cover.erase() 813 self.cover.erase()
811 else: 814 else:
812 self.cover = None 815 self.cover = None
813 816
814 self.write('{0}{1}\n'.format(ResponseUTPrepared, 817 self.write('{0}{1}\n'.format(DebugProtocol.ResponseUTPrepared,
815 str((self.test.countTestCases(), "", "")))) 818 str((self.test.countTestCases(), "", ""))))
816 return 819 return
817 820
818 if cmd == RequestUTRun: 821 if cmd == DebugProtocol.RequestUTRun:
819 from DCTestResult import DCTestResult 822 from DCTestResult import DCTestResult
820 self.testResult = DCTestResult(self) 823 self.testResult = DCTestResult(self)
821 if self.cover: 824 if self.cover:
822 self.cover.start() 825 self.cover.start()
823 self.test.run(self.testResult) 826 self.test.run(self.testResult)
824 if self.cover: 827 if self.cover:
825 self.cover.stop() 828 self.cover.stop()
826 self.cover.save() 829 self.cover.save()
827 self.write('{0}\n'.format(ResponseUTFinished)) 830 self.write('{0}\n'.format(DebugProtocol.ResponseUTFinished))
828 return 831 return
829 832
830 if cmd == RequestUTStop: 833 if cmd == DebugProtocol.RequestUTStop:
831 self.testResult.stop() 834 self.testResult.stop()
832 return 835 return
833 836
834 if cmd == ResponseForkTo: 837 if cmd == DebugProtocol.ResponseForkTo:
835 # this results from a separate event loop 838 # this results from a separate event loop
836 self.fork_child = (arg == 'child') 839 self.fork_child = (arg == 'child')
837 self.eventExit = True 840 self.eventExit = True
838 return 841 return
839 842
840 if cmd == RequestForkMode: 843 if cmd == DebugProtocol.RequestForkMode:
841 self.fork_auto, self.fork_child = eval(arg) 844 self.fork_auto, self.fork_child = eval(arg)
842 return 845 return
843 846
844 # If we are handling raw mode input then reset the mode and break out 847 # If we are handling raw mode input then reset the mode and break out
845 # of the current event loop. 848 # of the current event loop.
864 self.buffer = '' 867 self.buffer = ''
865 868
866 self.__exceptionRaised() 869 self.__exceptionRaised()
867 else: 870 else:
868 if code is None: 871 if code is None:
869 self.pendingResponse = ResponseContinue 872 self.pendingResponse = DebugProtocol.ResponseContinue
870 else: 873 else:
871 self.buffer = '' 874 self.buffer = ''
872 875
873 try: 876 try:
874 if self.running is None: 877 if self.running is None:
1055 @param remoteAddress the network address of the debug server host (string) 1058 @param remoteAddress the network address of the debug server host (string)
1056 @param redirect flag indicating redirection of stdin, stdout and stderr (boolean) 1059 @param redirect flag indicating redirection of stdin, stdout and stderr (boolean)
1057 """ 1060 """
1058 if remoteAddress is None: # default: 127.0.0.1 1061 if remoteAddress is None: # default: 127.0.0.1
1059 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 1062 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1060 sock.connect((DebugAddress, port)) 1063 sock.connect((DebugProtocol.DebugAddress, port))
1061 elif ":" in remoteAddress: # IPv6 1064 elif ":" in remoteAddress: # IPv6
1062 sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) 1065 sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
1063 sock.connect((remoteAddress, port)) 1066 sock.connect((remoteAddress, port))
1064 else: # IPv4 1067 else: # IPv4
1065 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 1068 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1168 status = 1 1171 status = 1
1169 1172
1170 if self.running: 1173 if self.running:
1171 self.set_quit() 1174 self.set_quit()
1172 self.running = None 1175 self.running = None
1173 self.write('{0}{1:d}\n'.format(ResponseExit, status)) 1176 self.write('{0}{1:d}\n'.format(DebugProtocol.ResponseExit, status))
1174 1177
1175 # reset coding 1178 # reset coding
1176 self.__coding = self.defaultCoding 1179 self.__coding = self.defaultCoding
1177 1180
1178 def __dumpVariables(self, frmnr, scope, filter): 1181 def __dumpVariables(self, frmnr, scope, filter):
1209 keylist = dict.keys() 1212 keylist = dict.keys()
1210 1213
1211 vlist = self.__formatVariablesList(keylist, dict, scope, filter) 1214 vlist = self.__formatVariablesList(keylist, dict, scope, filter)
1212 varlist.extend(vlist) 1215 varlist.extend(vlist)
1213 1216
1214 self.write('{0}{1}\n'.format(ResponseVariables, str(varlist))) 1217 self.write('{0}{1}\n'.format(DebugProtocol.ResponseVariables, str(varlist)))
1215 1218
1216 def __dumpVariable(self, var, frmnr, scope, filter): 1219 def __dumpVariable(self, var, frmnr, scope, filter):
1217 """ 1220 """
1218 Private method to return the variables of a frame to the debug server. 1221 Private method to return the variables of a frame to the debug server.
1219 1222
1413 elif repr(obj).startswith('['): 1416 elif repr(obj).startswith('['):
1414 varlist.append(('...', 'list', "{0:d}".format(len(obj)))) 1417 varlist.append(('...', 'list', "{0:d}".format(len(obj))))
1415 elif repr(obj).startswith('('): 1418 elif repr(obj).startswith('('):
1416 varlist.append(('...', 'tuple', "{0:d}".format(len(obj)))) 1419 varlist.append(('...', 'tuple', "{0:d}".format(len(obj))))
1417 1420
1418 self.write('{0}{1}\n'.format(ResponseVariable, str(varlist))) 1421 self.write('{0}{1}\n'.format(DebugProtocol.ResponseVariable, str(varlist)))
1419 1422
1420 def __formatQt4Variable(self, value, vtype): 1423 def __formatQt4Variable(self, value, vtype):
1421 """ 1424 """
1422 Private method to produce a formatted output of a simple Qt4 type. 1425 Private method to produce a formatted output of a simple Qt4 type.
1423 1426
1678 try: 1681 try:
1679 comp = self.complete(text, state) 1682 comp = self.complete(text, state)
1680 except: 1683 except:
1681 comp = None 1684 comp = None
1682 1685
1683 self.write("{0}{1}||{2}\n".format(ResponseCompletion, str(completions), text)) 1686 self.write("{0}{1}||{2}\n".format(DebugProtocol.ResponseCompletion,
1687 str(completions), text))
1684 1688
1685 def startDebugger(self, filename=None, host=None, port=None, 1689 def startDebugger(self, filename=None, host=None, port=None,
1686 enableTrace=True, exceptions=True, tracePython=False, redirect=True): 1690 enableTrace=True, exceptions=True, tracePython=False, redirect=True):
1687 """ 1691 """
1688 Public method used to start the remote debugger. 1692 Public method used to start the remote debugger.
1711 except IndexError: 1715 except IndexError:
1712 self.running = None 1716 self.running = None
1713 if self.running: 1717 if self.running:
1714 self.__setCoding(self.running) 1718 self.__setCoding(self.running)
1715 self.passive = True 1719 self.passive = True
1716 self.write("{0}{1}|{2:d}\n".format(PassiveStartup, self.running, exceptions)) 1720 self.write("{0}{1}|{2:d}\n".format(DebugProtocol.PassiveStartup,
1721 self.running, exceptions))
1717 self.__interact() 1722 self.__interact()
1718 1723
1719 # setup the debugger variables 1724 # setup the debugger variables
1720 self.fncache = {} 1725 self.fncache = {}
1721 self.dircache = [] 1726 self.dircache = []
1770 self.mainFrame = None 1775 self.mainFrame = None
1771 self.inRawMode = False 1776 self.inRawMode = False
1772 self.debugging = True 1777 self.debugging = True
1773 1778
1774 self.passive = True 1779 self.passive = True
1775 self.write("{0}{1}|{2:d}\n".format(PassiveStartup, self.running, exceptions)) 1780 self.write("{0}{1}|{2:d}\n".format(
1781 DebugProtocol.PassiveStartup, self.running, exceptions))
1776 self.__interact() 1782 self.__interact()
1777 1783
1778 self.attachThread(mainThread=True) 1784 self.attachThread(mainThread=True)
1779 self.mainThread.tracePython = tracePython 1785 self.mainThread.tracePython = tracePython
1780 1786
1921 def fork(self): 1927 def fork(self):
1922 """ 1928 """
1923 Public method implementing a fork routine deciding which branch to follow. 1929 Public method implementing a fork routine deciding which branch to follow.
1924 """ 1930 """
1925 if not self.fork_auto: 1931 if not self.fork_auto:
1926 self.write(RequestForkTo + '\n') 1932 self.write(DebugProtocol.RequestForkTo + '\n')
1927 self.eventLoop(True) 1933 self.eventLoop(True)
1928 pid = DebugClientOrigFork() 1934 pid = DebugClientOrigFork()
1929 if pid == 0: 1935 if pid == 0:
1930 # child 1936 # child
1931 if not self.fork_child: 1937 if not self.fork_child:

Mercurial Repository: eric

eric ide

mercurial