diff --git a/tools/dependencies.tcl b/tools/dependencies.tcl
index f1f3016..eabd751 100755
--- a/tools/dependencies.tcl
+++ b/tools/dependencies.tcl
@@ -40,22 +40,22 @@ source [file join [file dirname [info script]] failcache.tcl]
 
 set failcache_dir ""
 set logs_dir ""
-while {[string range [lindex $::argv 0] 0 1] eq "--"} {
-    switch -- [lindex $::argv 0] {
+while {[string range [lindex $argv 0] 0 1] eq "--"} {
+    switch -- [lindex $argv 0] {
         --failcache_dir {
-            set failcache_dir [lindex $::argv 1]
-            set ::argv [lreplace $::argv 0 0]
+            set failcache_dir [lindex $argv 1]
+            set argv [lreplace $argv 0 0]
         }
         --logs_dir {
-            set logs_dir [lindex $::argv 1]
-            set ::argv [lreplace $::argv 0 0]
+            set logs_dir [lindex $argv 1]
+            set argv [lreplace $argv 0 0]
         }
         default {
-            ui_error "unknown option: [lindex $::argv 0]"
+            ui_error "unknown option: [lindex $argv 0]"
             exit 2
         }
     }
-    set ::argv [lreplace $::argv 0 0]
+    set argv [lreplace $argv 0 0]
 }
 
 if {$logs_dir ne ""} {
@@ -66,7 +66,7 @@ if {$logs_dir ne ""} {
     set log_subports_progress $log_status_dependencies
 }
 
-if {[llength $::argv] == 0} {
+if {[llength $argv] == 0} {
     puts stderr "Usage: $argv0 <portname> \[(+|-)variant...\]"
     exit 2
 }
@@ -80,7 +80,7 @@ if {[catch {mportinit "" my_global_options ""} result]} {
 }
 
 # look up the path of the Portfile for the given port
-set portname [lindex $::argv 0]
+set portname [lindex $argv 0]
 #try -pass_signal {...}
 try {
     set result [mportlookup $portname]
@@ -95,7 +95,7 @@ try {
 
 # parse the given variants from the command line
 set variants [dict create]
-foreach item [lrange $::argv 1 end] {
+foreach item [lrange $argv 1 end] {
     foreach {_ sign variant} [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $item] {
         dict set variants $variant $sign
     }
@@ -115,7 +115,7 @@ set portinfo [dict merge $portinfo [mportinfo $mport]]
 # Also checking for matching archive, in case supported_archs changed
 if {[registry::entry imaged $portname [dict get $portinfo version] [dict get $portinfo revision] [dict get $portinfo canonical_active_variants]] ne ""
         && [[ditem_key $mport workername] eval [list _archive_available]]} {
-    puts "$::argv already installed, not installing or activating dependencies"
+    puts "$argv already installed, not installing or activating dependencies"
     exit 0
 }
 # Ensure build-time deps are always included for the top-level port,
@@ -126,14 +126,11 @@ if {[registry::entry imaged $portname [dict get $portinfo version] [dict get $po
 # buildbot will exclude ports that have an archive deployed.
 [ditem_key $mport workername] eval [list set portutil::archive_available_result 0]
 
-set toplevel_depstypes [list depends_fetch depends_extract depends_patch depends_build depends_lib depends_run]
-set recursive_depstypes [list depends_lib depends_run]
 foreach p [split $env(PATH) :] {
     if {![string match ${macports::prefix}* $p]} {
         lappend bin_search_path $p
     }
 }
-set lib_search_path [list /Library/Frameworks /System/Library/Frameworks /lib /usr/lib]
 
 # check if depspec is fulfilled by a port, and if so, append its
 # name to the variable named by retvar
@@ -144,12 +141,13 @@ proc check_dep_needs_port {depspec retvar} {
     set depregex [lindex $splitlist 1]
     switch [lindex $splitlist 0] {
         bin {
+            global bin_search_path
             set depregex \^$depregex\$
-            set search_path $::bin_search_path
+            set search_path $bin_search_path
             set executable 1
         }
         lib {
-            set search_path $::lib_search_path
+            set search_path {/Library/Frameworks /System/Library/Frameworks /lib /usr/lib}
             set i [string first . $depregex]
             if {$i < 0} {set i [string length $depregex]}
             set depname [string range $depregex 0 ${i}-1]
@@ -184,7 +182,8 @@ proc check_dep_needs_port {depspec retvar} {
 # Get the ports needed by a given port.
 proc collect_deps {portinfo retvar} {
     upvar $retvar ret
-    foreach deptype $::recursive_depstypes {
+    # Recursive deps are not being built, so only their runtime deps are needed.
+    foreach deptype {depends_lib depends_run} {
         if {[dict exists $portinfo $deptype]} {
             foreach depspec [dict get $portinfo $deptype] {
                 check_dep_needs_port $depspec ret
@@ -237,8 +236,9 @@ proc open_port {portname} {
     }
 
     set portinfo [dict merge $portinfo [mportinfo $mport]]
-    if {![dict exists $::mportinfo_array $mport]} {
-        dict set ::mportinfo_array $mport $portinfo
+    global mportinfo_array
+    if {![dict exists $mportinfo_array $mport]} {
+        dict set mportinfo_array $mport $portinfo
     }
     return [list $mport $portinfo]
 }
@@ -262,12 +262,14 @@ proc deactivate_with_dependents {e} {
 }
 
 proc deactivate_unneeded {portinfo} {
+    global mportinfo_array
     # Unfortunately mportdepends doesn't have quite the right semantics
     # to be useful here. It's concerned with what is needed and not
     # present, whereas here we're concerned with removing what we can do
     # without. Future API opportunity?
     set deplist [list]
-    foreach deptype $::toplevel_depstypes {
+    # The top level port is being built, so all build time and run time deps are needed.
+    foreach deptype {depends_fetch depends_extract depends_patch depends_build depends_lib depends_run} {
         if {[dict exists $portinfo $deptype]} {
             foreach depspec [dict get $portinfo $deptype] {
                 check_dep_needs_port $depspec deplist
@@ -304,7 +306,7 @@ proc deactivate_unneeded {portinfo} {
         if {![dict exists $needed_array [$e name]]} {
             deactivate_with_dependents $e
         } else {
-            set entryinfo [dict get $::mportinfo_array [dict get $mports_array [$e name]]]
+            set entryinfo [dict get $mportinfo_array [dict get $mports_array [$e name]]]
             if {[dict get $entryinfo version] ne [$e version]
                     || [dict get $entryinfo revision] != [$e revision]
                     || [dict get $entryinfo canonical_active_variants] ne [$e variants]} {
@@ -355,8 +357,9 @@ if {[catch {mportdepends $mport "activate" 1 1 0 dlist} result]} {
 
 
 proc append_it {ditem} {
-    lappend ::dlist_sorted $ditem
-    dict set ::mportinfo_array $ditem [mportinfo $ditem]
+    global dlist_sorted mportinfo_array
+    lappend dlist_sorted $ditem
+    dict set mportinfo_array $ditem [mportinfo $ditem]
     return 0
 }
 try {
@@ -387,7 +390,8 @@ puts $log_status_dependencies ""
 
 ## ensure dependencies are installed and active
 proc checkdep_failcache {ditem} {
-    set depinfo [dict get $::mportinfo_array $ditem]
+    global mportinfo_array
+    set depinfo [dict get $mportinfo_array $ditem]
 
     if {[check_failcache [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants]]} {
         tee "Dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' has previously failed and is required." $::log_status_dependencies stderr
@@ -414,7 +418,8 @@ if {$failcache_dir ne ""} {
 # clean up any work directories left over from earlier
 # (avoids possible errors with different variants in the statefile)
 proc clean_workdirs {} {
-    set build_dir [file join $macports::portdbpath build]
+    global macports::portdbpath
+    set build_dir [file join $portdbpath build]
     foreach dir [glob -nocomplain -directory $build_dir *] {
         file delete -force -- $dir
     }
@@ -422,14 +427,16 @@ proc clean_workdirs {} {
 
 # Returns 0 if dep is installed, 1 if not
 proc install_dep_archive {ditem} {
-    set depinfo [dict get $::mportinfo_array $ditem]
-    incr ::dependencies_counter
-    set msg "Installing dependency ($::dependencies_counter of $::dependencies_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
-    puts -nonewline $::log_status_dependencies "$msg ... "
+    global mportinfo_array dependencies_counter dependencies_count \
+           log_status_dependencies
+    set depinfo [dict get $mportinfo_array $ditem]
+    incr dependencies_counter
+    set msg "Installing dependency ($dependencies_counter of $dependencies_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
+    puts -nonewline $log_status_dependencies "$msg ... "
     puts "----> ${msg}"
     if {[registry::entry imaged [dict get $depinfo name] [dict get $depinfo version] [dict get $depinfo revision] [dict get $depinfo canonical_active_variants]] ne ""} {
         puts "Already installed, nothing to do"
-        puts $::log_status_dependencies {[OK]}
+        puts $log_status_dependencies {[OK]}
         return 0
     }
     clean_workdirs
@@ -447,13 +454,13 @@ proc install_dep_archive {ditem} {
         # it's quick and easy to check and may save a build.
         if {[dict exists $depinfo known_fail] && [string is true -strict [dict get $depinfo known_fail]]} {
             puts stderr "Dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' is known to fail, aborting."
-            puts $::log_status_dependencies {[FAIL] (known_fail)}
+            puts $log_status_dependencies {[FAIL] (known_fail)}
             puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (dependency '[dict get $depinfo name]' known to fail) maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
             exit 1
         }
         # This dep will have to be built, not just installed
         puts stderr "Fetching archive for dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed."
-        puts $::log_status_dependencies {[MISSING]}
+        puts $log_status_dependencies {[MISSING]}
         return 1
     }
     # Now install it
@@ -464,29 +471,32 @@ proc install_dep_archive {ditem} {
     }
     if {$fail || $result > 0} {
         puts stderr "Installing from archive for dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
-        puts $::log_status_dependencies {[FAIL]}
-        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '$depinfo(name)')."
+        puts $log_status_dependencies {[FAIL]}
+        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '[dict get $depinfo name]')."
         exit 1
     }
 
-    puts $::log_status_dependencies {[OK]}
+    puts $log_status_dependencies {[OK]}
     return 0
 }
 
 # mportexec uses this global variable, so we have to clean up between
 # doing operations (that require deps) on different ports.
 proc close_open_mports {} {
-    foreach mport $macports::open_mports {
+    global macports::open_mports
+    foreach mport $open_mports {
         catch {ditem_key $mport refcnt 1}
         catch {mportclose $mport}
     }
-    set macports::open_mports [list]
+    set open_mports [list]
 }
 
 proc install_dep_source {depinfo} {
-    incr ::build_counter
-    set msg "Building dependency ($::build_counter of $::build_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
-    puts -nonewline $::log_status_dependencies "$msg ... "
+    global build_counter build_count log_status_dependencies \
+           mportinfo_array failcache_dir
+    incr build_counter
+    set msg "Building dependency ($build_counter of $build_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
+    puts -nonewline $log_status_dependencies "$msg ... "
     puts "----> ${msg}"
 
     # Be quiet during the prep operations
@@ -494,7 +504,7 @@ proc install_dep_source {depinfo} {
     set macports::channels(info) {}
     close_open_mports
     clean_workdirs
-    set ::mportinfo_array [dict create]
+    set mportinfo_array [dict create]
     set ditem [lindex [open_port [dict get $depinfo name]] 0]
     # Ensure archivefetch is not attempted at all
     set workername [ditem_key $ditem workername]
@@ -521,7 +531,7 @@ proc install_dep_source {depinfo} {
     }
     if {$fail || $result > 0} {
         puts stderr "Fetch of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
-        puts $::log_status_dependencies {[FAIL] (fetch)}
+        puts $log_status_dependencies {[FAIL] (fetch)}
         puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to fetch dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
         exit 1
     }
@@ -532,7 +542,7 @@ proc install_dep_source {depinfo} {
     }
     if {$fail || $result > 0} {
         puts stderr "Checksum of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
-        puts $::log_status_dependencies {[FAIL] (checksum)}
+        puts $log_status_dependencies {[FAIL] (checksum)}
         puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to checksum dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
         exit 1
     }
@@ -545,24 +555,24 @@ proc install_dep_source {depinfo} {
     }
     if {$fail || $result > 0} {
         puts stderr "Build of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
-        puts $::log_status_dependencies {[FAIL]}
+        puts $log_status_dependencies {[FAIL]}
         puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
 
-        if {$::failcache_dir ne ""} {
+        if {$failcache_dir ne ""} {
             failcache_update [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] 1
         }
-        ui_debug "Open mports:"
-        foreach mport $macports::open_mports {
-            ui_debug [ditem_key $ditem]
-        }
+        #ui_debug "Open mports:"
+        #foreach mport $macports::open_mports {
+        #    ui_debug [ditem_key $ditem]
+        #}
         exit 1
     }
 
     # Success. Clear any failcache entry.
-    if {$::failcache_dir ne ""} {
+    if {$failcache_dir ne ""} {
         failcache_update [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] 0
     }
-    puts $::log_status_dependencies {[OK]}
+    puts $log_status_dependencies {[OK]}
 }
 
 # Show all output for anything that gets installed
@@ -573,7 +583,7 @@ set missing_deps [list]
 try {
     foreach ditem $dlist_sorted {
         if {[install_dep_archive $ditem]} {
-            lappend missing_deps [dict get $::mportinfo_array $ditem]
+            lappend missing_deps [dict get $mportinfo_array $ditem]
         }
     }
 } on error {eMessage} {
@@ -605,7 +615,7 @@ if {$build_count > 0} {
     set macports::channels(debug) {}
     set macports::channels(info) {}
     close_open_mports
-    set ::mportinfo_array [dict create]
+    set mportinfo_array [dict create]
     try {
         set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variants]
     } on error {eMessage} {
diff --git a/tools/failcache.tcl b/tools/failcache.tcl
index 3585cb5..7d91387 100644
--- a/tools/failcache.tcl
+++ b/tools/failcache.tcl
@@ -25,13 +25,14 @@ proc port_files_checksum {porturl} {
 }
 
 proc check_failcache {portname porturl canonical_variants {return_contents no}} {
+    global failcache_dir
     set hash [port_files_checksum $porturl]
     set key "$portname $canonical_variants $hash"
     set ret 0
-    foreach f [glob -directory $::failcache_dir -nocomplain -tails "${portname} *"] {
+    foreach f [glob -directory $failcache_dir -nocomplain -tails "${portname} *"] {
         if {$f eq $key} {
             if {$return_contents} {
-                set fd [open [file join $::failcache_dir $f] r]
+                set fd [open [file join $failcache_dir $f] r]
                 set line [gets $fd]
                 close $fd
                 return $line
@@ -39,22 +40,24 @@ proc check_failcache {portname porturl canonical_variants {return_contents no}}
             set ret 1
         } elseif {[lindex [split $f " "] end] ne $hash} {
             puts stderr "removing stale failcache entry: $f"
-            file delete -force [file join $::failcache_dir $f]
+            file delete -force [file join $failcache_dir $f]
         }
     }
     return $ret
 }
 
 proc failcache_update {portname porturl canonical_variants failed} {
+    global failcache_dir
     set hash [port_files_checksum $porturl]
-    set entry_path [file join $::failcache_dir "$portname $canonical_variants $hash"]
+    set entry_path [file join $failcache_dir "$portname $canonical_variants $hash"]
     if {$failed} {
-        file mkdir $::failcache_dir
+        global env failcache_buildurl
+        file mkdir $failcache_dir
         set fd [open $entry_path w]
-        if {[info exists ::env(BUILDBOT_BUILDURL)]} {
-            puts $fd $::env(BUILDBOT_BUILDURL)
-        } elseif {[info exists ::failcache_buildurl]} {
-            puts $fd $::failcache_buildurl
+        if {[info exists env(BUILDBOT_BUILDURL)]} {
+            puts $fd $env(BUILDBOT_BUILDURL)
+        } elseif {[info exists failcache_buildurl]} {
+            puts $fd $failcache_buildurl
         } else {
             puts $fd "unknown"
         }
@@ -66,7 +69,8 @@ proc failcache_update {portname porturl canonical_variants failed} {
 
 # clear all entries for portname
 proc failcache_clear_all {portname} {
-    foreach f [glob -directory $::failcache_dir -nocomplain "${portname} *"] {
+    global failcache_dir
+    foreach f [glob -directory $failcache_dir -nocomplain "${portname} *"] {
         puts stderr "clearing failcache entry: [file tail $f]"
         file delete -force $f
     }
diff --git a/tools/mirror-multi.tcl b/tools/mirror-multi.tcl
index b9a9c90..aa31bd6 100755
--- a/tools/mirror-multi.tcl
+++ b/tools/mirror-multi.tcl
@@ -63,10 +63,12 @@ set mirror_done [dict create]
 set distfiles_results [dict create]
 
 proc check_mirror_done {portname} {
-    if {[dict exists $::mirror_done $portname]} {
-        return [dict get $::mirror_done $portname]
+    global mirror_done
+    if {[dict exists $mirror_done $portname]} {
+        return [dict get $mirror_done $portname]
     }
-    set cache_entry [file join $::mirrorcache_dir [string toupper [string index $portname 0]] $portname]
+    global mirrorcache_dir
+    set cache_entry [file join $mirrorcache_dir [string toupper [string index $portname 0]] $portname]
     if {[file isfile $cache_entry]} {
         set result [mportlookup $portname]
         if {[llength $result] < 2} {
@@ -82,31 +84,33 @@ proc check_mirror_done {portname} {
             close $fd
             if {$portfile_hash eq $entry_hash} {
                 if {$partial eq ""} {
-                    dict set ::mirror_done $portname 1
+                    dict set mirror_done $portname 1
                     return 1
                 } else {
-                    dict set ::mirror_done $portname $partial
+                    dict set mirror_done $portname $partial
                     return $partial
                 }
             } else {
                 file delete -force $cache_entry
-                dict set ::mirror_done $portname 0
+                dict set mirror_done $portname 0
             }
         }
     } else {
-        dict set ::mirror_done $portname 0
+        dict set mirror_done $portname 0
     }
     return 0
 }
 
 proc set_mirror_done {portname value} {
-    if {![dict exists $::mirror_done $portname] || [dict get $::mirror_done $portname] != 1} {
+    global mirror_done
+    if {![dict exists $mirror_done $portname] || [dict get $mirror_done $portname] != 1} {
+        global mirrorcache_dir
         set result [mportlookup $portname]
         set portinfo [lindex $result 1]
         set portfile [file join [macports::getportdir [dict get $portinfo porturl]] Portfile]
         set portfile_hash [sha256 file $portfile]
 
-        set cache_dir [file join $::mirrorcache_dir [string toupper [string index $portname 0]]]
+        set cache_dir [file join $mirrorcache_dir [string toupper [string index $portname 0]]]
         file mkdir $cache_dir
         set cache_entry [file join $cache_dir $portname]
         set fd [open $cache_entry w]
@@ -115,13 +119,14 @@ proc set_mirror_done {portname value} {
             puts $fd $value
         }
         close $fd
-        dict set ::mirror_done $portname 1
+        dict set mirror_done $portname 1
     }
 }
 
 proc get_dep_list {portinfo} {
+    global deptypes
     set deps [list]
-    foreach deptype $::deptypes {
+    foreach deptype $deptypes {
         if {[dict exists $portinfo $deptype]} {
             foreach dep [dict get $portinfo $deptype] {
                 lappend deps [lindex [split $dep :] end]
@@ -151,10 +156,11 @@ proc save_distfiles_results {mport succeeded} {
         # no distfiles, no problem
         return
     }
+    global distfiles_results
     set distpath [_mportkey $mport distpath]
     foreach distfile $all_dist_files {
         set filepath [file join $distpath $distfile]
-        dict set ::distfiles_results $filepath $succeeded
+        dict set distfiles_results $filepath $succeeded
     }
 }
 
@@ -179,6 +185,7 @@ proc skip_mirror {mport identifier} {
         # no distfiles, no need to mirror
         return 1
     }
+    global distfiles_results
     if {![info exists distfiles]} {
         set distfiles [list]
     }
@@ -194,9 +201,9 @@ proc skip_mirror {mport identifier} {
         }
         set distfile [getdistname $distfile]
         set filepath [file join $distpath $distfile]
-        if {![dict exists $::distfiles_results $filepath]} {
+        if {![dict exists $distfiles_results $filepath]} {
             set any_unmirrored 1
-        } elseif {[dict get $::distfiles_results $filepath] == 0} {
+        } elseif {[dict get $distfiles_results $filepath] == 0} {
             ui_msg "Skipping ${identifier}: $distfile already failed checksum"
             return 2
         }
@@ -210,9 +217,10 @@ proc skip_mirror {mport identifier} {
 
 
 proc mirror_port {portinfo} {
+    global processed platforms
     set portname [dict get $portinfo name]
     set porturl [dict get $portinfo porturl]
-    dict set ::processed $portname 1
+    dict set processed $portname 1
     set do_mirror 1
     set attempted 0
     set succeeded 0
@@ -269,7 +277,7 @@ proc mirror_port {portinfo} {
         mportclose $mport
     }
 
-    foreach {os_major os_arch} $::platforms {
+    foreach {os_major os_arch} $platforms {
         ui_msg "$portname with platform 'darwin $os_major $os_arch'"
         if {[catch {mportopen $porturl [dict create subport $portname os_major $os_major os_arch $os_arch] {}} mport]} {
             ui_error "mportopen $porturl failed: $mport"
@@ -295,7 +303,7 @@ proc mirror_port {portinfo} {
 
     set dep_failed 0
     foreach dep [lsort -unique $deps] {
-        if {![dict exists $::processed $dep] && [check_mirror_done $dep] == 0} {
+        if {![dict exists $processed $dep] && [check_mirror_done $dep] == 0} {
             set result [mportlookup $dep]
             if {[llength $result] < 2} {
                 ui_error "No such port: $dep"
@@ -320,14 +328,14 @@ proc mirror_port {portinfo} {
 }
 
 set mirrorcache_dir /tmp/mirrorcache
-if {[lindex $::argv 0] eq "-c"} {
-    set mirrorcache_dir [lindex $::argv 1]
-    set ::argv [lrange $::argv 2 end]
+if {[lindex $argv 0] eq "-c"} {
+    set mirrorcache_dir [lindex $argv 1]
+    set argv [lrange $argv 2 end]
 }
 
 set exitval 0
-foreach portname $::argv {
-    if {[dict exists $::processed $portname]} {
+foreach portname $argv {
+    if {[dict exists $processed $portname]} {
         ui_msg "skipping ${portname}, already processed"
         continue
     }
diff --git a/tools/sort-with-subports.tcl b/tools/sort-with-subports.tcl
index 4c8f37d..dd82d9d 100755
--- a/tools/sort-with-subports.tcl
+++ b/tools/sort-with-subports.tcl
@@ -48,60 +48,63 @@ proc ui_channels {priority} {
 
 
 proc process_port_deps {portname} {
-    set deplist [dict get $::portdepinfo $portname]
-    dict unset ::portdepinfo $portname
-    if {[dict exists $::portsoftdeps $portname]} {
-        lappend deplist {*}[dict get $::portsoftdeps $portname]
-        dict unset ::portsoftdeps $portname
+    global portdepinfo portsoftdeps portlist
+    set deplist [dict get $portdepinfo $portname]
+    dict unset portdepinfo $portname
+    if {[dict exists $portsoftdeps $portname]} {
+        lappend deplist {*}[dict get $portsoftdeps $portname]
+        dict unset portsoftdeps $portname
     }
     foreach portdep $deplist {
-        if {[dict exists $::portdepinfo $portdep]} {
+        if {[dict exists $portdepinfo $portdep]} {
             process_port_deps $portdep
         }
     }
-    lappend ::portlist $portname
+    lappend portlist $portname
 }
 
 proc check_failing_deps {portname} {
-    if {[dict exists $::failingports $portname]} {
-        return [dict get $::failingports $portname]
+    global failingports portdepinfo outputports requestedports \
+           canonicalnames
+    if {[dict exists $failingports $portname]} {
+        return [dict get $failingports $portname]
     }
     # Protect against dependency cycles
-    dict set ::failingports $portname [list 3 $portname]
-    foreach portdep [dict get $::portdepinfo $portname] {
+    dict set failingports $portname [list 3 $portname]
+    foreach portdep [dict get $portdepinfo $portname] {
         set dep_ret [check_failing_deps $portdep]
         # 0 = ok, 1 = known_fail, 2 = failcache, 3 = dep cycle
         set status [lindex $dep_ret 0]
         if {$status != 0} {
             set failed_dep [lindex $dep_ret 1]
-            if {[dict get $::outputports $portname] == 1} {
+            if {[dict get $outputports $portname] == 1} {
                 if {$status == 1} {
-                    if {[dict exists $::requestedports $portname]} {
-                        puts stderr "Excluding [dict get $::canonicalnames $portname] because its dependency '$failed_dep' is known to fail"
+                    if {[dict exists $requestedports $portname]} {
+                        puts stderr "Excluding [dict get $canonicalnames $portname] because its dependency '$failed_dep' is known to fail"
                     }
-                    dict set ::outputports $portname 0
-                } elseif {$status == 2 && ![dict exists $::requestedports $portname]} {
+                    dict set outputports $portname 0
+                } elseif {$status == 2 && ![dict exists $requestedports $portname]} {
                     # Exclude deps that will fail due to their own dep being in the failcache.
                     # But still output requested ports so the failure will be reported.
-                    dict set ::outputports $portname 0
+                    dict set outputports $portname 0
                 } elseif {$status == 3} {
-                    if {[dict exists $::requestedports $portname]} {
-                        puts stderr "Warning: [dict get $::canonicalnames $portname] appears to have a cyclic dependency involving '$portdep'"
+                    if {[dict exists $requestedports $portname]} {
+                        puts stderr "Warning: [dict get $canonicalnames $portname] appears to have a cyclic dependency involving '$portdep'"
                     }
                     # Some cycles involving depends_test exist, which don't cause
                     # problems yet only because we don't run tests.
-                    #dict set ::outputports $portname 0
+                    #dict set outputports $portname 0
                 }
             }
             # keep processing other deps for now if there was a dep cycle
             if {$status != 3} {
-                dict set ::failingports $portname [list $status $failed_dep]
-                return [dict get $::failingports $portname]
+                dict set failingports $portname [list $status $failed_dep]
+                return [dict get $failingports $portname]
             }
         }
     }
-    dict set ::failingports $portname [list 0 ""]
-    return [dict get $::failingports $portname]
+    dict set failingports $portname [list 0 ""]
+    return [dict get $failingports $portname]
 }
 
 source [file join [file dirname [info script]] failcache.tcl]
diff --git a/tools/uninstall-unneeded-ports.tcl b/tools/uninstall-unneeded-ports.tcl
index 4cc052a..dc6595c 100755
--- a/tools/uninstall-unneeded-ports.tcl
+++ b/tools/uninstall-unneeded-ports.tcl
@@ -54,7 +54,7 @@ foreach source $macports::sources {
                 set portinfo [read $fd $len]
 
                 # depends_test is not included because mpbb doesn't run `port test'
-                foreach field [list depends_build depends_extract depends_fetch depends_lib depends_patch depends_run] {
+                foreach field {depends_build depends_extract depends_fetch depends_lib depends_patch depends_run} {
                     if {[dict exists $portinfo $field]} {
                         foreach dependency [dict get $portinfo $field] {
                             set lowercase_dependency_name [string tolower [lindex [split $dependency :] end]]