Update a configuration file: Difference between revisions

* [[Read a configuration file]]

<br><br>

 

=={{header|AutoHotkey}}==

data = %A_scriptdir%\rosettaconfig.txt

outdata = %A_scriptdir%\rosettaconfig.tmp

}

 

 

=={{header|BASIC}}==

 

This program is not tied to the task requested, but it can read and modify ANY configuration file. It is somewhat long, but includes functionality to modify or add variables and values to the configuration file, append remarks (#) to it, read and save values in an array (comma separated), toggle comment mode for variables in a configuration file, etc. It is even longer because is almost fully commented and in key procedures every parameter is explained. It includes a main program cycle to read the configuration file and modify its values.

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

' Read a Configuration File V1.0 '

YorN$ = sYorN

END FUNCTION

 

In the following example, the user can modify the variables, their comment status and add the NUMBEROFSTRAWBERRIES variable with the value of 64000. In this case, the user is modifying the value of the NUMBEROFBANANAS variable in the configuration file.

C with POSIX <code>strcasecmp</code> function for case-insensitive comparing. Substitute your toolchain's version.

 

#include <stdlib.h>

#include <string.h>

{ fprintf(stderr, "failed\n");

return (EXIT_FAILURE); }

 

Run:

=={{header|D}}==

This type of file is really not very suitable for automated management, so this code is very basic.

std.typecons;

 

cfg.addOption("numberofstrawberries", "62000");

cfg.store();

Input file:

<pre># This is a configuration file in standard configuration file format

{{libheader| uSettings}}

Requere '''uSettings.pas''' found in [[Read_a_configuration_file#Delphi]].

program uConfigFile;

 

Settings.Free;

Readln;

{{out}}

<pre> FAVOURITEFRUIT = banana

=={{header|Erlang}}==

Given the large number of very exact rules governing the update of this configuration file it is with some pleasure I add new options to the beginning of the file.

-module( update_configuration_file ).

 

[Option | T] = string:tokens( String, " " ),

string:join( [string:to_upper(Option) | T], " " ).

{{out}}

<pre>

 

=={{header|Fortran}}==

CHARACTER*28 FAVOURITEFRUIT

LOGICAL NEEDSPEELING

READ (F,FRUIT) !Read who knows what.

WRITE (6,FRUIT)

Most of which is support stuff. The requirement is to declare a NAMELIST naming the variables of interest, then READ or WRITE using just the name of the NAMELIST. Only three statements, four if the file OPEN is counted.

 

In a more general situation, it is helpful to have a routine that reads the NAMELIST style input and isolates the assignments so that each can individually be written to a scratch file in the NAMELIST style (i.e. providing the block head and tail lines, though some Fortrans allow NAMELIST input from a text variable and without this requirement) whereupon if ERR is provoked during the READ, the troublesome entry can be displayed for user appreciation before continuing with any remaining assignments.

 

INTEGER FIELD !An I/O unit number.

CHARACTER*28 FAVOURITEFRUIT

CALL GETVALS("Basket.txt") !Read the values, allowing for the previous version.

CALL PUTVALS("Basket.txt") !Save the values, as per the new version.

Whereupon the file now has

<pre>

 

=={{header|FreeBASIC}}==

 

Type ConfigData

Print

Print "Press any key to quit"

 

The contents of config2.txt after updating are:

 

=={{header|Go}}==

 

import (

c.Set("NUMBEROFSTRAWBERRIES", "62000")

c.Write(os.Stdout)

 

=={{header|Haskell}}==

Necessary imports

 

 

Definition of datatypes:

 

 

data Entry = Comment String

f : v -> field f (unwords v)

field f = Field (toUpper <$> f)

 

Getting and setting fields in INI data:

 

setValue f v = INI . replaceOn (eqv f) (Field f v) . entries

 

(prev,post) = case break p lst of

(lst, []) -> (lst, [])

 

IO stuff:

 

readIni file = INI . map read . lines <$> S.readFile file

 

enable "SeedsRemoved" .

setValue "NumberOfBananas" "1024" .

 

=={{header|J}}==

Since the task does not specify the line end character, we assume that the last character in the file is the line end character.

 

 

normalize=:3 :0

upd=. y,' ',":x

(<m) 1!:2~ normalize (,upd,{:);<@rxrplc~&(pat;upd) t

 

Note that, aside from the line end issue, the task is ambiguous because it specifies a set of operations rather than a file format. If the consequences of these ambiguities are troubling, you might prefer to replace normalize with normalize^:_

Example use:

 

'example.file' enable 'seedsremoved'

1024 'example.file' set 'numberofbananas'

 

Here's how the file specified in the task description looks after these steps have been executed:

{{trans|D}}

{{works with|Java|7}}

import java.util.*;

import java.util.regex.*;

}

}

 

Input file:

=={{header|Julia}}==

Designed similarly to the way multiple small functions in a Julia module for general editing of this file type might be written.

line = strip(line)

if line == ""

end

end

Contents of the revised file:

# This is a configuration file in standard configuration file format

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

import java.io.File

val cData = ConfigData("banana", false, true, 1024, 62000)

updateConfigFile(fileName, cData)

 

Contents of file 'config.txt' after updating:

=={{header|Lasso}}==

Config type definition

 

define config => type {

}

 

 

How to call it:

local(

config = config,

#config -> set('numberofbananas', 1024)

 

 

Initial config file:

NUMBEROFSTRAWBERRIES 62000

</pre>

 

=={{header|Perl}}==

 

use strict;

 

 

# How many bananas we have

 

=={{header|Phix}}==

Very basic (and contains most of the code from the read configuration file example)<br>

Note in particular there is no real attempt to distinguish between booleans and integers.

Resulting RCTEST.INI file:

<pre>

=={{header|PHP}}==

 

 

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

}

 

 

{{in}}

 

=={{header|PicoLisp}}==

(in "config"

(make

(out "config"

(for L Data

 

=={{header|PowerShell}}==

function Update-ConfigurationFile

{

}

}

Update-ConfigurationFile -NumberOfStrawberries 62000 -NumberOfBananas 1024 -SeedsRemoved On -NeedsPeeling Off

 

Invoke-Item -Path ".\config.txt"

{{Out}}

<pre>

 

=={{header|Python}}==

 

#----------------------------------------------------------------------------

cfg.enable_option('numberofstrawberries', 62000)

print cfg

 

Output:

Use the shared <tt>[[Racket/Options|options.rkt]]</tt> code.

 

#lang racket

 

;; numberofstrawberries with a value of 62000

(set! numberofstrawberries 62000)

 

=={{header|Raku}}==

The script:

 

 

my ($tmpfile, $out) = tempfile;

sub format-line ($key, $value, $enabled) {

("; " if !$enabled) ~ $key.uc ~ (" $value" if defined $value);

 

=={{header|REXX}}==

 

Programming note: &nbsp; not all REXXes support the closing of files using the &nbsp; '''lineout''' &nbsp; BIF with a single argument.

parse arg iFID oFID . /*obtain optional arguments from the CL*/

if iFID=='' | iFID=="," then iFID= 'UPDATECF.TXT' /*Not given? Then use default.*/

cpy: call lineout oFID, arg(1); return /*write one line of text ───► oFID. */

dos: ''arg(1) word(arg(2) "2>nul",1); return /*execute a DOS command (quietly). */

'''output''' &nbsp; when using the default input file (which has additional removable statements) and input options:

<pre>

 

===version 2===

oid='updatecf.xxx'; 'erase' oid

options=translate('FAVOURITEFRUIT NEEDSPEELING SEEDSREMOVED NUMBEROFBANANAS numberofstrawberries')

done.option=1

End

{{out}}

same as for solution 'D'

 

=={{header|Ruby}}==

 

class ConfigFile

 

# How many bananas we have

outputs

<pre># This is a configuration file in standard configuration file format

=={{header|Tcl}}==

Creating this to be a general solution:

oo::class create Config {

variable filename contents

}

}

Applying to the task at hand (assuming a file in the current directory called <tt>sample.cfg</tt>):

$cfg disable needspeeling

$cfg enable seedsremoved

$cfg set numberofbananas 1024

$cfg set numberofstrawberries 62000

 

=={{header|TXR}}==

This works by reading the configuration into a variable, and then making multiple passes over it, using the same constructs that normally operate on files or pipes. The first 30% of the script deals with reading the configuration file and parsing each command line argument, and converting its syntax into configuration syntax, stored in <code>new_opt_line</code>. For each argument, the configuration is then scanned and filtered from <code>config</code> to <code>new_config</code>, using the same syntax which could be used to do the same job with temporary files. When the interesting variable is encountered in the config, using one of the applicable pattern matches, then the prepared configuration line is substituted for it. While this is going on, the encountered variable names (bindings for <code>var_other</code>) are also being collected into a list. This list is then later used to check via the directive <code>@(bind opt_there option)</code> to determine whether the option occurred in the configuration or not. The bind construct will not only check whether the left and right hand side are equal, but if nested lists are involved, it checks whether either side occurs in the other as a subtree. <code>option</code> binds with <code>opt_other</code> if it matches one of the option names in <code>opt_other</code>. Finally, the updated config is regurgitated.

 

@configfile

@(maybe)

@config

@ (end)

 

Sample invocation:

 

=={{header|VBScript}}==

Set objFSO = CreateObject("Scripting.FileSystemObject")

 

Set objFSO = Nothing

Set objParamLookup = Nothing

 

{{In}}

 

{{Out}}

<pre>

# This is a configuration file in standard configuration file format