Refine code

Author: jondy

src/components/LoginDialog.vue

@@ -1,7 +1,7 @@
 <template>
   <div class="cb-user">
       <el-dialog
-        width="25%"
+        width="45%"
         :visible="dialogVisible"
         :close-on-click-modal="false"
         :before-close="handleDialogClose">

tools/cbextension.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 '''GDB Extension
-
 '''
 import gdb
 import threading
@@ -9,27 +8,27 @@
 from urllib.parse import urlencode
 
 
-CBURL = 'http://localhost:20829/api/v1/event/gdb/'
+cb_notify_url = 'http://localhost:20829/api/v1/event/gdb/'
 
 
-def post_event(runner):
-    if not lock.acquire(timeout=1.0):
+def cb_post_event(runner):
+    if not cb_lock.acquire(timeout=1.0):
         return None
     runner()
-    lock.release()
+    cb_lock.release()
 
 
-def execmd(*cmdlist):
+def cb_execmd(*cmdlist):
 
     def _runner():
         for cmd in cmdlist:
             gdb.execute(cmd)
         gdb.flush()
 
-    post_event(_runner)
+    cb_post_event(_runner)
 
 
-def prog_begin(filename, pk):
+def cb_prog_begin(pk, filename):
 
     def _runner():
         i = gdb.selected_inferior()
@@ -39,19 +38,18 @@ def _runner():
             gdb.execute('inferior %s' % n)
         gdb.execute('set remote exec-file %s' % filename)
         gdb.execute('file %s' % filename)
-        gdb.execute('start')
         gdb.flush()
+
         cb_notify_event({
-            'event': 'begin_prog',
             'pk': pk,
-            'num': i.num,
+            'inferior': i.num,
             'filename': filename
         })
 
-    post_event(_runner)
+    cb_post_event(_runner)
 
 
-def prog_end(num):
+def cb_prog_end(pk, num):
 
     def _runner():
         gdb.execute('kill inferiors %s' % num)
@@ -62,49 +60,171 @@ def _runner():
             gdb.execute('remove-inferiors %s' % num)
         gdb.flush()
 
-    post_event(_runner)
+        cb_notify_event({
+            'pk': pk,
+        })
+
+    cb_post_event(_runner)
 
 
-def prog_cmd(num, *cmdlist):
+def cb_prog_cmd_async(pk, cmd, arg='', thread='$_thread'):
+    # run / step / stepi / next / nexti / continue / until / finish &
+    cmdstr = 'thread apply %s -s %s %s &' % (thread, cmd, arg)
 
     def _runner():
-        gdb.execute('inferior %s' % num)
-        for cmd in cmdlist:
-            gdb.execute(cmd)
+        result = gdb.execute(cmdstr, False, True)
         gdb.flush()
+        cb_notify_event({
+            'pk': pk,
+            'result': result
+        })
 
-    post_event(_runner)
+    cb_post_event(_runner)
+
+
+def cb_prog_cmd(pk, cmd, arg='', thread='$_gthread', frame='0'):
+    # -stack-list-variables --thread 1 --frame 0 --all-values
+    # ^done,variables=[{name="x",value="11"},{name="s",value="{a = 1, b = 2}"}]
+
+    # -stack-list-frames --thread 1
+    # ^done,stack=
+    # [frame={level="0",addr="0x0001076c",func="foo",
+    #  file="recursive2.c",fullname="/home/foo/bar/recursive2.c",line="11",
+    #  arch="i386:x86_64"},
+    #  ...]
+
+    # -stack-list-arguments --thread 1 1
+    # ^done,
+    # stack-args=[
+    # frame={level="0",args=[]},
+    # ...]
+
+    # -thread-info
+    # -thread-list-ids
+
+    # -data-disassemble
+    # -data-evaluate-expression expr
+    # -data-list-changed-registers
+    # -data-list-register-names
+    # -data-list-register-values
+
+    # -data-read-memory
+    # -data-read-memory-bytes
+    # -data-write-memory-bytes
+
+    # -symbol-info-functions
+    # -symbol-info-module-functions
+    # -symbol-info-module-variables
+    # -symbol-info-modules
+    # -symbol-info-types
+    # -symbol-info-variables
+
+    # -exec-continue
+    # -exec-finish
+    # -exec-interrupt
+    # -exec-next
+    # -exec-next-instruction
+    # -exec-return
+    # -exec-run --start
+    # -exec-step
+    # -exec-step-instruction
+    # -exec-until
+
+    # -break-insert
+    # -break-delete
+    # -break-condition
+    # -break-list
+    # -break-info
+    # -break-disable
+    # -break-enable
+    # -break-watch
+
+    cmdstr = ' '.join(['interpreter-exec mi', '"', cmd,
+                       '--thread', thread, '--frame', frame, arg,
+                       '"']
+
+    def _runner():
+        result = gdb.execute(cmdstr, False, True)
+        gdb.flush()
+        cb_notify_event({
+            'pk': pk,
+            'result': result
+        })
+
+    cb_post_event(_runner)
+
+
+def cb_dispatch(pk, cmd, *args):
+    if cmd == 'prog_begin':
+        cb_prog_begin(pk, *args)
+    elif cmd == 'prog_end':
+        cb_prog_end(pk, *args)
+    elif cmd == 'prog_cmd':
+        cb_prog_cmd(pk, *args)
+    elif cmd == 'prog_cmd_async':
+        cb_prog_cmd_async(pk, *args)
 
 
 def cb_new_inferior_handler(event):
-    pass # event.inferior
+    event.inferior
 
 
 def cb_exited_handler(event):
-    pass # event.inferior, event.exit_code
+    event.inferior, event.exit_code
+
+
+def cb_new_thread_handler(event):
+    thread = event.inferior_thread
+    cb_notify_event({
+        'inferior': thread.inferior.num,
+        'thread': thread.num,
+        'gthread': thread.global_num,
+        'state': 'new',
+    })
 
 
 def cb_stop_handler(event):
-    pass # event.stop_signal, event.breakpoints
+    thread = event.inferior_thread
+    if hasattr(event, 'breakpoints'):
+        reason = [(bp.thread, bp.number, bp.type, bp.location)
+                  for bp in event.breakpoints]
+    elif hasattr(event, 'stop_signal'):
+        reason = event.stop_signal
+    else:
+        reason = ''
+    cb_notify_event({
+        'inferior': thread.inferior.num,
+        'thread': thread.num,
+        'gthread': thread.global_num,
+        'state': 'exited' if thread.is_exited() else 'stopped',
+        'reason': reason
+    })
 
 
 def cb_cont_handler(event):
-    pass # event.inferior_thread
+    thread = event.inferior_thread
+    cb_notify_event({
+        'inferior': thread.inferior.num,
+        'thread': thread.num,
+        'state': 'running',
+    })
 
 
 def cb_notify_event(args):
     data = urlencode(args)
-    r = urlopen(CBURL, data.encode('ascii'))
+    r = urlopen(cb_notify_url, data.encode('ascii'))
     if r.status == 200:
         return r.read().decode('utf-8')
 
 
 #
 # Hook event
 #
-gdb.events.new_inferior.connect(cb_new_inferior_handler)
-gdb.events.exited.connect(cb_exited_handler)
+# gdb.events.new_inferior.connect(cb_new_inferior_handler)
+# gdb.events.exited.connect(cb_exited_handler)
+# gdb.events.cont.connect(cb_cont_handler)
+
+gdb.events.new_thread.connect(cb_new_thread_handler)
 gdb.events.stop.connect(cb_stop_handler)
-gdb.events.cont.connect(cb_cont_handler)
 
-lock = threading.Lock()
+cb_lock = threading.Lock()