CODEWITHSUNDEEP
tcl
Stergio
Stergio

Reputation: 13

Manipulating file in tcl language

First time poster and new to TCL so please pardon my knowledge.

I've found a few examples on stackoverflow and with that help created a script.

I need to modify few lines of a file, I've tried the following (see code). I can seem to add the line of interest but it does not write it in the correct location e.g. if I want to replace line 3 it adds line after line 3 and moreover deletes subsequent lines if there is more than one line operation.

Lastly could some one kindly suggest the best way to identify the line of interest with name rather than line number. Name is always in the form Filter.HpOrd_n = where n is 0...k

Data in info.dat

AA
BB
Filter.HpOrd_1 = 2
Filter.HpOrd_2 = 2
Filter.HpOrd_3 = 0.1
Filter.HpOrd_4 = 0.2
CC
DD
EE
FF

Code: 

set fd [open "info.dat" r+]

set i 0
while { [gets $fd line] != -1 } {
    set line [split $line "\n"]
    incr i
    if {$i == 3} {
        set nLine [lreplace $line 0 0 Filter.LoPass]
        puts $fd [join $nLine "\n"]
    }

    if {$i == 6} {
        set nLine [lreplace $line 0 0 Filter.Butterworth]
        puts $fd [join $nLine "\n"]
    }

}   
close $fd

Upvotes: 1

Views: 392

Answers (3)

Peter Lewerin
Peter Lewerin

Reputation: 13282

Plain files (in basically all programming languages) are byte/character oriented rather than line oriented. This means 1) that you need to use a seek operation to get back to the beginning of the line you want to overwrite, and 2) unless the new line is exactly the same length as the old one, you will experience stub lines around it.

You have other problems as well. set line [split $line "\n"] doesn't do anything: you've just read line from gets, so it's guaranteed not to have any newlines in it. [join $nLine "\n"] doesn't do what you probably think it does: it will replace any sequences of whitespace in $line with single newlines, but it will not place any newline at the end of the string.

Unless your files are insanely large, I recommend something like this:

Replace by line number

proc lineReplace args {
    set lines [split [lindex $args end] \n]
    foreach {n line} [lrange $args 0 end-1] {
        set index [incr n -1]
        if {$index > 0} {
            lset lines $index $line
        }
    }
    join $lines \n
}

package require fileutil

fileutil::updateInPlace info.dat {
    lineReplace
    3 Filter.LoPass
    6 Filter.Butterworth
}

In the "front end" you only specify the command to use and thereafter pairs of line number / new line text.

In the "back end" (the lineReplace command) the parameter args will contain those number / line pairs and at the end, as a single item, the complete contents of the file. The file contents are then split into a list of lines, and for every number / line pair you replace one of the items in that list. Finally, the list of lines are joined back into a string with newlines between each line. This string is returned by lineReplace to fileutil::updateInPlace, which replaces the old contents in the file with the returned string.

Replace by name

proc lineReplaceByName args {
    set lines [split [lindex $args end] \n]
    foreach {name line} [lrange $args 0 end-1] {
        set index [lsearch $lines $name*]
        if {$index > 0} {
            lset lines $index $line
        }
    }
    join $lines \n
}

fileutil::updateInPlace info.dat {
    lineReplaceByName
    Filter.HpOrd_1 Filter.LoPass
    Filter.HpOrd_4 Filter.Butterworth
}

In this case the "back end" calculates the line number by searching for the given name at the beginning of each line. If the name isn't found, the replacement operation is skipped. Otherwise it's the same as before.

Replacing just the name

If you don't want to replace the complete line, but just the name part of it, some changes are necessary. If you are 100% sure that 1) the name never has any whitespace in it, and 2) there is always whitespace between the name and the =, you can just replace lset lines $index $line with lset lines $index 0 $line. If you want to play it safer, you can replace the line with

lset lines $index [regsub {.+(?=\s*=\s*)} [lindex $lines $index] $line]

which uses a regular expression to find the character region that precedes the = character (optionally with whitespace around it) and then replaces that with the text you provided.

The fileutil package is a part of the Tcllib companion library to Tcl.

Documentation: fileutil package, foreach, if, incr, join, lindex, lrange, lsearch, lset, package, proc, regsub, seek, set, split

Upvotes: 0

glenn jackman
glenn jackman

Reputation: 247202

With plain Tcl:

# the input and output file handles
set fin [open info.dat r]
set fout [file tempfile fname]

# process the file
while {[gets $fin line] != -1} {
    puts $fout [string map {
        "Filter.HpOrd_1" "Filter.LoPass"
        "Filter.HpOrd_4" "Filter.Butterworth"
    } $line]
}

close $fin
close $fout

# backup the original and overwrite it
file link -hard info.dat.bak info.dat
file rename -force -- $fname info.dat

Upvotes: 1

ikrabbe
ikrabbe

Reputation: 1929

TCL is just a meta language and set fd [open "info.dat" r+] is related to general file descriptor handling. If you open a file descriptor "r+" you can read and write to that file descriptor, but one file descriptor always points to one point in a file.

With "r+" your file descriptor initially points to the start of the file. Then you gets $fd line a line from the file, so $fd points to the start of the second line afterwards. Now you puts $fs [join $nline "\n"] blindly overwriting from the start of the second line and so on.

Generally you cannot replace lines in one file, but you will write a second file and move that after you closed both files. You can overwrite with seek, but you overwrite from a point in the file. So what you put should always have the same size, of you have read before.

Upvotes: 0

Related Questions