/*
DEBUG OPTIONS
334420
public void viewDebugMenuClick(int index, Object value, boolean isToggled) {
		System.out.println(index + ":" + value + ":" + isToggled);
		switch (index) {
		case 0:
			displayFps = isToggled;
			app.setDisplayFps(isToggled);
			break;
		case 1:
			app.setDisplayStatView(isToggled);
			break;
		}
	}
1271717
function debug(message) {
            if (enplug.debug) {
                arguments[0] = TAG + arguments[0];
                console.log.apply(console, arguments);
            }
        }
1171113
function OpenBlock_Handle_Debug(&$res)
    {
        if ($res['ArgumentCount'] == 0) {
            return '$scope->debug();';
        } elseif ($res['ArgumentCount'] == 1) {
            $arg = $res['Arguments'][0];

            if ($arg['ArgumentMode'] == 'string') {
                return 'Debug::show('.$arg['php'].');';
            }

            $php = ($arg['ArgumentMode'] == 'default') ? $arg['lookup_php'] : $arg['php'];
            return '$val .= Debug::show('.str_replace('FINALGET!', 'cachedCall', $php).');';
        } else {
            throw new SSTemplateParseException('Debug takes 0 or 1 argument only.', $this);
        }
    }
1034008
public static function debug($data, array $options = [])
    {
        $options = array_merge([
            'trace_offset' => 0,
        ], $options);

        self::output(self::getDebugInformation($data), $options);
    }
815922
function setDebugLevel(level, printf) {
  var outLevel = 0;

  debug = debug2 = debug3 = debugTree = function() {};

  switch (String(level)) {
    case '3':
      debug3 = printf;
      outLevel++;
      // fall through
    case '2':
      debugTree = function (fmt, tree) {
        printf(fmt, util.inspect(tree.toJSON(), false, 64));
      };
      debug2 = printf;
      outLevel++;
      // fall through
    case '1':
      debug = printf;
      outLevel++;
      // fall through
    default:
      return outLevel;
  }
}
731095
def checkdebug(self):
        
        # Global debugging
        opt = self.file_grep(r"^(DEFAULT_LOGGING|DAEMONOPTIONS)=(.*)",
                             *self.files)
        for opt1 in opt:
            for opt2 in opt1.split(" "):
                if opt2 in ("--debug", "debug"):
                    return True
        return False
784623
def enable_debug(self):
        
        if self.args.foreground:
            self.config.application[config.DEBUG] = True
951322
@Override
    public void debug(Object object, Object... objects) {
        if (isDebugEnabled()) {
            StringBuilder result = new StringBuilder();
            result.append(object.toString());
            for (Object obj : objects) {
                if (obj == null) {
                    result.append("null");
                } else {
                    result.append(obj.toString());
                }
            }
            debugString(result.toString());
        }
    }
822989
function debug(name) {
  function disabled(){}
  disabled.enabled = false;

  var match = skips.some(function(re){
    return re.test(name);
  });

  if (match) return disabled;

  match = names.some(function(re){
    return re.test(name);
  });

  if (!match) return disabled;

  function logger(msg) {
    msg = (msg instanceof Error) ? (msg.stack || msg.message) : msg;
    Function.prototype.apply.call(logger.log, this, arguments);
  }

  logger.log = exports.log;
  logger.enabled = true;

  return logger;
}
339127
function debug(cmd) {
        // start node in debug mode
        childProcess = childProcess || require("child_process");

        var PATH_CWD = process.cwd();

        // splice out allume command
        process.argv.splice(0, 1);

        // find debug argument
        var debugIdx = -1;
        for (var a in process.argv) {
            if (process.argv[a] == "--debug") {
                debugIdx = a;
            }
            process.argv[a] = process.argv[a].replace(/"/g, "\"");
        }
        if (debugIdx >= 0) {
            process.argv.splice(debugIdx, 1);
        }
        if (!cmd["--debug"].port) {
            process.argv.splice(0, 0, "--debug-brk");
            //process.argv.splice(0, 0, "--inspect");
        }
        else {
            if (debugIdx >= 0) {
                process.argv.splice(debugIdx, 1);
            }
            process.argv.splice(0, 0, "--debug-brk=" + cmd["--debug"].port);
            //process.argv.splice(0, 0, "--inspect=" + cmd["--debug"].port);
        }
    

        var ls = childProcess.spawn("node", process.argv, {"cwd": PATH_CWD});

        ls.stdout.on("data", function(data) {
            console.log(data.toString().trim());
        });

        ls.stderr.on("data", function(data) {
            console.error(data.toString().trim());
        });

        return;
    }
1311317
def debug_object(obj: T) -> str:
    """"""
    pairs = []
    for k, v in vars(obj).items():
        pairs.append(u"{}={}".format(k, v))
    return u", ".join(pairs)
912487
def debug(message)
      (m = filter(message, :debug)) && each {|l| l.debug(m)}
    end
41413
protected void debug(String string, int level) {
		if (VerbosityOption.getValue()>=level){
			System.out.println(string); 
		}
	}
901852
function(parsoidOptions, cliOpts) {
		// Handle the --help options
		var exit = false;
		if (cliOpts.trace === 'help') {
			console.error(ScriptUtils.traceUsageHelp());
			exit = true;
		}
		if (cliOpts.dump === 'help') {
			console.error(ScriptUtils.dumpUsageHelp());
			exit = true;
		}
		if (cliOpts.debug === 'help') {
			console.error(ScriptUtils.debugUsageHelp());
			exit = true;
		}
		if (cliOpts.genTest === 'help') {
			console.error(ScriptUtils.genTestUsageHelp());
			exit = true;
		}
		if (exit) {
			process.exit(1);
		}

		// Ok, no help requested: process the options.
		if (cliOpts.debug !== undefined) {
			// Continue to support generic debugging.
			if (cliOpts.debug === true) {
				console.warn("Warning: Generic debugging, not handler-specific.");
				parsoidOptions.debug = ScriptUtils.booleanOption(cliOpts.debug);
			} else {
				// Setting --debug automatically enables --trace
				parsoidOptions.debugFlags = ScriptUtils.splitFlags(cliOpts.debug);
				parsoidOptions.traceFlags = parsoidOptions.debugFlags;
			}
		}

		if (cliOpts.trace !== undefined) {
			if (cliOpts.trace === true) {
				console.warn("Warning: Generic tracing is no longer supported. Ignoring --trace flag. Please provide handler-specific tracing flags, e.g. '--trace pre,html5', to turn it on.");
			} else {
				// Add any new trace flags to the list of existing trace flags (if
				// any were inherited from debug); otherwise, create a new list.
				parsoidOptions.traceFlags = (parsoidOptions.traceFlags || []).concat(ScriptUtils.splitFlags(cliOpts.trace));
			}
		}

		if (cliOpts.dump !== undefined) {
			if (cliOpts.dump === true) {
				console.warn("Warning: Generic dumping not enabled. Please set a flag.");
			} else {
				parsoidOptions.dumpFlags = ScriptUtils.splitFlags(cliOpts.dump);
			}
		}

		if (cliOpts.genTest) {
			if (cliOpts.genTest === true) {
				console.warn("Warning: Generic test generation is not supported. Ignoring --genTest flag. Please provide handler-specific tracing flags, e.g. '--genTest ListHandler', to turn it on.");
			} else {
				if (cliOpts.genTest.slice(0,4) === 'dom:') {
					var domHandlers = new Set([
						'dom:dpload', 'dom:fostered', 'dom:process-fixups', 'dom:normalize',
						'dom:pwrap', 'dom:migrate-metas', 'dom:pres', 'dom:migrate-nls',
						'dom:dsr', 'dom:tplwrap', 'dom:dom-unpack', 'dom:tag:cite', 'dom:tag:poem',
						'dom:fixups', 'dom:media', 'dom:sections', 'dom:heading-ids', 'dom:lang-converter',
						'dom:strip-metas', 'dom:cleanup', 'dom:linkclasses', 'dom:redlinks',
						'dom:downgrade'
					]);
					parsoidOptions.generateFlags = {
						"handlers": ScriptUtils.splitFlags(cliOpts.genTest),
						"directory": cliOpts.genDirectory,
						"pageName": cliOpts.pageName,
						"fragments": cliOpts.genTestFragments
					};
					parsoidOptions.generateFlags.handlers.forEach(function(handler) {
						console.assert(domHandlers.has(handler),
							'No matching DOM handler named ' + handler + ' found, exiting.');
					});

				} else {
					var handlers = new Set([
						'QuoteTransformer', 'ListHandler', 'ParagraphWrapper',
						'TokenStreamPatcher', 'BehaviorSwitchHandler', 'SanitizerHandler',
						'PreHandler', 'NoInclude', 'IncludeOnly', 'OnlyInclude',
						'MigrateTemplateMarkerMetas',
					]);
					parsoidOptions.generateFlags = {
						"handler": cliOpts.genTest,
						"fileName": cliOpts.genTestOut
					};
					console.assert(handlers.has(parsoidOptions.generateFlags.handler),
						'No matching token handler named ' + parsoidOptions.generateFlags.handler + ' found, exiting.');
				}
			}
		}

		return parsoidOptions;
	}
481055
function(options) {
    if (typeof options != "object" || options.length) {
      if (this.options.debug) {
        throw (options + ' options has to be an object');
      } else {
        return;
      }
    }

    // Set options
    _.defaults(this.options, options);
  }
525735
function resolveForkOptions(opts) {
  opts = opts || {};

  var processExecArgv = process.execArgv.join(' ');
  var inspectorActive = processExecArgv.indexOf('--inspect') !== -1;
  var debugBrk = processExecArgv.indexOf('--debug-brk') !== -1;

  var execArgv = [];
  if (inspectorActive) {
    execArgv.push('--inspect=' + opts.debugPort);

    if (debugBrk) {
      execArgv.push('--debug-brk');
    }
  }

  return assign({}, opts, {
    forkArgs: opts.forkArgs,
    forkOpts: assign({}, opts.forkOpts, {
      execArgv: (opts.forkOpts && opts.forkOpts.execArgv || [])
      .concat(execArgv)
    })
  });
}
918313
def debug(value):
    
    print("%s %s: " % (type(value), value))
    print(dir(value))
    print('\n\n')
    return ''