Read a configuration file: Difference between revisions

* [[Update a configuration file]]

<br><br>

 

=={{header|Ada}}==

Uses package Config available at SourceForge:

https://sourceforge.net/projects/ini-files/

with Ada.Text_IO; use Ada.Text_IO;

 

Put_Line("seedsremoved = " & Boolean'Image(seedsremoved));

Put_Line("otherfamily = " & otherfamily);

 

{{out}}

 

=={{header|Aime}}==

integer c;

file f;

l.ucall(o_, 0, ", ");

o_("\n");

{{Out}}

<pre>FAVOURITEFRUIT: banana

SEEDSREMOVED: false

OTHERFAMILY: Rhu Barber, Harry Barber,</pre>

 

=={{header|AutoHotkey}}==

 

; Author: AlephX, Aug 18 2011

data = %A_scriptdir%\rosettaconfig.txt

}

msgbox, FULLNAME %fullname%`nFAVOURITEFRUIT %FAVOURITEFRUIT%`nNEEDSPEELING %NEEDSPEELING%`nSEEDSREMOVED %SEEDSREMOVED%`nOTHERFAMILY %OTHERFAMILY1% + %OTHERFAMILY2%

 

=={{header|AWK}}==

# syntax: GAWK -f READ_A_CONFIGURATION_FILE.AWK

BEGIN {

return(str)

}

{{out}}

<pre>

 

This is a fully functional program with generic reading of a configuration file with variable names up to 20 characters and values up to 30 characters. Both limits can be expanded as needed but remember how quick it can eat RAM. It can read configuration files with variables separated of values through spaces or equal sign (=), so it will find "Variable = Value" or "Variable Value". Values can be separated by commas in configuration file and it will create a virtual array. This program will omit lines begining with #, ; or null.

' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '

' Read a Configuration File V1.0 '

 

END FUNCTION

Run

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

NAME = 2

ARRAY = 3

WHEN ARRAY: = !^array$()

ENDCASE

{{out}}

<pre>

'''optimized'''

 

#include <stdlib.h>

#include <string.h>

return 0;

 

 

{{out}}

'''unoptimized'''

 

#include <iostream>

#include <fstream>

return 0;

}

 

{{out}}

 

'''Solution without Boost libraries. No optimisation.'''

#include <iomanip>

#include <string>

read_config(inp,outp);

}

 

{{out}}

 

=={{header|Clojure}}==

(:require [clojure.java.io :as io]

[clojure.string :as str])

(defn -main

[filename]

 

{{out}}

 

=={{header|COBOL}}==

identification division.

program-id. ReadConfiguration.

end-perform

.

 

{{out}}

=={{header|Common Lisp}}==

Using parser-combinators available in quicklisp:

 

(defpackage :read-config

((eq parsed nil) (error "config parser error: ~a" line))

(t (setf (gethash (car parsed) hash) (cdr parsed))))))

{{out}}

#<HASH-TABLE :TEST EQUAL :COUNT 4 {100BD25B43}>

READ-CONFIG> (maphash (lambda (k v) (print (list k v))) *)

NIL

NIL

 

=={{header|D}}==

 

 

void setOpt(alias Var)(in string line) {

if (!m.empty) {

static if (is(typeof(Var) == string))

Var = m.captures.length > 2 ? m.captures[2] : "";

 

void main(in string[] args) {

bool needsPeeling, seedsRemoved; // Default false.

 

foreach (line; f.byLine) {

auto opt = line.strip.idup;

setOpt!fullName(opt);

setOpt!favouriteFruit(opt);

}

 

{{out}}

 

=={{header|DCL}}==

$ loop:

$ read /end_of_file = done input line

$ goto loop

$ done:

{{out}}

<pre>$ @read_a_configuration_file

FAVOURITEFRUIT = "banana"

NEEDSPEELING = "true"</pre>

 

=={{header|EchoLisp}}==

{{Incorrect|EchoLisp|Makes no attempt to parse the configuration file of the task description.}}

There is no 'config file' in EchoLisp, but a '''(preferences)''' function which is automatically loaded and evaluated at boot-time, and automatically saved after modification. This function can set global parameters, or call other functions, or load libraries.

(edit 'preferences)

;; current contents to edit is displayed in the input box

; SEEDSREMOVED

(define OTHERFAMILY '("Rhu Barber" "Harry Barber")))

{{out}}

;; press F5 or COMMAND-R to reload

EchoLisp - 2.13.12

SEEDSREMOVED

😡 error: #|user| : unbound variable : SEEDSREMOVED

 

=={{header|Elixir}}==

{{trans|Erlang}}

def read(file) do

File.read!(file)

end

 

 

{{out}}

=={{header|Erlang}}==

 

-module( configuration_file ).

 

option_from_binaries_value( [Value] ) -> erlang:binary_to_list(Value);

option_from_binaries_value( Values ) -> [erlang:binary_to_list(X) || X <- Values].

 

{{out}}

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

 

Something worth noting is that the FORTH interpreter will halt on a syntax error in the config.txt file. If this was not the proscribed behavior for the application then the FORTH error handler would need modification. This is possible in most systems by using the system error words (abort, catch, throw) appropriately while interpreting the config file.

FORTH DEFINITIONS

 

: # ( -- ) 1 PARSE 2DROP ; \ parse line and throw away

: = ( addr --) 1 PARSE trim ROT PLACE ; \ string assignment operator

 

FORTH DEFINITIONS

CR ." Family:"

CR otherfamily(1) $.

The config file would look like this

<pre>

Rhu Barber

Harry Barber ok</PRE>

 

=={{header|Fortran}}==

 

program readconfig

implicit none

 

end program

 

=={{header|FreeBASIC}}==

 

Sub split (s As Const String, sepList As Const String, result() As String)

Print

Print "Press any key to quit"

 

{{out}}

Other family(0) = Rhu Barber

Other family(1) = Harry Barber

</pre>

 

=={{header|Gambas}}==

Dim fullname As String = Settings["fullname", "Foo Barber"] 'If fullname is empty then use the default "Foo Barber"

Dim favouritefruit As String = Settings["favouritefruit", "banana"]

Print fullname

 

Output:

<pre>

=={{header|Go}}==

This make assumptions about the way the config file is supposed to be structured similar to the ones made by the Python solution.

 

import (

 

return v, nil

 

Usage example:

 

import (

fmt.Printf("SEEDSREMOVED: %q\n", seedsremoved)

fmt.Printf("OTHERFAMILY: %q\n", otherfamily)

 

=={{header|Groovy}}==

def loadConfig = { File file ->

String regex = /^(;{0,1})\s*(\S+)\s*(.*)$/

}

}

Testing:

{{out}}

<pre>FULLNAME=Foo Barber

=={{header|Haskell}}==

 

import Data.Char

import Data.List

defaultConfig :: Config

defaultConfig = Config "" "" False False []

 

Or, use Data.Configfile:

 

import Data.ConfigFile

import Data.Either.Utils

let username = getSetting cp "username"

password = getSetting cp "password"

This works with configuration files in standard format, i.e.,

# this is a comment

If it contains any value then it can considered as being equivalent to <i>true</i>:

 

ws := ' \t'

vars := table()

write(s[1:-2])

}

 

Sample run on above input:

=={{header|J}}==

 

set=:4 :'(x)=:y'

 

cfg cfgBoolean 'seedsremoved'

i.0 0

 

Example use:

 

(,' = ',]&.do)&>;: 'fullname favouritefruit needspeeling seedsremoved'

fullname = Foo Barber

favouritefruit = banana

needspeeling = 1

 

=={{header|Java}}==

A more natural way to do this in Java would be Properties.load(InputStream) but the example data is not in the format expected by that method (equals signs are optional).

import java.io.FileReader;

import java.io.IOException;

}

}

 

{{out}}

A more functional and concise approach using Java 8:

 

import java.io.FileReader;

import java.io.IOException;

return result;

}

 

{{out}}

In JavaScript using an object makes more sense than local variables. This function takes our config file in plain text as the parameter.

 

// this expression matches a line starting with an all capital word,

// and anything after it

return configObject;

 

The result is an object, which can be represented with this JSON.

 

"FULLNAME": " Foo Barber",

"FAVOURITEFRUIT": " banana",

]

}

 

=={{header|jq}}==

 

In the following, in the case of collisions, the last-most specification prevails.

 

def uc: .name | ascii_upcase;

end);

 

 

'''Invocation'''

{{works with|Julia|0.6}}

 

vars = Dict()

for line in eachline(file)

readconf("test.conf")

 

 

{{out}}

{{works with|Kotlin|1.0.6}}

This example is more verbose than it has to be because of increased effort in providing immutability to the configuration class.

import java.nio.file.Files

import java.nio.file.Paths

private fun toKeyValuePair(line: String) = line.split(Regex(" "), 2).let {

Pair(it[0], if (it.size == 1) "" else it[1])

 

=={{header|Lasso}}==

#

# Lines beginning with a hash or a semicolon are ignored by the application

'<br />'

#otherfamily

{{out}}

<pre>Foo Barber

 

=={{header|Liberty BASIC}}==

dim confKeys$(100)

dim confValues$(100)

next i

end function

 

{{out}}

 

=={{header|Lua}}==

 

fp = io.open( "conf.txt", "r" )

print( "", entry )

end

 

CreateVar[x_, y_String: "True"] := Module[{},

If[StringFreeQ[y, ","]

CreateVar @@@ data;

]

 

=={{header|MATLAB}} / {{header|Octave}}==

This is defined as a function, parameters are returned as part of a struct. When the first line, and the assignment to return values are removed, it is a script that stores the parameters in the local workspace.

 

% READCONF reads configuration file.

%

fclose(fid);

whos, % shows the parameter in the local workspace

 

<pre>R=readconf('file.conf')

 

=={{header|Nanoquery}}==

import dict

 

end

 

{{out}}

<pre>[[FULLNAME : Foo Barber], [FAVOURITEFRUIT : banana], [NEEDSPEELING : true], [OTHERFAMILY : [Rhu Barber, Harry Barber]]]</pre>

 

=={{header|OCaml}}==

Using the library [http://homepage.mac.com/letaris/ ocaml-inifiles]:

 

#require "inifiles"

open Inifiles

print_endline "other family:";

List.iter (Printf.printf "- %s\n") v;

 

The file "conf.ini":

=={{header|ooRexx}}==

Here's another way of doing this, which stores the values in a Rexx stem (array), and stores each value of a multivalued variable as a separate item:

#!/usr/bin/rexx

/*.----------------------------------------------------------------------.*/

end

return

{{out}}

<pre>

This solution makes use of FCL-STL package shipped with FPC >= 2.6.0, moreover it can be run directly like a script (just chmod +x) using the new instantfpc feature.

 

 

{$if not defined(fpc) or (fpc_fullversion < 20600)}

ConfigValues.Free;

ConfigStrings.Free;

 

{{out}}

What we end up with after processing rosetta.config are three VARs and a LST, named FAVOURITEFRUIT, FULLNAME, NEEDSPEELING and OTHERFAMILY respectively.

 

<@ LETSCPPNTPARSRC>Data|1</@><@ OMT> read file into locally scope variable</@>

<@ LETCGDLSTLLOSCP>List|Data</@><@ OMT> split Data into a list of lines </@>

<@ SAYVAR>NEEDSPEELING</@>

<@ SAYDMPLST>OTHERFAMILY</@>

 

=={{header|Perl}}==

This is an all-singing, all-dancing version that checks the configuration file syntax and contents and raises exceptions if it fails. (It is intentionally over-commented for pedagogical purposes.)

my $favouritefruit;

my $needspeeling;

}

}

 

=={{header|Phix}}==

Normally I would recommend IupConfig, but the "standard" file format in the task description isn't even close (no [Section] headers, no '=').

 

{{out}}

<pre>

 

=={{header|Phixmonti}}==

2 get "," find

if

drop

endfor

{{out}}

<pre>FULLNAME = Foo Barber

Slightly modify the format of the configuration file before passing it to the internal function parse_ini_string()

 

 

$conf = file_get_contents('parse-conf-file.txt');

echo 'Need spelling = ', (empty($ini['NEEDSPEELING']) ? 'false' : 'true'), PHP_EOL;

echo 'Seeds removed = ', (empty($ini['SEEDSREMOVED']) ? 'false' : 'true'), PHP_EOL;

 

{{out}}

[1] => Harry Barber

)</pre>

 

=={{header|PicoLisp}}==

(in File

(while (read)

(rdConf "conf.txt")

(println FULLNAME FAVOURITEFRUIT NEEDSPEELING SEEDSREMOVED OTHERFAMILY)

{{out}}

<pre>"Foo Barber" "banana" T NIL "Rhu Barber, Harry Barber"</pre>

 

=={{header|PL/I}}==

set: procedure options (main);

declare text character (100) varying;

 

end set;

{{out}} using the given text file as input:-

<pre>

 

=={{header|PowerShell}}==

function Read-ConfigurationFile

{

Write-Verbose -Message ("{0,-15}= {1}" -f "OTHERFAMILY", ($script:otherFamily -join ", "))

}

I stored the file in ".\temp.txt" and there is no output unless the -Verbose switch is used:

Read-ConfigurationFile -Path .\temp.txt -Verbose

{{Out}}

<pre>

</pre>

Test if the variables are set:

Get-Variable -Name fullName, favouriteFruit, needsPeeling, seedsRemoved, otherFamily

{{Out}}

<pre>

 

=== Using Switch -Regex ===

Function Read-ConfigurationFile {

[CmdletBinding()]

Return $__Aux

}

Setting variable

$Configuration = Read-ConfigurationFile -LiteralPath '.\config.cfg'

 

Show variable

$Configuration

{{Out}}

<pre>

 

Using customize function

Show-Value $Configuration 'fullname'

Show-Value $Configuration 'favouritefruit'

Show-Value $Configuration 'otherfamily' 1

Show-Value $Configuration 'otherfamily' 2

{{Out}}

<pre>

 

Using index variable

'$Configuration[''fullname'']'

$Configuration['fullname']

'=== $Configuration.Item(3).Item(1) ==='

$Configuration.Item(3).Item(1)

{{Out}}

<pre>

=={{header|Python}}==

This task is not well-defined, so we have to make some assumptions (see comments in code).

ret = {}

with file(fn) as fp:

conf = readconf(sys.argv[1])

for k, v in sorted(conf.items()):

 

=={{header|Racket}}==

Use the shared [[Racket/Options]] code.

 

#lang racket

 

(printf "seedsremoved = ~s\n" seedsremoved)

(printf "otherfamily = ~s\n" otherfamily)

 

{{out}}

{{works with|Rakudo|2020.08.1}}

This demonstrates several interesting features of Raku, including full grammar support, derived grammars, alternation split across derivations, and longest-token matching that works across derivations. It also shows off Raku's greatly cleaned up regex syntax.

my $favouritefruit;

my $needspeeling = False;

say "needspeeling: $needspeeling";

say "seedsremoved: $seedsremoved";

{{out}}

<pre>fullname: Foo Barber

 

=={{header|RapidQ}}==

type TSettings extends QObject

FullName as string

 

Call ReadSettings

 

{{out}}

Settings.OtherFamily.Item(0) = Rhu Barber

Settings.OtherFamily.Item(1) = Harry Barber

</pre>

 

No assumptions were made about what variables are (or aren't) in the configuration file.

<br>Code was written to make the postmortem report as readable as possible.

signal on syntax; signal on novalue /*handle REXX source program errors. */

parse arg cFID _ . /*cFID: is the CONFIG file to be read.*/

novalue: syntax: call err 'REXX program' condition('C') "error",,

condition('D'),'REXX source statement (line' sigl"):",sourceline(sigl)

'''output''' &nbsp; when using the input (file) as specified in the task description:

<pre>

 

=={{header|Ruby}}==

needspeeling = seedsremoved = false

otherfamily = []

otherfamily.each_with_index do |name, i|

puts "otherfamily(#{i+1}) = #{name}"

 

{{out}}

 

=={{header|Run BASIC}}==

dim paramVal$(6)

param$(1) = "fullname"

print param$(i);chr$(9);paramVal$(i)

end if

{{out}}

<pre>

 

=={{header|Rust}}==

use std::io::BufRead;

use std::io::BufReader;

}

}

 

{{out}}

* Converts the entire collection to a Map

 

getLines.

toList.

map {

s:List[String] => (s(0).toLowerCase, s(1).split(",").map(_.trim).toList)

 

Test code:

for ((k,v) <- conf) {

if (v.size == 1)

 

}

{{out}}

<pre>

and [http://seed7.sourceforge.net/libraries/scanfile.htm#getLine%28inout_file%29 getLine].

 

include "scanfile.s7i";

 

writeln(("otherfamily[" <& index <& "]:") rpad 16 <& otherfamily[index]);

end for;

 

{{out}}

 

=={{header|SenseTalk}}==

// read the configuration file and get a list of just the interesting lines

set lines to each line of file "config.txt" where char 1 of each isn't in ("#", ";", "")

put "Variable" && name && "is" && value(name)

end repeat

Output:

Variable FULLNAME is Foo Barber

Variable FAVOURITEFRUIT is banana

Variable NEEDSPEELING is True

Variable OTHERFAMILY is ("Rhu Barber","Harry Barber")

 

=={{header|Sidef}}==

var needspeeling = (var seedsremoved = false);

var otherfamily = [];

otherfamily.each_kv {|i, name|

say "otherfamily(#{i+1}) = #{name}";

{{out}}

<pre>

{{works with|Smalltalk/X}}

This code retrieves the configuration values as a Dictionary; code to set an object's instance variables follows below:

configFile asFilename readingLinesDo:[:line |

(line isEmpty or:[ line startsWithAnyOf:#('#' ';') ]) ifFalse:[

]

].

gives us in dict Dictionary ('fullname'->'Foo Barber' 'needspeeling'->true 'favouritefruit'->'banana' 'otherfamily'->OrderedCollection('Rhu Barber' 'Harry Barber'))

 

assuming that the target object has setters for each option name, we could write:

someObject

perform:(eachOption,':') asSymbol with:eachValue

ifNotUnderstood: [ self error: 'unknown option: ', eachOption ]

or assign variables with:

needspeeling := dict at: 'needspeeling' ifAbsent:false.

favouritefruit := dict at: 'favouritefruit' ifAbsent:false.

otherfamily := dict at: 'otherfamily' ifAbsent:false.

seedsremoved := dict at: 'seedsremoved' ifAbsent:false.

 

=={{header|Tcl}}==

This code stores the configuration values in a global array (<code>cfg</code>) so they can't pollute the global namespace in unexpected ways.

global cfg

# Read the file in

puts "Peeling? $cfg(needspeeling)"

puts "Unseeded? $cfg(seedsremoved)"

 

=={{header|TXR}}==

Prove the logic by transliterating to a different syntax:

@ (cases)

#@/.*/

@ (end)

@(end)

 

Sample run:

 

{{works with|bash}}

# redirect stdin to read from the given filename

exec 0<"$1"

for i in "${!otherfamily[@]}"; do

echo "otherfamily[$i] = ${otherfamily[i]}"

 

{{out}}

 

=={{header|VBScript}}==

Set ofso = CreateObject("Scripting.FileSystemObject")

Set config = ofso.OpenTextFile(ofso.GetParentFolderName(WScript.ScriptFullName)&"\config.txt",1)

config.Close

Set ofso = Nothing

 

{{Out}}

=={{header|Vedit macro language}}==

 

#12 = 0 // seedsremoved = FALSE

Reg_Empty(21) // fullname

Message("fullname = ") Reg_Type(21) TN

Message("favouritefruit = ") Reg_Type(22) TN

 

{{out}}

=={{header|Visual Basic}}==

 

'

' (c) Copyright 1993 - 2011 Mark Hobley

Public Function btrim$(arg$)

btrim$ = LTrim$(RTrim$(arg$))

 

=={{header|Yabasic}}==

 

while(not eof(#a))

wend

 

 

=={{header|zkl}}==

First, a simple parser that knows nothing about contents, just format.

conf:=Dictionary();

foreach line in (config){

}

 

Which may be good enough; query the hash table to get a set option or a default if it wasn't set:

{{out}}

<pre>

</pre>

If your program actually wants to use the options as variables, the following sets variables to values in the config file, ignoring misspellings, or values you don't care about. You are not allowed to create variables "on the fly".

foreach k,v in (conf){ try{ setVar(k,v) }catch{} };

foreach k,v in (vars){ println(k," : ",v) }

{{out}}

<pre>

{{omit from|Lilypond}}

{{omit from|Openscad}}

[[Category:Initialization]]