初始化提交

common/js/skulpt_mixtoy/dist/new/debugger.js

@@ -0,0 +1,312 @@
+/**
+ * Debugger support for skulpt module
+ */
+
+var Sk = Sk || {}; //jshint ignore:line
+
+function hasOwnProperty(obj, prop) {
+    var proto = obj.constructor.prototype;
+    return (prop in obj) &&
+        (!(prop in proto) || proto[prop] !== obj[prop]);
+}
+
+Sk.Breakpoint = function(filename, lineno, colno) {
+    this.filename = filename;
+    this.lineno = lineno;
+    this.colno = colno;
+    this.enabled = true;
+    this.ignore_count = 0;
+};
+
+Sk.Debugger = function(filename, output_callback) {
+    this.dbg_breakpoints = {};
+    this.tmp_breakpoints = {};
+    this.suspension_stack = [];
+    this.current_suspension = -1;
+    this.eval_callback = null;
+    this.suspension = null;
+    this.output_callback = output_callback;
+    this.step_mode = false;
+    this.filename = filename;
+};
+
+Sk.Debugger.prototype.print = function(txt) {
+    if (this.output_callback != null) {
+        this.output_callback.print(txt);
+    }
+};
+
+Sk.Debugger.prototype.get_source_line = function(lineno) {
+    if (this.output_callback != null) {
+        return this.output_callback.get_source_line(lineno);
+    }
+    
+    return "";
+};
+
+Sk.Debugger.prototype.move_up_the_stack = function() {
+    this.current_suspension = Math.min(this.current_suspension + 1, this.suspension_stack.length - 1);
+};
+
+Sk.Debugger.prototype.move_down_the_stack = function() {
+    this.current_suspension = Math.max(this.current_suspension - 1, 0);
+};
+
+Sk.Debugger.prototype.enable_step_mode = function() {
+    this.step_mode = true;
+};
+
+Sk.Debugger.prototype.disable_step_mode = function() {
+    this.step_mode = false;
+};
+
+Sk.Debugger.prototype.get_suspension_stack = function() {
+    return this.suspension_stack;
+};
+
+Sk.Debugger.prototype.get_active_suspension = function() {
+    if (this.suspension_stack.length === 0) {
+        return null;
+    }
+
+    return this.suspension_stack[this.current_suspension];
+};
+
+Sk.Debugger.prototype.generate_breakpoint_key = function(filename, lineno, colno) {
+    var key = filename + "-" + lineno;
+    return key;
+};
+
+Sk.Debugger.prototype.check_breakpoints = function(filename, lineno, colno, globals, locals) {
+    // If Step mode is enabled then ignore breakpoints since we will just break
+    // at every line.
+    if (this.step_mode === true) {
+        return true;
+    }
+    
+    var key = this.generate_breakpoint_key(filename, lineno, colno);
+    if (hasOwnProperty(this.dbg_breakpoints, key) &&
+        this.dbg_breakpoints[key].enabled === true) {
+        var bp = null;
+        if (hasOwnProperty(this.tmp_breakpoints, key)) {
+            delete this.dbg_breakpoints[key];
+            delete this.tmp_breakpoints[key];
+            return true;
+        }
+        
+        this.dbg_breakpoints[key].ignore_count -= 1;
+        this.dbg_breakpoints[key].ignore_count = Math.max(0, this.dbg_breakpoints[key].ignore_count);
+        
+        bp = this.dbg_breakpoints[key];
+        if (bp.ignore_count === 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    return false;
+};
+
+Sk.Debugger.prototype.get_breakpoints_list = function() {
+    return this.dbg_breakpoints;
+};
+
+Sk.Debugger.prototype.disable_breakpoint = function(filename, lineno, colno) {
+    var key = this.generate_breakpoint_key(filename, lineno, colno);
+    
+    if (hasOwnProperty(this.dbg_breakpoints, key)) {
+        this.dbg_breakpoints[key].enabled = false;
+    }
+};
+
+Sk.Debugger.prototype.enable_breakpoint = function(filename, lineno, colno) {
+    var key = this.generate_breakpoint_key(filename, lineno, colno);
+    
+    if (hasOwnProperty(this.dbg_breakpoints, key)) {
+        this.dbg_breakpoints[key].enabled = true;
+    }
+};
+
+Sk.Debugger.prototype.clear_breakpoint = function(filename, lineno, colno) {
+    var key = this.generate_breakpoint_key(filename, lineno, colno);
+    if (hasOwnProperty(this.dbg_breakpoints, key)) {
+        delete this.dbg_breakpoints[key];
+        return null;
+    } else {
+        return "Invalid breakpoint specified: " + filename + " line: " + lineno;
+    }
+};
+
+Sk.Debugger.prototype.clear_all_breakpoints = function() {
+    this.dbg_breakpoints = {};
+    this.tmp_breakpoints = {};
+};
+
+Sk.Debugger.prototype.set_ignore_count = function(filename, lineno, colno, count) {
+    var key = this.generate_breakpoint_key(filename, lineno, colno);
+    if (hasOwnProperty(this.dbg_breakpoints, key)) {
+        var bp = this.dbg_breakpoints[key];
+        bp.ignore_count = count;
+    }
+};
+
+Sk.Debugger.prototype.set_condition = function(filename, lineno, colno, lhs, cond, rhs) {
+    var key = this.generate_breakpoint_key(filename, lineno, colno);
+    var bp;
+    if (hasOwnProperty(this.dbg_breakpoints, key)) {
+        // Set a new condition
+        bp = this.dbg_breakpoints[key];
+    } else {
+        bp = new Sk.Breakpoint(filename, lineno, colno);
+    }
+    
+    bp.condition = new Sk.Condition(lhs, cond, rhs);
+    this.dbg_breakpoints[key] = bp;
+};
+
+Sk.Debugger.prototype.print_suspension_info = function(suspension) {
+    var filename = suspension.filename;
+    var lineno = suspension.lineno;
+    var colno = suspension.colno;
+    this.print("Hit Breakpoint at <" + filename + "> at line: " + lineno + " column: " + colno + "\n");
+    this.print("----------------------------------------------------------------------------------\n");
+    this.print(" ==> " + this.get_source_line(lineno - 1) + "\n");
+    this.print("----------------------------------------------------------------------------------\n");
+};
+
+Sk.Debugger.prototype.set_suspension = function(suspension) {
+    var parent = null;
+    if (!hasOwnProperty(suspension, "filename") && suspension.child instanceof Sk.misceval.Suspension) {
+        suspension = suspension.child;
+    }
+        
+    // Pop the last suspension of the stack if there is more than 0
+    if (this.suspension_stack.length > 0) {
+        this.suspension_stack.pop();
+        this.current_suspension -= 1;
+    }
+    
+    // Unroll the stack to get each suspension.
+    while (suspension instanceof Sk.misceval.Suspension) {
+        parent = suspension;
+        this.suspension_stack.push(parent);
+        this.current_suspension += 1;
+        suspension = suspension.child;
+    }
+
+    suspension = parent;
+    
+    this.print_suspension_info(suspension);
+};
+
+Sk.Debugger.prototype.add_breakpoint = function(filename, lineno, colno, temporary) {
+    var key = this.generate_breakpoint_key(filename, lineno, colno);
+    this.dbg_breakpoints[key] = new Sk.Breakpoint(filename, lineno, colno);
+    if (temporary) {
+        this.tmp_breakpoints[key] = true;
+    }
+};
+
+Sk.Debugger.prototype.suspension_handler = function(susp) {
+    return new Promise(function(resolve, reject) {
+        try {
+            resolve(susp.resume());
+        } catch(e) {
+            reject(e);
+        }
+    });
+};
+
+Sk.Debugger.prototype.resume = function() {
+    // Reset the suspension stack to the topmost
+    this.current_suspension = this.suspension_stack.length - 1;
+    
+    if (this.suspension_stack.length === 0) {
+        this.print("No running program");
+    } else {
+        var promise = this.suspension_handler(this.get_active_suspension());
+        promise.then(this.success.bind(this), this.error.bind(this));
+    }
+};
+
+Sk.Debugger.prototype.pop_suspension_stack = function() {
+    this.suspension_stack.pop();
+    this.current_suspension -= 1;
+};
+
+Sk.Debugger.prototype.success = function(r) {
+    if (r instanceof Sk.misceval.Suspension) {
+        this.set_suspension(r);
+    } else {
+        if (this.suspension_stack.length > 0) {
+            // Current suspension needs to be popped of the stack
+            this.pop_suspension_stack();
+            
+            if (this.suspension_stack.length === 0) {
+                this.print("Program execution complete");
+                return;
+            }
+            
+            var parent_suspension = this.get_active_suspension();
+            // The child has completed the execution. So override the child's resume
+            // so we can continue the execution.
+            parent_suspension.child.resume = function() {
+                return r;
+            };
+            this.resume();
+        } else {
+            this.print("Program execution complete");
+        }
+    }
+};
+
+Sk.Debugger.prototype.error = function(e) {
+    this.print("Traceback (most recent call last):");
+    for (var idx = 0; idx < e.traceback.length; ++idx) {
+        this.print("  File \"" + e.traceback[idx].filename + "\", line " + e.traceback[idx].lineno + ", in <module>");
+        var code = this.get_source_line(e.traceback[idx].lineno - 1);
+        code = code.trim();
+        code = "    " + code;
+        this.print(code);
+    }
+    
+    var err_ty = e.constructor.tp$name;
+    for (idx = 0; idx < e.args.v.length; ++idx) {
+        this.print(err_ty + ": " + e.args.v[idx].v);
+    }
+};
+
+Sk.Debugger.prototype.asyncToPromise = function(suspendablefn, suspHandlers, debugger_obj) {
+    return new Promise(function(resolve, reject) {
+        try {
+            var r = suspendablefn();
+
+            (function handleResponse (r) {
+                try {
+                    while (r instanceof Sk.misceval.Suspension) {
+                        debugger_obj.set_suspension(r);
+                        return;
+                    }
+
+                    resolve(r);
+                } catch(e) {
+                    reject(e);
+                }
+            })(r);
+
+        } catch (e) {
+            reject(e);
+        }
+    });
+};
+
+Sk.Debugger.prototype.execute = function(suspendablefn, suspHandlers) {
+    var r = suspendablefn();
+    
+    if (r instanceof Sk.misceval.Suspension) {
+        this.suspensions.concat(r);
+        this.eval_callback(r);
+    }
+};
+
+goog.exportSymbol("Sk.Debugger", Sk.Debugger);