[iu2] 2007-02-17 In a Python's program I've recently written there is a function that builds the GUI. An annoying thing about that function is that many GUI items and their data counterparts depend on a global application mode, which leads to many '''if'''s. All the ''if'' commands make the code look unreadable and not so maintenance-friendly. 

I thought of a tcl control structure for handling this situation more nicely. The example is the following, rather silly code

  proc operateMode {} {	
    global theMode
  	
    puts {Alway performed}
    if {$theMode eq "mode1"} {
      foreach x {1 2 3} {
        puts "mode1 $x"
      }
    }
  	
    # mode2 or mode3
    if {$theMode in {mode2 mode3}} {
      puts "Mode $theMode!"
      puts "Do something for $theMode"
      if {$theMode eq "mode2"} {
        puts "mode is mode2"
      } else {
        puts "Mode 3 chosen"
      }
    }
  	
    if {$theMode eq "mode4"} {
      puts "Now this is mode 4"
    }
    # end of modes
  }	


Trying it with the following script, let's call it ''run example script'' 

  # run example script
  set allModes {mode1 mode2 mode3 mode4}
  
  foreach theMode $allModes {
    puts "Mode: $theMode"
    operateMode
    puts -----------------
  }

gives

  Mode: mode1
  Alway performed
  mode1 1
  mode1 2
  mode1 3
  -----------------
  Mode: mode2
  Alway performed
  Mode mode2!
  Do something for mode2
  mode is mode2
  -----------------
  Mode: mode3
  Alway performed
  Mode mode3!
  Do something for mode3
  Mode 3 chosen
  -----------------
  Mode: mode4
  Alway performed
  Now this is mode 4
  -----------------  
  
'''With the new control structure''' ''operateMode'' will be written as follows

  proc operateMode {} {	
    modeAware $::theMode $::allModes {
  		
      global theMode
      puts {Alway performed}
      foreach x {1 2 3} {
        puts "mode1 $x"
      } - mode1
  		
      {
        # mode2 or mode3
        puts "Mode $theMode!"
        puts "Do something for $theMode"
        puts "mode is mode2" - mode2
        puts "Mode 3 chosen" - mode3
      } - mode2 mode3
  	
      puts "Now this is mode 4" - mode4
      # end of modes
    }
  }	

which focuses on '''what''' to do rather than on '''when''' to do it.

I wrote the code for ''modeAware'' in stages.

'''1. A little bit shorter structure'''

Defining a new proc "!!" let us rewrite the original opreateMode like this

  proc operateMode {} {	
    global theMode
  	
    !! puts {Alway performed}
    !! mode1 foreach x {1 2 3} {
      puts "mode1 $x"
    }
  	
    # mode2 or mode3
    !! mode2 mode3 {
      puts "Mode $theMode!"
      puts "Do something for $theMode"
      !! mode2 puts "mode is mode2"
      !! mode3 puts "Mode 3 chosen"
    }
  
    !! mode4 puts "Now this is mode 4"
    # end of mode
  }	

where "!!" is defined as an "if" replacement, and it filtes the command given to it according to the modes that appear on the line. 

  proc !! {args} {
    set c -1
    foreach m $args {
      incr c
      if {$m in $::allModes} {lappend chosenModes $m} break
    }
    if {[info exists chosenModes]} {
      if {$::theMode in $chosenModes} {
        set cmd [lrange $args $c end]
  	if {[llength $cmd] == 1} {set cmd [join $cmd]}
  	uplevel 1 $cmd
      }
    } else {
      uplevel 1 $args
    }
  }


and yields the same result upon invoking the ''run example script''.

The proc "!!" already makes the code clearer because it cuts down lines and braces. Actually, I have used a couple of times deidcated short "if" replacements for "if" patterns that occured more than a few times in my code. 


'''2. Shift the condition to the end of the line'''

With "!!" changed to find the modes at the end of each command, 

  package require struct
  proc !! {args} {
    global allModes theMode
    set c [llength $args]
    foreach m [struct::list reverse $args] {
      incr c -1
      if {$m in $allModes} {lappend chosenModes $m} break
    }
  
    if {[info exists chosenModes]} {
      if {$theMode in $chosenModes} {
  	set cmd [lrange $args 0 [expr {$c - 1}]]
  	if {[llength $cmd] == 1} {set cmd [join $cmd]}
  	uplevel 1 $cmd
      }
    } else {  ;# no modes on the line
      uplevel 1 $args
    }
  }

operateMode can be written as

  proc operateMode {} {	
    global theMode
    !! puts {Alway performed}
    !! foreach x {1 2 3} {
      puts "mode1 $x"
    } - mode1

    # mode2 or mode3  	
    !! {
      puts "Mode $theMode!"
      puts "Do something for $theMode"
      !! puts "mode is mode2" - mode2
      !! puts "Mode 3 chosen" - mode3
    } - mode2 mode3
  
    !! puts "Now this is mode 4" - mode4
    # end of mode
  }	

Anything can replace the "-" symbol, except for an empty string..
Also, If a non existing mode appears in the line, an error will occur (however, protecting theMode from being assigned an invalid mode is not handled).

'''3. Removing "!!" altogether'''

The proc ''modeAware'' will take a script and add "!!" for each line, then uplevel it.
Since "!!" will not be written manually anymore, let's just change it to work on a given mode-argument instead of of global mode:

  package require struct
  proc !! {mode allowedModes args} {
    set c [llength $args]
    foreach m [struct::list reverse $args] {
      incr c -1
      if {$m in $allowedModes} {lappend chosenModes $m} break
    }
  	
    if {[info exists chosenModes]} {
      if {$mode in $chosenModes} {
  	set cmd [lrange $args 0 [expr {$c - 1}]]
  	if {[llength $cmd] == 1} {set cmd [join $cmd]}
  	uplevel 1 $cmd
      }
    } else {
      uplevel 1 $args
    }
  }

And this is modeAware

  proc modeAware {mode modes body} {
    set lines [split $body \n]
    set body ""
    set cmd ""
    foreach line $lines {
      if {[string trim $line] ne ""} {
  	if {[regexp -lineanchor {^\s*#} $line]} {		;# a comment - do not add !! command
  	  append body $line\n
  	} else {
    	  append cmd $line
  	  if {[string index $line end] ne "\\"} { ;# handle lines ending with a '\'
    	    append body "!! $mode [list $modes] $cmd\n"
    	    set cmd ""}}}}  ;# a supporting editor would help a lot stuffing those braces...
  
    uplevel 1 $body
  }

which adds "!!" for each line, while not touching comment lines, and considering lines ending with a "\".

Comparing the first version of ''operateMode'' and its final version:

  proc operateMode {} {                           |  proc operateMode {} {	
    global theMode                                |    modeAware $::theMode $::allModes { 
  	                                            |
    puts {Alway performed}                        |      global theMode
    if {$theMode eq "mode1"} {                    |      puts {Alway performed}
      foreach x {1 2 3} {                         |      foreach x {1 2 3} {
        puts "mode1 $x"                           |        puts "mode1 $x"
      }                                           |      } - mode1
    }                                             |
  	                                            |      {
    # mode2 or mode3                              |        # mode2 or mode3
    if {$theMode in {mode2 mode3}} {              |        puts "Mode $theMode!"
      puts "Mode $theMode!"                       |        puts "Do something for $theMode"
      puts "Do something for $theMode"            |        puts "mode is mode2" - mode2
      if {$theMode eq "mode2"} {                  |        puts "Mode 3 chosen" - mode3
        puts "mode is mode2"                      |      } - mode2 mode3
      } else {                                    |
  	puts "Mode 3 chosen"                        |      puts "Now this is mode 4" - mode4
      }                                           |      # end of modes
    }                                             |    }
  	                                            |  }
    if {$theMode eq "mode4"} {                    |
      puts "Now this is mode 4"                   |
    }                                             |
    # end of modes                                |
  }	                                            |
    

With ''modeAware'' I can write the all the operations I need, and then go over the code and just mark the sections that should operate on certain modes.


----
[Category Example] [Category Design]