the other values in `loadConfig` will be interpreted later 
string parsers
435732
function defaultGetCallingScript(offset = 0) {
	const stack = (new Error).stack.split(/$/m);
	const line = stack[(/^Error/).test(stack[0]) + 1 + offset];
	const parts = line.split(/@(?![^/]*?\.xpi)|\(|\s+/g);
	return parts[parts.length - 1].replace(/:\d+(?::\d+)?\)?$/, '');
}
369168
function _parseConfig(config) {
  const _config = Object.assign({}, {
    filename:module.parent.filename,
    scope: settings.get('scope') || {},
    includeGlobals:false,
    proxyGlobal:true,
    useSandbox: settings.get('useSandbox') || false,
    workspace: [workspaces.DEFAULT_WORKSPACE],
    squashErrors: !!(config.resolver || {}).squashErrors
  }, config);

  if (isBuffer(_config.content)) _config.content = _config.content.toString();

  return _config;
}
1019173
def loads(self, config_str, as_defaults=False):
        
        self._rw.load_config_from_string(self._config, config_str, as_defaults=as_defaults)
239652
def parse_known_args(self, args=None, namespace=None):
        """"""
        # load the config_manager within the scope of the method that uses it
        # so that we avoid circular references in the outer scope
        from configman.config_manager import ConfigurationManager
        configuration_manager = ConfigurationManager(
            definition_source=[self.get_required_config()],
            values_source_list=self.value_source_list,
            argv_source=args,
            app_name=self.prog,
            app_version=self.version,
            app_description=self.description,
            use_auto_help=False,
        )
        conf = configuration_manager.get_config(
            mapping_class=create_key_translating_dot_dict(
                "HyphenUnderscoreDict",
                (('-', '_'),)
            )
        )
        return conf
969985
function loadConfigCore(configItem) {
  if (typeof configItem === "string") {
    configItem = fs.readFileSync(configItem, "utf8");
  } else if (typeof configItem === "object") {
    // do nothing
  } else {
    throw new Error("Unexpected config item type.");
  }

  return configItem;
}
83115
function parseConfig( p ){

    var fileContent = fs.readFileSync( p ).toString( 'utf-8' ),
        json = JSON.parse( fileContent || '{}' );

    return json;
}
853655
function parseListConfig(string) {
		var items = {};

		// Collapse whitespace around ,
		string = string.replace(/\s*,\s*/g, ",");

		string.split(/,+/).forEach(function(name) {
			name = name.trim();
			if (!name) {
				return;
			}
			items[name] = true;
		});
		return items;
	}
1268381
def read(config_values):
    """"""
    if not config_values:
        raise RheaError('Cannot read config_value: `{}`'.format(config_values))

    config_values = to_list(config_values)

    config = {}
    for config_value in config_values:
        config_value = ConfigSpec.get_from(value=config_value)
        config_value.check_type()
        config_results = config_value.read()
        if config_results and isinstance(config_results, Mapping):
            config = deep_update(config, config_results)
        elif config_value.check_if_exists:
            raise RheaError('Cannot read config_value: `{}`'.format(config_value))

    return config
137377
private String[] toNameConfigPair(String token) throws ConfigurationException {
        String[] pair = token.split("\\[", 2);
        String name = StringUtils.clean(pair[0]);

        if (name == null) {
            throw new IllegalArgumentException("Filter name not found for filter chain definition token: " + token);
        }
        String config = null;

        if (pair.length == 2) {
            config = StringUtils.clean(pair[1]);
            //if there was an open bracket, it assumed there is a closing bracket, so strip it too:
            config = config.substring(0, config.length() - 1);
            config = StringUtils.clean(config);

            //backwards compatibility prior to implementing SHIRO-205:
            //prior to SHIRO-205 being implemented, it was common for end-users to quote the config inside brackets
            //if that config required commas.  We need to strip those quotes to get to the interior quoted definition
            //to ensure any existing quoted definitions still function for end users:
            if (config != null && config.startsWith("\"") && config.endsWith("\"")) {
                String stripped = config.substring(1, config.length() - 1);
                stripped = StringUtils.clean(stripped);

                //if the stripped value does not have any internal quotes, we can assume that the entire config was
                //quoted and we can use the stripped value.
                if (stripped != null && stripped.indexOf('"') == -1) {
                    config = stripped;
                }
                //else:
                //the remaining config does have internal quotes, so we need to assume that each comma delimited
                //pair might be quoted, in which case we need the leading and trailing quotes that we stripped
                //So we ignore the stripped value.
            }
        }

        return new String[]{name, config};

    }
1098186
public static Configuration loadFromString(String config)
    throws IOException, SAXException {
    ConfigurationImpl cfg = new ConfigurationImpl();

    XMLReader parser = XMLReaderFactory.createXMLReader();
    parser.setContentHandler(new ConfigHandler(cfg, null));
    Reader reader = new StringReader(config);
    parser.parse(new InputSource(reader));
    return cfg;
  }
108975
private static String getStringValue0(String appName, String key) {
        String ret = System.getProperty(key);
        if (StringUtils.isNotEmpty(ret)) {
            return ret;
        }
        rLock.lock();
        try {
            for (ExternalConfigLoader configLoader : CONFIG_LOADERS) {
                ret = appName == null ? configLoader.getValue(key)
                    : configLoader.getValue(appName, key);
                if (StringUtils.isNotEmpty(ret)) {
                    return ret;
                }
            }
        } finally {
            rLock.unlock();
        }
        return getConfig().getProperty(key);
    }
1263490
def load_config(self):
        
        self.__config = {}

        # Parse sections, its options and put it in self.config.
        for section in self.sections:

            self.__config[section] = {}
            options = self.parser.options(section)

            # Parse options of each section
            for option in options:

                try:
                    opt = self.parser \
                        .get(section, option)
                    try:
                        self.__config[section][option] = literal_eval(opt)
                    except (SyntaxError, ValueError):
                        self.__config[section][option] = opt
                        self.log_output.append(
                            {"level": "debug",
                             "msg": "Option not literal_eval-parsable"
                                    " (maybe string): [{0}] {1}"
                                 .format(section, option)})

                    if self.__config[section][option] == -1:
                        self.log_output.append(
                            {"level": "debug",
                             "msg": "Skipping: [%s] %s" % (section, option)}
                        )
                except ConfigParser.NoOptionError as exc:
                    self.log_output.append(
                        {"level": "error",
                         "msg": "Exception on [%s] %s: %s"
                                % (section, option, exc)}
                    )
                    self.__config[section][option] = None
545308
def load_from_string(self, settings_string='', module_name='customsettings'):
        '''
        
        '''
        try:
            mod = imp.new_module(module_name)
            exec(settings_string, mod.__dict__)
        except TypeError:
            log.warning("Could not import settings")
        self.my_settings = {}
        try:
            self.my_settings = self._convert_to_dict(mod)
        except ImportError:
            log.warning("Settings unable to be loaded")

        return self.settings()
748130
function Config(options) {
  var useConfig;

  options = options || {};

  this.cache = {};
  this.parser = options.parser;

  this.useNplintrc = (options.useNplintrc !== false);
  this.useNplintignore = (options.useNplintignore !== false);

  useConfig = options.configFile;
  this.options = options;

  if (useConfig) {
    if (isResolvable(useConfig) || isResolvable('nplint-config-' + useConfig) || useConfig.charAt(0) === '@') {
      this.useSpecificConfig = loadConfig(useConfig);
    } else {
      this.useSpecificConfig = loadConfig(path.resolve(process.cwd(), useConfig));
    }
  }
}
246846
def parse_config(config)
      sections = {"defaults" => []}
      current  = "defaults"
      config.gsub(/#[^\n]*/, "")
        .split(/\n/)
        .map(&:strip)
        .reject(&:empty?)
        .each do |line|
        if IS_SECTION =~ line
          current = line.match(IS_SECTION)[1].strip
          sections[current] ||= []
        else
          sections[current] << line
        end
      end
      sections
    end
46554
function (str, parserOptions) {
  parserOptions = parserOptions || {};
  var map = parserOptions.map || identity;
  var loadMethod = parserOptions.loadMethod || 'safeLoad';
  var data = index$13[loadMethod](str, omit(parserOptions, ['map', 'loadMethod'])) || {};
  return map(data, map);
}
1266513
def __parse_config(self):
        

        if self.should_parse_config and (self.args.config or self.config_file):
            self.config = ConfigParser.SafeConfigParser()
            self.config.read(self.args.config or self.config_file)