I often run into syntactic prejudice when I am
writing software to spec.  This often seems to
preclude using Tcl, which, of course, tends to
bloat the amount of work and the time and money
needed to accomplish it.  Eventually, however,
I came up with the "run" command - it's a replacement
for "source" but it does some extensive preprocessing
before running the code, allowing some really radical
language changes without any run-time overhead.

run.tcl:

 proc run { filename { macrolist "" } } {
   if { "$macrolist" != "" } {
     upvar $macrolist macros
   }
   if [catch { set f [ open $filename r ] } err ] { return -code $err }
   set src [ read $f ]
   foreach key [array names macros] {
     regsub -all $key $src $macros($key) src
   }
   set exp ""
   while 1 {
     if [regexp "(.*)(<<<.*>>>)(.*)" $src -> head exp tail] {
       regsub <<< $exp "" exp
       regsub >>> $exp "" exp
       set result [ uplevel eval $exp ]
       set src "$head$result$tail"
     } else {
       break
     }
   }
   # puts $src ;# uncomment to see translation
   uplevel eval $src
 }

Now, suppose we wish to add some syntactic sugar
to expr, and to have an input language looking like
Oberon or Modula.  We code this:

 source run.tcl

 proc compute { args } {
   set exp ""
   set id ""
   regsub "''" [ string trim $args ] "@@@" args
   while 1 {
     regexp "(\[^a-zA-Z_'\]*)(\[a-zA-Z0-9_'\]*)(.*)" $args -> head id tail
     if ![ string length $id ] {
       set exp "$exp$head"
       break
     }
     set dollar ""
     if ![ string equal [ string index $id 0 ] "'" ] {
       if ![ string equal [info commands $id] "" ] {
         set id "\[ $id"
         regexp {[^\(]*\(([^\)]*)\)(.*)} $tail -> params tail
         set tail " $params \]$tail"
       } else { set dollar "\$" }
     }
     append exp "$head$dollar$id"
     set args $tail
   }
   regsub -all "'" $exp "\"" exp
   set map "@@@ ' and && or || not ! <> != true 1 false 0 on 1 off 0 yes 1 no 0 pi 3.1415926535"
   foreach { from to } $map {
     regsub $from $exp $to exp
   }
   set exp [ uplevel subst -novariable \{$exp\} ]
   return "\{ $exp \}"
 }

 set xlate(IF) "if <<< compute "
 set xlate(THEN) ">>> \{""
 set xlate(ELSE) "\} else \{"
 set xlate(ELSIF) "\} elseif \[ compute "
 set xlate(END) "\}"
 set xlate(WHILE) "while \{ \[ compute "
 set xlate(DO) "\] \} \{"

"compute" is a macro that handles the translation
of "expr", and "xlate" is a simple textual substitution
table.  Now we can take the file "foo.tcl":

# basic tcl syntax is still there:
 set x 1

 # So is new modula-style
 IF x <> 1 THEN
   puts "x is NOT 1"
 ELSE
   puts "x IS 1"
 END

and run it from a tcl script:

 run foo.tcl xlate

and what is actually sourced is:

 set x 1

 if { $x != 1 } {
   puts "x is NOT 1"
 } else {
   puts "x IS 1"
 }