Read and return `DM_SQUARE_DEBUG` env var, if defined.

    Raises
    ------
    RuntimeError
        If DM_SQUARE_DEBUG is not an int convertable value
181502
def debug_lvl_from_env():
    
    debug_lvl = os.environ.get('DM_SQUARE_DEBUG')
    if not debug_lvl:
        return 0

    try:
        debug_lvl = int(debug_lvl)
    except ValueError:
        # ensure that logging is configured as this method is likely to be
        # called prior to configuring logging.
        setup_logging(verbosity=1)
        raise RuntimeError(
            textwrap.dedent("""\
            env var DM_SQUARE_DEBUG '{debug_lvl}' is not a string value that
            can be converted to an int.""".format(debug_lvl=debug_lvl))
        ) from None
992539
public Value evaluate( Debugger debugger ) throws InvocationException
  {
    RuntimeState runtimeState = getRuntimeState( debugger );

    Location suspendedLoc = debugger.getSuspendedLocation();
    VirtualMachine vm = suspendedLoc.virtualMachine();

    ClassType classType = runtimeState.getCodeRunnerClass( vm );
    Value thisObject = findThisObjectFromCtx( debugger.getSuspendedThread() );
    try
    {
      Value value = classType.invokeMethod(
        debugger.getSuspendedThread(), runtimeState.getRunMeSomeCodeMethod(),
        Arrays.asList(
          thisObject,
          suspendedLoc.declaringType().classLoader(),
          makeExternalsSymbolsForLocals( runtimeState, vm, debugger ),
          vm.mirrorOf( _strText ),
          vm.mirrorOf( _strClassContext ),
          vm.mirrorOf( _strContextElementClass ),
          vm.mirrorOf( _iContextLocation ) ), 0 );
      // Primitive boolean value needed for conditional breakpoint expression
      return unboxIfBoxed( runtimeState, debugger.getSuspendedThread(), value );
    }
    catch( Exception e )
    {
      throw GosuExceptionUtil.forceThrow( e );
    }
  }
935584
def _VAR_DECL_value(self, cursor, _type):
        """"""
        # always expect list [(k,v)] as init value.from list(cursor.get_children())
        # get the init_value and special cases
        init_value = self._get_var_decl_init_value(cursor.type,
                                                   list(cursor.get_children()))
        _ctype = cursor.type.get_canonical()
        if self.is_unexposed_type(_ctype):
            # string are not exposed
            init_value = '%s # UNEXPOSED TYPE. PATCH NEEDED.' % (init_value)
        elif (self.is_pointer_type(_ctype) and
                      _ctype.get_pointee().kind == TypeKind.FUNCTIONPROTO):
            # Function pointers argument are handled at type creation time
            # but we need to put a CFUNCTYPE as a value of the name variable
            init_value = _type
        elif self.is_array_type(_ctype):
            # an integer litteral will be the size
            # an string litteral will be the value
            # any list member will be children of a init_list_expr
            # FIXME Move that code into typedesc
            def countof(k, l):
                return [item[0] for item in l].count(k)

            if (countof(CursorKind.INIT_LIST_EXPR, init_value) == 1):
                init_value = dict(init_value)[CursorKind.INIT_LIST_EXPR]
            elif (countof(CursorKind.STRING_LITERAL, init_value) == 1):
                # we have a initialised c_array
                init_value = dict(init_value)[CursorKind.STRING_LITERAL]
            else:
                # ignore size alone
                init_value = []
            # check the array size versus elements.
            if _type.size < len(init_value):
                _type.size = len(init_value)
        elif init_value == []:
            # catch case.
            init_value = None
        else:
            log.debug('VAR_DECL: default init_value: %s', init_value)
            if len(init_value) > 0:
                init_value = init_value[0][1]
        return init_value
215874
function debugDOM(htmlElement) {
  const limit = process.env.DEBUG_PRINT_LIMIT || 7000
  const inNode =
    typeof process !== 'undefined' &&
    process.versions !== undefined &&
    process.versions.node !== undefined
  /* istanbul ignore next */
  const window =
    (htmlElement.ownerDocument && htmlElement.ownerDocument.defaultView) ||
    undefined
  const inCypress =
    (typeof global !== 'undefined' && global.Cypress) ||
    (typeof window !== 'undefined' && window.Cypress)
  /* istanbul ignore else */
  if (inCypress) {
    return ''
  } else if (inNode) {
    return prettyDOM(htmlElement, limit)
  } else {
    return prettyDOM(htmlElement, limit, {highlight: false})
  }
}
1097274
def debugger():
    """"""
    sdb = _current[0]
    if sdb is None or not sdb.active:
        sdb = _current[0] = Sdb()
    return sdb
415015
def value(self):
        """"""
        dtype = lib.get_data_type(self._data)
        dvalue = lib.get_data_value(self._data)

        if dvalue == ffi.NULL:
            return None

        return self.python_value(dtype, dvalue)
735262
private void read_env() {
        String env;
        try {
            if ((env = System.getProperty("TANGO_HOST")) == null) {
		if ((env = System.getenv("TANGO_HOST")) == null) {
		    Except.throw_connection_failed("TangoApi_TANGO_HOST_NOT_SET",
			    "Property \"TANGO_HOST\" not exported", "TangoDs.Util.read_env()");
		}
	    }

	    assert env != null;
	    if (env.indexOf(":") < 0) {
		Except.throw_connection_failed("TangoApi_TANGO_HOST_NOT_SET",
			"Unknown \"TANGO_HOST\" property " + env, "TangoDs.Util.read_env()");
	    }
	    final String[] array = ApiUtil.parseTangoHost(env);
	    db_host = array[0];
	} catch (final DevFailed e) {
	    Except.print_exception(e);
	    System.exit(-1);
	}
    }
1108833
def read_var_uint64(self):
        
        i = self._read_varint_helper()
        if not 0 <= i <= wire_format.UINT64_MAX:
            raise errors.DecodeError('Value out of range for uint64: %d' % i)
        return i
1035732
def get_debug_info():
        
        from . import __version__
        from .parser import SPEC_VERSION
        d = OrderedDict()
        d['Version'] = '%s' % __version__
        d['Spec version'] = SPEC_VERSION

        return d
90015
def _get_envvar_value(self):
        
        envvar_name = None

        if self.envvar is True:
            envvar_name = self.envvar_name
            if envvar_name is None:
                envvar_name = '_'.join(self.get_path()).upper()
        elif self.envvar:
            envvar_name = self.envvar

        if envvar_name and envvar_name in os.environ:
            return self.type.deserialize(os.environ[envvar_name])
        else:
            return not_set
1233342
def get_var_count(self):
        
        n = c_int()
        self.library.get_var_count.argtypes = [POINTER(c_int)]
        self.library.get_var_count(byref(n))
        return n.value
186346
def init(envVarName, enableColorOutput=False):
    
    global _initialized

    if _initialized:
        return

    global _ENV_VAR_NAME
    _ENV_VAR_NAME = envVarName

    if enableColorOutput:
        _preformatLevels(envVarName + "_NO_COLOR")
    else:
        _preformatLevels(None)

    if envVarName in os.environ:
        # install a log handler that uses the value of the environment var
        setDebug(os.environ[envVarName])
    addLimitedLogHandler(stderrHandler)

    _initialized = True
812557
def check_for_debug(supernova_args, nova_args):
    
    # Heat requires special handling for debug arguments
    if supernova_args['debug'] and supernova_args['executable'] == 'heat':
        nova_args.insert(0, '-d ')
    elif supernova_args['debug']:
        nova_args.insert(0, '--debug ')

    return nova_args
77607
def argval(self):
        
        if self.arg is None or any(x is None for x in self.arg):
            return None

        for x in self.arg:
            if not isinstance(x, int):
                raise InvalidArgError(self.arg)

        return self.arg
1352899
def debug
    return unless @debug
    message = Thread.current.to_s + ' ' + yield
    if defined?(Syslog) and Syslog.opened?
      Syslog.debug(message)
    else
      STDERR << 'syncache: ' + message + "\n"
      STDERR.flush
    end
  end
468188
def parse_square_param(line):
    
    if not line.startswith("square_param="):
        raise ValueError("Not a valid square_param line")
    values = line.split()
    params = {'sigma': float(values.pop()),
              'm0': float(values.pop()),
              'c': float(values.pop()),
              'eff_max': float(values.pop())
              }
    return params
1116654
def get_scoped_variable_m(self, data_port_id):
        
        for scoped_variable_m in self.scoped_variables:
            if scoped_variable_m.scoped_variable.data_port_id == data_port_id:
                return scoped_variable_m
        return None