q(uit)\nexit
        Quit from the debugger. The program being executed is aborted.
422309
def do_quit(self, arg):
        
        if isinstance(self.stdin, RemoteSocket) and not self.is_debug_instance:
            return self.do_detach(arg)
        self._user_requested_quit = True
        self.set_quit()
        return 1
314723
static void exitWithError(Boolean isDebug, Exception e) {
        System.err.println("Error executing function (Use -x for more information): " + e.getMessage());
        if (isDebug) {
            System.err.println();
            System.err.println("Error Detail");
            System.err.println("------------");
            e.printStackTrace(System.err);
        }
        System.exit(1);
    }
1146374
private Status executeDebug(Stmt.Debug stmt, CallStack frame, EnclosingScope scope) {
		//
		// FIXME: need to do something with this
		RValue.Array arr = executeExpression(ARRAY_T, stmt.getOperand(), frame);
		for (RValue item : arr.getElements()) {
			RValue.Int i = (RValue.Int) item;
			char c = (char) i.intValue();
			debug.print(c);
		}
		//
		return Status.NEXT;
	}
566242
def _exit(self, status_code):
        """"""
        # If there are active threads still running infinite loops, sys.exit
        # won't kill them but os._exit will. os._exit skips calling cleanup
        # handlers, flushing stdio buffers, etc.
        exit_func = os._exit if threading.active_count() > 1 else sys.exit
        exit_func(status_code)
1118094
function (qunit) {
                        qunit.on('testEnd', function (testEnd) {
                            testEnd.errors.forEach(function (error) {
                                var actual = qunit.dump.parse(error.actual),
                                expected = qunit.dump.parse(error.expected),
                                reason = 'Actual value ' + actual + ' does not match expected value ' + expected,
                                message = 'Description: ' + error.message + EOL +
                                'Reason: ' + reason + EOL +
                                'Stack: ' + error.stack;

                                grunt.log.errorlns(message);
                            });
                        });
                    }
989734
def abort(self, err):
        """"""
        if _debug: IOQController._debug("abort %r", err)

        if (self.state == CTRL_IDLE):
            if _debug: IOQController._debug("    - idle")
            return

        while True:
            iocb = self.ioQueue.get(block=0)
            if not iocb:
                break
            if _debug: IOQController._debug("    - iocb: %r", iocb)

            # change the state
            iocb.ioState = ABORTED
            iocb.ioError = err

            # notify the client
            iocb.trigger()

        if (self.state != CTRL_IDLE):
            if _debug: IOQController._debug("    - busy after aborts")
145909
public function iPutABreakpoint()
    {
        fwrite(STDOUT, "\033[s \033[93m[Breakpoint] Press \033[1;93m[RETURN]\033[0;93m to continue, or 'q' to quit...\033[0m");
        do {
            $line = trim(fgets(STDIN, 1024));
            //Note: this assumes ASCII encoding.  Should probably be revamped to
            //handle other character sets.
            $charCode = ord($line);
            switch ($charCode) {
                case 0: //CR
                case 121: //y
                case 89: //Y
                    break 2;
                // case 78: //N
                // case 110: //n
                case 113: //q
                case 81: //Q
                    throw new \Exception("Exiting test intentionally.");
                default:
                    fwrite(STDOUT, sprintf("\nInvalid entry '%s'.  Please enter 'y', 'q', or the enter key.\n", $line));
                    break;
            }
        } while (true);
        fwrite(STDOUT, "\033[u");
    }
768801
def run(self):
    
    try:
      while True:
        aFunction, arguments = self.manager.taskQueue.get()
        if aFunction is None:
          break
        aFunction(arguments)
    except KeyboardInterrupt:
      import thread
      print >>sys.stderr, "%s caught KeyboardInterrupt" % threading.currentThread().getName()
      thread.interrupt_main()
    except Exception, x:
      print >>sys.stderr, "Something BAD happened in %s:" % threading.currentThread().getName()
      traceback.print_exc(file=sys.stderr)
      print >>sys.stderr, x
108769
def fix_windows_stdout_stderr():
    

    if hasattr(sys, "frozen") and sys.platform == "win32":
        try:
            sys.stdout.write("\n")
            sys.stdout.flush()
        except:
            class DummyStream(object):
                def __init__(self): pass

                def write(self, data): pass

                def read(self, data): pass

                def flush(self): pass

                def close(self): pass

            sys.stdout, sys.stderr, sys.stdin = DummyStream(), DummyStream(), DummyStream()
            sys.__stdout__, sys.__stderr__, sys.__stdin__ = DummyStream(), DummyStream(), DummyStream()
339791
def Run(self, unused_args):
    """"""
    if flags.FLAGS.pdb_post_mortem:
      logging.warning("Segfault action requested :(")
      print(ctypes.cast(1, ctypes.POINTER(ctypes.c_void_p)).contents)
    else:
      logging.warning("Segfault requested but not running in debug mode.")
1241998
def AbortProcessing(obj, eng, callbacks, exc_info):
        """"""
        msg = "Processing was aborted for object: {0}".format(obj.id)
        eng.log.debug(msg)
        raise Break
807599
function() {
		var pid = process.pid;
		
		return Q.fcall(function() {
			if (process.platform === 'win32') {
				process._debugProcess(pid);
			}
			else {
				process.kill(pid, 'SIGUSR1');
			}
		});
	}
1237072
@Override
  public void exitQuery(GDLParser.QueryContext ctx) {
    for(Vertex v : vertices) {
      addPredicates(Predicate.fromGraphElement(v, getDefaultVertexLabel()));
    }
    for(Edge e : edges) {
      addPredicates(Predicate.fromGraphElement(e, getDefaultEdgeLabel()));
    }
  }
24657
def main():
    
    try:
        demo()
    except dialog.error, exc_instance:
        sys.stderr.write("Error:\n\n%s\n" % exc_instance.complete_message())
        sys.exit(1)
        
    sys.exit(0)
12269
function spawnExt(command, args, options, ignoreClose = false,
                  printMessage = msg => process.stdout.write(msg)) {
  let proc;
  const promise = new Promise((resolve, reject) => {
    let descr = command + ' ' + args.join(' ');
    let processOutput = '';
    printMessage(`running: ${descr}\n`);
    try {
      proc = xSpawn.spawn(command, args, options);
    } catch (e) {
      console.log(e);
      reject(e);
      return {proc: null, promise};
    }
    proc.stdout.on('data', printMessage);
    proc.stderr.on('data', printMessage);

    proc.on('close', function(returnCode) {
      printMessage(`completed: ${descr}\n\n`);
      // Many tasks (e.g., tsc) complete but are actually errors;
      // Confirm return code is zero.
      returnCode === 0 || ignoreClose ? resolve(0) : reject(returnCode);
    });
    proc.on('error', function(data) {
      printMessage(`completed with error: ${descr}\n\n`);
      printMessage(`${data.toString()}\n`);
      reject(data);
    });
  });
  return {proc, promise};
}
1150681
def abort (self):
        """"""
        self.print_active_threads()
        self.cancel()
        timeout = self.config["aborttimeout"]
        try:
            self.urlqueue.join(timeout=timeout)
        except urlqueue.Timeout:
            log.warn(LOG_CHECK, "Abort timed out after %d seconds, stopping application." % timeout)
            raise KeyboardInterrupt()
575288
def debug(self, message, *args, **kwargs):
        
        self.system.debug(message, *args, **kwargs)