TCL: Make code cleaner from nested if-statements - if-statement

Question

This is a procedure of one of the items of the status bar on i3 window manager on linux. Is run every second. Basically deals with frequency governors. If temperature reaches a certain number then switch to powersave mode, or if a certain application is running, e.g. steam, or the laptop is running on batteries. If temperature reaches a lower point then it will switch to performance, etc.
The procedure runs very well so far, no issues. However the code has so many nested if-else statements, that it hard to maintain and everytime I add something the code becomes more, well.... nested.
proc cpu_freq {} {
set app steam
set cpu_power [exec sudo cpupower frequency-info | sed -ne /speed/p]
set cpu_temp [exec sensors | grep Core | sed -n {2p} | awk {{print $3}} | cut -c2-3]
set battery [exec acpi]
if {[string match *performance* $cpu_power]} {set cpu_freq HIGH; set color "$::green"}
if {[string match *powersave* $cpu_power]} {set cpu_freq LOW; set color "$::red"}
if {![file isfile $::i3dir/powersave.freq] && ![file isfile $::i3dir/performance.freq]} {
set switch AUTO
}
# ON BATTERY
if {[string match *Discharging* $battery]} {
# WHEN IN PERFORMANCE MODE
if {[string match *performance* $cpu_power]} {
if {![file isfile $::i3dir/performance.freq]} {
# AND NOT IN MANUAL
# SWITCH TO POWERSAVE
exec sudo cpupower frequency-set -g powersave
set cpu_freq LOW
set switch AUTO
set color "$::red"
set ::on_battery true
} else {
# SWITCH TO MANUAL PERFORMANCE MODE
if {[file isfile $::i3dir/performance.freq]} {
exec sudo cpupower frequency-set -g performance
set cpu_freq HIGH
set switch MAN
set color "$::green"
set ::on_battery true
} else {
if {[file isfile $::i3dir/powersave.freq]} {
# SWITCH TO MANUAL POWERSAVE MODE
exec sudo cpupower frequency-set -g powersave
set cpu_freq LOW
set switch MAN
set color "$::red"
set ::on_battery true
}
}
}
} else {
# WHEN IN POWERSAVE MODE (AUTO)
# SWITCH TO MANUAL POWERSAVE
if {[string match *powersave* $cpu_power]} {
if {[file isfile $::i3dir/powersave.freq]} {
exec sudo cpupower frequency-set -g powersave
set cpu_freq LOW
set switch MAN
set color "$::red"
set ::on_battery true
} else {
# SWITCH TO MANUAL PERFORMANCE
if {[file isfile $::i3dir/performance.freq]} {
exec sudo cpupower frequency-set -g performance
set cpu_freq HIGH
set switch MAN
set color "$::green"
set ::on_battery true
}
}
}
}
# ON MAINS
} else {
# WHEN IN POWERSAVE MODE
if {[string match *powersave* $cpu_power]} {
# RUNNING APP OR MANUAL SWITCH
if {[file isfile $::i3dir/powersave.freq]} {
set cpu_freq LOW
set switch MAN
} else {
if {[isRunning $app]} {
set cpu_freq LOW
set switch AUTO
# DO NOTHING, KEEP RUNNING IN POWERSAVE MODE
} else {
# SWITCH TO PERFORMANCE AFTER RUNNING ON BATTERIES
if {$::on_battery==true} {
exec sudo cpupower frequency-set -g performance
set cpu_freq HIGH
set switch AUTO
set color "$::green"
set ::on_battery false
# SWITCH TO PERFORMANCE WHEN REACHING LOWER TEMPS
} elseif {$cpu_temp <= 55} {
exec sudo cpupower frequency-set -g performance
set cpu_freq HIGH
set switch AUTO
set color "$::green"
}
}
}
# WHEN IN PERFORMANCE MODE
} else {
# MANUAL SWITCH
if {[file isfile $::i3dir/performance.freq]} {
set switch MAN
set cpu_freq HIGH
# DO NOTHING, KEEP RUNNING IN PERFORMANCE MODE
} else {
# HOT TEMPERATURE OR RUNNING APP
# SWITCH TO POWERSAVE
if {$cpu_temp >= 75 || [isRunning $app] } {
exec sudo cpupower frequency-set -g powersave
set cpu_freq LOW
set switch AUTO
set color "$::red"
} else {
set cpu_freq HIGH
set switch AUTO
}
}
}
}
set stdout {{"name":"cpu_freq","full_text":"$switch:$cpu_freq","color":"$color"}}
set stdout [subst -nocommands $stdout]
puts -nonewline $stdout
}

Answer 1

Break it up into a set of functions.
Tcl has a switch statement which can sometimes help. It also has elseif to assist in reducing nesting. But in the code shown, break it into functions with sensible names and you can reduce it to one function that deals with the logic and a collection that deal with what happens in a certain case.

Answer 2

When I see something like this I immediately think about finite state machines/state transition diagrams. You have a starting state and you then switch to other states based on the results of the procs that you call in the if statements, at some point you reach an end state from which no further transitions are possible.
So I'd look at restructuring to something like the following example:
# The value to process
set value "This is a big red ball"
# The starting state
set state 1
# The state transtions and the functions to implement them
set states [dict create "1,3" "IsRed" "1,2" "IsBlue" "2,4" "IsBig" "2,5" "IsSmall" "3,4" "IsBig" "3,5" "IsSmall"]
# Procs that implement the state transitions
proc IsRed {next} {
global value state
if {[string first "red" $value] != -1} {
puts "red"
set state $next
return true
}
return false
}
proc IsBlue {next} {
global value state
if {[string first "blue" $value] != -1} {
puts "blue"
set state $next
return true
}
return false
}
proc IsSmall {next} {
global value state
if {[string first "small" $value] != -1} {
puts "small"
set state $next
return true
}
return false
}
proc IsBig {next} {
global value state
if {[string first "big" $value] != -1} {
puts "big"
set state $next
return true
}
return false
}
# Proc to run the state machine until the state stops changing
proc runMachine { states } {
global state
set startState -1
while { $state != $startState } {
set startState $state
foreach key [dict keys $states "$state,*"] {
set next [lindex [split $key ","] 1]
set res [[dict get $states $key] $next]
# If the state changes then no need to do any more processing
if { $res == true } {
break
}
}
}
}
runMachine $states
This is one possible approach and it's much simpler than what you need to do but shows the basic idea. The dictionary shows the allowed state transitions and the proc to run in order to test if the transition is allowed. I've put my processing code (the puts statement) in this function but it would be simple to have another function do the processing, either called directly or held as another value in the dictionary and called from the runMachine proc.
set states [dict create 21,3" [list "IsRed" "RedAction"]]
This approach lets you seperate all the actions and transitions out and draw a state transition diagram that clearly shows what's going on.
A quick google for TCL Finite State Machine shows lots of other ways to implement this idea.

Answer 3

Breaking the code up into separate functions as suggested by patthoyts is a good solution but might possibly be somewhat slower (it's unlikely that you'll notice, however). Another solution to make the code easier to work with is to dynamically create cpu_freq during startup.
To do this, write a script that is as verbose and with as much documentation as you want, which produces the succinct and efficient body that you want for cpu_freq. When you need to extend it, you just add more sections to the script. Call proc with the produced body as third argument, and it will be compiled the first time it is called.