Changeset 28697 for trunk/base


Ignore:
Timestamp:
Sep 7, 2007, 5:05:46 PM (12 years ago)
Author:
eridius@…
Message:

Convert tabs to spaces and add a modeline for emacs and vim

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/base/src/macports1.0/macports.tcl

    r28673 r28697  
     1# -*- Mode: Tcl; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:et:st=4:ts=4:sts=4
    12# macports.tcl
    23# $Id$
     
    4041    namespace export bootstrap_options user_options portinterp_options open_mports ui_priorities
    4142    variable bootstrap_options "\
    42         portdbpath libpath binpath auto_path extra_env sources_conf prefix portdbformat \
    43         portinstalltype portarchivemode portarchivepath portarchivetype portautoclean \
    44         porttrace portverbose destroot_umask variants_conf rsync_server rsync_options \
    45         rsync_dir startupitem_type place_worksymlink xcodeversion xcodebuildcmd \
     43        portdbpath libpath binpath auto_path extra_env sources_conf prefix portdbformat \
     44        portinstalltype portarchivemode portarchivepath portarchivetype portautoclean \
     45        porttrace portverbose destroot_umask variants_conf rsync_server rsync_options \
     46        rsync_dir startupitem_type place_worksymlink xcodeversion xcodebuildcmd \
    4647        mp_remote_url mp_remote_submit_url buildnicevalue buildmakejobs"
    4748    variable user_options "submitter_name submitter_email submitter_key"
    4849    variable portinterp_options "\
    49         portdbpath portpath portbuildpath auto_path prefix prefix_frozen portsharepath \
    50         registry.path registry.format registry.installtype portarchivemode portarchivepath \
    51         portarchivetype portautoclean porttrace portverbose destroot_umask rsync_server \
    52         rsync_options rsync_dir startupitem_type place_worksymlink \
     50        portdbpath portpath portbuildpath auto_path prefix prefix_frozen portsharepath \
     51        registry.path registry.format registry.installtype portarchivemode portarchivepath \
     52        portarchivetype portautoclean porttrace portverbose destroot_umask rsync_server \
     53        rsync_options rsync_dir startupitem_type place_worksymlink \
    5354        mp_remote_url mp_remote_submit_url buildnicevalue buildmakejobs \
    54         $user_options"
     55        $user_options"
    5556   
    5657    # deferred options are only computed when needed.
     
    5859    # they are not exported to the interpreter in system_options array.
    5960    variable portinterp_deferred_options "xcodeversion xcodebuildcmd"
    60        
     61   
    6162    variable open_mports {}
    6263   
     
    7879
    7980proc macports::ui_init {priority message} {
    80         # Get the list of channels.
    81         if {[llength [info commands ui_channels]] > 0} {
    82                 set channels [ui_channels $priority]
    83         } else {
    84             set channels [ui_channels_default $priority]
    85         }
    86 
    87         # Simplify ui_$priority.
    88         set nbchans [llength $channels]
    89         if {$nbchans == 0} {
    90                 proc ::ui_$priority {str} {}
    91         } else {
    92                 if {[llength [info commands ui_prefix]] > 0} {
    93                         set prefix [ui_prefix $priority]
    94                 } else {
    95                     set prefix [ui_prefix_default $priority]
    96                 }
    97 
    98                 if {$nbchans == 1} {
    99                         set chan [lindex $channels 0]
    100                         proc ::ui_$priority {str} [subst { puts $chan "$prefix\$str" }]
    101                 } else {
    102                         proc ::ui_$priority {str} [subst {
    103                                 foreach chan \$channels {
    104                                         puts $chan "$prefix\$str"
    105                                 }
    106                         }]
    107                 }
    108 
    109                 # Call ui_$priority
    110                 ::ui_$priority $message
    111         }
     81    # Get the list of channels.
     82    if {[llength [info commands ui_channels]] > 0} {
     83        set channels [ui_channels $priority]
     84    } else {
     85        set channels [ui_channels_default $priority]
     86    }
     87
     88    # Simplify ui_$priority.
     89    set nbchans [llength $channels]
     90    if {$nbchans == 0} {
     91        proc ::ui_$priority {str} {}
     92    } else {
     93        if {[llength [info commands ui_prefix]] > 0} {
     94            set prefix [ui_prefix $priority]
     95        } else {
     96            set prefix [ui_prefix_default $priority]
     97        }
     98
     99        if {$nbchans == 1} {
     100            set chan [lindex $channels 0]
     101            proc ::ui_$priority {str} [subst { puts $chan "$prefix\$str" }]
     102        } else {
     103            proc ::ui_$priority {str} [subst {
     104                foreach chan \$channels {
     105                    puts $chan "$prefix\$str"
     106                }
     107            }]
     108        }
     109
     110        # Call ui_$priority
     111        ::ui_$priority $message
     112    }
    112113}
    113114
    114115# Defult implementation of ui_prefix
    115116proc macports::ui_prefix_default {priority} {
    116         switch $priority {
    117                 debug {
    118                         return "DEBUG: "
    119                 }
    120                 error {
    121                         return "Error: "
    122                 }
    123                 warn {
    124                         return "Warning: "
    125                 }
    126                 default {
    127                         return ""
    128                 }
    129         }
     117    switch $priority {
     118        debug {
     119            return "DEBUG: "
     120        }
     121        error {
     122            return "Error: "
     123        }
     124        warn {
     125            return "Warning: "
     126        }
     127        default {
     128            return ""
     129        }
     130    }
    130131}
    131132
     
    156157rename puts tcl::puts
    157158proc puts {args} {
    158         catch "tcl::puts $args"
     159    catch "tcl::puts $args"
    159160}
    160161
     
    163164proc macports::findBinary {prog {autoconf_hint ""}} {
    164165    if {${autoconf_hint} != "" && [file executable ${autoconf_hint}]} {
    165         return ${autoconf_hint}
    166     } else {
    167         if {[catch {set cmd_path [macports::binaryInPath ${prog}]} result] == 0} {
    168             return ${cmd_path}
    169         } else {
    170             return -code error "${result} or at its MacPorts configuration time location, did you move it?"
    171         }
     166    return ${autoconf_hint}
     167    } else {
     168    if {[catch {set cmd_path [macports::binaryInPath ${prog}]} result] == 0} {
     169        return ${cmd_path}
     170    } else {
     171        return -code error "${result} or at its MacPorts configuration time location, did you move it?"
     172    }
    172173    }
    173174}
     
    178179    global env
    179180    foreach dir [split $env(PATH) :] {
    180         if {[file executable [file join $dir $prog]]} {
    181             return [file join $dir $prog]
    182         }
     181    if {[file executable [file join $dir $prog]]} {
     182        return [file join $dir $prog]
     183    }
    183184    }
    184185    return -code error [format [msgcat::mc "Failed to locate '%s' in path: '%s'"] $prog $env(PATH)];
     
    187188# deferred option processing
    188189proc macports::getoption {name} {
    189         global macports::$name
    190         return [expr $$name]
     190    global macports::$name
     191    return [expr $$name]
    191192}
    192193
    193194# deferred and on-need extraction of xcodeversion and xcodebuildcmd.
    194195proc macports::setxcodeinfo {name1 name2 op} {
    195         global macports::xcodeversion
    196         global macports::xcodebuildcmd
    197        
    198         trace remove variable macports::xcodeversion read macports::setxcodeinfo
    199         trace remove variable macports::xcodebuildcmd read macports::setxcodeinfo
    200 
    201         if {[catch {set xcodebuild [binaryInPath "xcodebuild"]}] == 0} {
    202                 if {![info exists xcodeversion]} {
    203                         # Determine xcode version (<= 2.0 or 2.1)
    204                         if {[catch {set xcodebuildversion [exec xcodebuild -version]}] == 0} {
    205                                 if {[regexp "DevToolsCore-(.*); DevToolsSupport-(.*)" $xcodebuildversion devtoolscore_v devtoolssupport_v] == 1} {
    206                                         if {$devtoolscore_v >= 620.0 && $devtoolssupport_v >= 610.0} {
    207                                                 # for now, we don't need to distinguish 2.1 from 2.1 or higher.
    208                                                 set macports::xcodeversion "2.1"
    209                                         } else {
    210                                                 set macports::xcodeversion "2.0orlower"
    211                                         }
    212                                 } else {
    213                                         set macports::xcodeversion "2.0orlower"
    214                                 }
    215                         } else {
    216                                 set macports::xcodeversion "2.0orlower"
    217                         }
    218                 }
    219                
    220                 if {![info exists xcodebuildcmd]} {
    221                         set macports::xcodebuildcmd "xcodebuild"
    222                 }
    223         } elseif {[catch {set pbxbuild [binaryInPath "pbxbuild"]}] == 0} {
    224                 if {![info exists xcodeversion]} {
    225                         set macports::xcodeversion "pb"
    226                 }
    227                 if {![info exists xcodebuildcmd]} {
    228                         set macports::xcodebuildcmd "pbxbuild"
    229                 }
    230         } else {
    231                 if {![info exists xcodeversion]} {
    232                         set macports::xcodeversion "none"
    233                 }
    234                 if {![info exists xcodebuildcmd]} {
    235                         set macports::xcodebuildcmd "none"
    236                 }
    237         }
     196    global macports::xcodeversion
     197    global macports::xcodebuildcmd
     198   
     199    trace remove variable macports::xcodeversion read macports::setxcodeinfo
     200    trace remove variable macports::xcodebuildcmd read macports::setxcodeinfo
     201
     202    if {[catch {set xcodebuild [binaryInPath "xcodebuild"]}] == 0} {
     203        if {![info exists xcodeversion]} {
     204            # Determine xcode version (<= 2.0 or 2.1)
     205            if {[catch {set xcodebuildversion [exec xcodebuild -version]}] == 0} {
     206                if {[regexp "DevToolsCore-(.*); DevToolsSupport-(.*)" $xcodebuildversion devtoolscore_v devtoolssupport_v] == 1} {
     207                    if {$devtoolscore_v >= 620.0 && $devtoolssupport_v >= 610.0} {
     208                        # for now, we don't need to distinguish 2.1 from 2.1 or higher.
     209                        set macports::xcodeversion "2.1"
     210                    } else {
     211                        set macports::xcodeversion "2.0orlower"
     212                    }
     213                } else {
     214                    set macports::xcodeversion "2.0orlower"
     215                }
     216            } else {
     217                set macports::xcodeversion "2.0orlower"
     218            }
     219        }
     220       
     221        if {![info exists xcodebuildcmd]} {
     222            set macports::xcodebuildcmd "xcodebuild"
     223        }
     224    } elseif {[catch {set pbxbuild [binaryInPath "pbxbuild"]}] == 0} {
     225        if {![info exists xcodeversion]} {
     226            set macports::xcodeversion "pb"
     227        }
     228        if {![info exists xcodebuildcmd]} {
     229            set macports::xcodebuildcmd "pbxbuild"
     230        }
     231    } else {
     232        if {![info exists xcodeversion]} {
     233            set macports::xcodeversion "none"
     234        }
     235        if {![info exists xcodebuildcmd]} {
     236            set macports::xcodebuildcmd "none"
     237        }
     238    }
    238239}
    239240
     
    247248
    248249proc mportinit {{up_ui_options {}} {up_options {}} {up_variations {}}} {
    249         if {$up_ui_options eq ""} {
    250                 array set ui_options {}
    251         } else {
    252                 upvar $up_ui_options ui_options
    253         }
    254         if {$up_options eq ""} {
    255                 array set options {}
    256         } else {
    257                 upvar $up_options options
    258         }
    259         if {$up_variations eq ""} {
    260                 array set $up_variations {}
    261         } else {
    262                 upvar $up_variations variations
    263         }
    264        
    265         global auto_path env
    266         global macports::autoconf::macports_conf_path
     250    if {$up_ui_options eq ""} {
     251        array set ui_options {}
     252    } else {
     253        upvar $up_ui_options ui_options
     254    }
     255    if {$up_options eq ""} {
     256        array set options {}
     257    } else {
     258        upvar $up_options options
     259    }
     260    if {$up_variations eq ""} {
     261        array set $up_variations {}
     262    } else {
     263        upvar $up_variations variations
     264    }
     265   
     266    global auto_path env
     267    global macports::autoconf::macports_conf_path
    267268        global macports::macports_user_dir
    268         global macports::bootstrap_options
    269         global macports::user_options
    270         global macports::extra_env
    271         global macports::portconf
    272         global macports::portdbpath
    273         global macports::portsharepath
    274         global macports::registry.format
    275         global macports::registry.path
    276         global macports::sources
    277         global macports::sources_conf
    278         global macports::destroot_umask
    279         global macports::libpath
    280         global macports::prefix
     269    global macports::bootstrap_options
     270    global macports::user_options
     271    global macports::extra_env
     272    global macports::portconf
     273    global macports::portdbpath
     274    global macports::portsharepath
     275    global macports::registry.format
     276    global macports::registry.path
     277    global macports::sources
     278    global macports::sources_conf
     279    global macports::destroot_umask
     280    global macports::libpath
     281    global macports::prefix
    281282        global macports::prefix_frozen
    282         global macports::registry.installtype
    283         global macports::rsync_dir
    284         global macports::rsync_options
    285         global macports::rsync_server
    286         global macports::variants_conf
    287         global macports::xcodebuildcmd
    288         global macports::xcodeversion
    289         global macports::buildnicevalue
    290         global macports::buildmakejobs
     283    global macports::registry.installtype
     284    global macports::rsync_dir
     285    global macports::rsync_options
     286    global macports::rsync_server
     287    global macports::variants_conf
     288    global macports::xcodebuildcmd
     289    global macports::xcodeversion
     290    global macports::buildnicevalue
     291    global macports::buildmakejobs
    291292
    292293        # Set the system encoding to utf-8
     
    295296        # Ensure that the macports user directory exists if HOME is defined
    296297        if {[info exists env(HOME)]} {
    297             set macports::macports_user_dir [file normalize $macports::autoconf::macports_user_dir]
    298             if { ![file exists $macports_user_dir] } {
    299                 # If not, create it with ownership of the enclosing directory, rwx by the user only
    300                 file mkdir $macports_user_dir
    301                 file attributes $macports_user_dir -permissions u=rwx,go= \
    302                     -owner [file attributes $macports_user_dir/.. -owner] \
    303                     -group [file attributes $macports_user_dir/.. -group]
    304             }
    305         } else {
    306             # Otherwise define the user directory as a direcotory that will never exist
    307             set macports::macports_user_dir "/dev/null/NO_HOME_DIR"
    308         }
    309         
    310         # Configure the search path for configuration files
    311         set conf_files ""
     298        set macports::macports_user_dir [file normalize $macports::autoconf::macports_user_dir]
     299        if { ![file exists $macports_user_dir] } {
     300        # If not, create it with ownership of the enclosing directory, rwx by the user only
     301        file mkdir $macports_user_dir
     302        file attributes $macports_user_dir -permissions u=rwx,go= \
     303            -owner [file attributes $macports_user_dir/.. -owner] \
     304            -group [file attributes $macports_user_dir/.. -group]
     305        }
     306    } else {
     307        # Otherwise define the user directory as a direcotory that will never exist
     308        set macports::macports_user_dir "/dev/null/NO_HOME_DIR"
     309    }
     310    
     311    # Configure the search path for configuration files
     312    set conf_files ""
    312313        if {[info exists env(PORTSRC)]} {
    313             set PORTSRC $env(PORTSRC)
    314             lappend conf_files ${PORTSRC}
    315         }
     314        set PORTSRC $env(PORTSRC)
     315        lappend conf_files ${PORTSRC}
     316    }
    316317    if { [file isdirectory macports_user_dir] } {
    317         lappend conf_files "${macports_user_dir}/macports.conf"
     318    lappend conf_files "${macports_user_dir}/macports.conf"
    318319    }
    319320    lappend conf_files "${macports_conf_path}/macports.conf"
    320321   
    321322    # Process the first configuration file we find on conf_files list
    322         foreach file $conf_files {
    323                 if [file exists $file] {
    324                         set portconf $file
    325                         set fd [open $file r]
    326                         while {[gets $fd line] >= 0} {
    327                                 if {[regexp {^(\w+)([ \t]+(.*))?$} $line match option ignore val] == 1} {
    328                                         if {[lsearch $bootstrap_options $option] >= 0} {
    329                                                 set macports::$option $val
    330                                                 global macports::$option
    331                                         }
    332                                 }
    333                         }
    334                        
    335                         break
    336                 }
    337         }
    338        
    339         # Process per-user only settings
     323    foreach file $conf_files {
     324        if [file exists $file] {
     325            set portconf $file
     326            set fd [open $file r]
     327            while {[gets $fd line] >= 0} {
     328                if {[regexp {^(\w+)([ \t]+(.*))?$} $line match option ignore val] == 1} {
     329                    if {[lsearch $bootstrap_options $option] >= 0} {
     330                        set macports::$option $val
     331                        global macports::$option
     332                    }
     333                }
     334            }
     335           
     336            break
     337        }
     338    }
     339   
     340    # Process per-user only settings
    340341        set per_user "${macports_user_dir}/user.conf"
    341         if [file exists $per_user] {
    342                 set fd [open $per_user r]
    343                 while {[gets $fd line] >= 0} {
    344                         if {[regexp {^(\w+)([ \t]+(.*))?$} $line match option ignore val] == 1} {
    345                                 if {[lsearch $user_options $option] >= 0} {
    346                                         set macports::$option $val
    347                                         global macports::$option
    348                                 }
    349                         }
    350                 }
    351         }
    352        
     342    if [file exists $per_user] {
     343        set fd [open $per_user r]
     344        while {[gets $fd line] >= 0} {
     345            if {[regexp {^(\w+)([ \t]+(.*))?$} $line match option ignore val] == 1} {
     346                if {[lsearch $user_options $option] >= 0} {
     347                    set macports::$option $val
     348                    global macports::$option
     349                }
     350            }
     351        }
     352    }
     353   
    353354    if {![info exists sources_conf]} {
    354355        return -code error "sources_conf must be set in ${macports_conf_path}/macports.conf or in your ${macports_user_dir}/macports.conf file"
     
    357358    while {[gets $fd line] >= 0} {
    358359        set line [string trimright $line]
    359         if {![regexp {^\s*#|^$} $line]} {
    360             if {[regexp {^([\w-]+://\S+)(?:\s+\[(\w+(?:,\w+)*)\])?$} $line _ url flags]} {
    361                 set flags [split $flags ,]
    362                 foreach flag $flags {
    363                     if {[lsearch -exact [list nosync] $flag] == -1} {
    364                         ui_warn "$sources_conf source '$line' specifies invalid flag '$flag'"
    365                     }
    366                 }
    367                 lappend sources [concat [list $url] $flags]
    368             } else {
    369                 ui_warn "$sources_conf specifies invalid source '$line', ignored."
    370             }
    371         }
     360    if {![regexp {^\s*#|^$} $line]} {
     361        if {[regexp {^([\w-]+://\S+)(?:\s+\[(\w+(?:,\w+)*)\])?$} $line _ url flags]} {
     362        set flags [split $flags ,]
     363        foreach flag $flags {
     364            if {[lsearch -exact [list nosync] $flag] == -1} {
     365            ui_warn "$sources_conf source '$line' specifies invalid flag '$flag'"
     366            }
     367        }
     368        lappend sources [concat [list $url] $flags]
     369        } else {
     370        ui_warn "$sources_conf specifies invalid source '$line', ignored."
     371        }
     372    }
    372373    }
    373374    if {![info exists sources]} {
    374         if {[file isdirectory ports]} {
    375             set sources "file://[pwd]/ports"
    376         } else {
    377             return -code error "No sources defined in $sources_conf"
    378         }
    379     }
    380 
    381         if {[info exists variants_conf]} {
    382                 if {[file exist $variants_conf]} {
    383                         set fd [open $variants_conf r]
    384                         while {[gets $fd line] >= 0} {
    385                                 set line [string trimright $line]
    386                                 if {![regexp {^[\ \t]*#.*$|^$} $line]} {
    387                                         foreach arg [split $line " \t"] {
    388                                                 if {[regexp {^([-+])([-A-Za-z0-9_+\.]+)$} $arg match sign opt] == 1} {
    389                                                         if {![info exists variations($opt)]} {
    390                                                                 set variations($opt) $sign
    391                                                         }
    392                                                 } else {
    393                                                         ui_warn "$variants_conf specifies invalid variant syntax '$arg', ignored."
    394                                                 }
    395                                         }
    396                                 }
    397                         }
    398                 } else {
    399                         ui_debug "$variants_conf does not exist, variants_conf setting ignored."
    400                 }
    401         }
     375    if {[file isdirectory ports]} {
     376        set sources "file://[pwd]/ports"
     377    } else {
     378        return -code error "No sources defined in $sources_conf"
     379    }
     380    }
     381
     382    if {[info exists variants_conf]} {
     383        if {[file exist $variants_conf]} {
     384                set fd [open $variants_conf r]
     385            while {[gets $fd line] >= 0} {
     386                set line [string trimright $line]
     387                if {![regexp {^[\ \t]*#.*$|^$} $line]} {
     388                    foreach arg [split $line " \t"] {
     389                        if {[regexp {^([-+])([-A-Za-z0-9_+\.]+)$} $arg match sign opt] == 1} {
     390                            if {![info exists variations($opt)]} {
     391                                set variations($opt) $sign
     392                            }
     393                        } else {
     394                            ui_warn "$variants_conf specifies invalid variant syntax '$arg', ignored."
     395                        }
     396                    }
     397                }
     398            }
     399        } else {
     400            ui_debug "$variants_conf does not exist, variants_conf setting ignored."
     401        }
     402    }
    402403
    403404    if {![info exists portdbpath]} {
    404         return -code error "portdbpath must be set in ${macports_conf_path}/macports.conf or in your ${macports_user_dir}/macports.conf"
     405    return -code error "portdbpath must be set in ${macports_conf_path}/macports.conf or in your ${macports_user_dir}/macports.conf"
    405406    }
    406407    if {![file isdirectory $portdbpath]} {
    407         if {![file exists $portdbpath]} {
    408             if {[catch {file mkdir $portdbpath} result]} {
    409                 return -code error "portdbpath $portdbpath does not exist and could not be created: $result"
    410             }
    411         }
     408    if {![file exists $portdbpath]} {
     409        if {[catch {file mkdir $portdbpath} result]} {
     410        return -code error "portdbpath $portdbpath does not exist and could not be created: $result"
     411        }
     412    }
    412413    }
    413414    if {![file isdirectory $portdbpath]} {
    414         return -code error "$portdbpath is not a directory. Please create the directory $portdbpath and try again"
     415    return -code error "$portdbpath is not a directory. Please create the directory $portdbpath and try again"
    415416    }
    416417
    417418    set registry.path $portdbpath
    418419    if {![file isdirectory ${registry.path}]} {
    419         if {![file exists ${registry.path}]} {
    420             if {[catch {file mkdir ${registry.path}} result]} {
    421                 return -code error "portdbpath ${registry.path} does not exist and could not be created: $result"
    422             }
    423         }
     420    if {![file exists ${registry.path}]} {
     421        if {[catch {file mkdir ${registry.path}} result]} {
     422        return -code error "portdbpath ${registry.path} does not exist and could not be created: $result"
     423        }
     424    }
    424425    }
    425426    if {![file isdirectory ${macports::registry.path}]} {
    426         return -code error "${macports::registry.path} is not a directory. Please create the directory $portdbpath and try again"
    427     }
    428 
    429         # Format for receipts, can currently be either "flat" or "sqlite"
    430         if {[info exists portdbformat]} {
    431                 if { $portdbformat == "sqlite" } {
    432                         return -code error "SQLite is not yet supported for registry storage."
    433                 }
    434                 set registry.format receipt_${portdbformat}
    435         } else {
    436                 set registry.format receipt_flat
    437         }
    438 
    439         # Installation type, whether to use port "images" or install "direct"
    440         if {[info exists portinstalltype]} {
    441                 set registry.installtype $portinstalltype
    442         } else {
    443                 set registry.installtype image
    444         }
    445    
    446         # Autoclean mode, whether to automatically call clean after "install"
    447         if {![info exists portautoclean]} {
    448                 set macports::portautoclean "yes"
    449                 global macports::portautoclean
    450         }
    451         # Check command line override for autoclean
    452         if {[info exists options(ports_autoclean)]} {
    453                 if {![string equal $options(ports_autoclean) $portautoclean]} {
    454                         set macports::portautoclean $options(ports_autoclean)
    455                 }
    456         }
    457         # Trace mode, whether to use darwintrace to debug ports.
    458         if {![info exists porttrace]} {
    459                 set macports::porttrace "no"
    460                 global macports::porttrace
    461         }
    462         # Check command line override for trace
    463         if {[info exists options(ports_trace)]} {
    464                 if {![string equal $options(ports_trace) $porttrace]} {
    465                         set macports::porttrace $options(ports_trace)
    466                 }
    467         }
     427    return -code error "${macports::registry.path} is not a directory. Please create the directory $portdbpath and try again"
     428    }
     429
     430    # Format for receipts, can currently be either "flat" or "sqlite"
     431    if {[info exists portdbformat]} {
     432        if { $portdbformat == "sqlite" } {
     433            return -code error "SQLite is not yet supported for registry storage."
     434        }
     435        set registry.format receipt_${portdbformat}
     436    } else {
     437        set registry.format receipt_flat
     438    }
     439
     440    # Installation type, whether to use port "images" or install "direct"
     441    if {[info exists portinstalltype]} {
     442        set registry.installtype $portinstalltype
     443    } else {
     444        set registry.installtype image
     445    }
     446   
     447    # Autoclean mode, whether to automatically call clean after "install"
     448    if {![info exists portautoclean]} {
     449        set macports::portautoclean "yes"
     450        global macports::portautoclean
     451    }
     452    # Check command line override for autoclean
     453    if {[info exists options(ports_autoclean)]} {
     454        if {![string equal $options(ports_autoclean) $portautoclean]} {
     455            set macports::portautoclean $options(ports_autoclean)
     456        }
     457    }
     458    # Trace mode, whether to use darwintrace to debug ports.
     459    if {![info exists porttrace]} {
     460        set macports::porttrace "no"
     461        global macports::porttrace
     462    }
     463    # Check command line override for trace
     464    if {[info exists options(ports_trace)]} {
     465        if {![string equal $options(ports_trace) $porttrace]} {
     466            set macports::porttrace $options(ports_trace)
     467        }
     468    }
    468469
    469470        # Duplicate prefix into prefix_frozen, so that port actions
     
    471472        set macports::prefix_frozen $prefix
    472473
    473         # Export verbosity.
    474         if {![info exists portverbose]} {
    475                 set macports::portverbose "no"
    476                 global macports::portverbose
    477         }
    478         if {[info exists ui_options(ports_verbose)]} {
    479                 if {![string equal $ui_options(ports_verbose) $portverbose]} {
    480                         set macports::portverbose $ui_options(ports_verbose)
    481                 }
    482         }
    483 
    484         # Archive mode, whether to create/use binary archive packages
    485         if {![info exists portarchivemode]} {
    486                 set macports::portarchivemode "yes"
    487                 global macports::portarchivemode
    488         }
    489 
    490         # Archive path, where to store/retrieve binary archive packages
    491         if {![info exists portarchivepath]} {
    492                 set macports::portarchivepath [file join $portdbpath packages]
    493                 global macports::portarchivepath
    494         }
    495         if {$portarchivemode == "yes"} {
    496                 if {![file isdirectory $portarchivepath]} {
    497                         if {![file exists $portarchivepath]} {
    498                                 if {[catch {file mkdir $portarchivepath} result]} {
    499                                         return -code error "portarchivepath $portarchivepath does not exist and could not be created: $result"
    500                                 }
    501                         }
    502                 }
    503                 if {![file isdirectory $portarchivepath]} {
    504                         return -code error "$portarchivepath is not a directory. Please create the directory $portarchivepath and try again"
    505                 }
    506         }
    507 
    508         # Archive type, what type of binary archive to use (CPIO, gzipped
    509         # CPIO, XAR, etc.)
    510         if {![info exists portarchivetype]} {
    511                 set macports::portarchivetype "cpgz"
    512                 global macports::portarchivetype
    513         }
    514         # Convert archive type to a list for multi-archive support, colon or
    515         # comma separators indicates to use multiple archive formats
    516         # (reading and writing)
    517         set macports::portarchivetype [split $portarchivetype {:,}]
    518 
    519         # Set rync options
    520         if {![info exists rsync_server]} {
    521                 set macports::rsync_server rsync.macports.org
    522                 global macports::rsync_server
    523         }
    524         if {![info exists rsync_dir]} {
    525                 set macports::rsync_dir release/base/
    526                 global macports::rsync_dir
    527         }
    528         if {![info exists rsync_options]} {
    529                 set rsync_options "-rtzv --delete-after"
    530                 global macports::rsync_options
    531         }
     474    # Export verbosity.
     475    if {![info exists portverbose]} {
     476        set macports::portverbose "no"
     477        global macports::portverbose
     478    }
     479    if {[info exists ui_options(ports_verbose)]} {
     480        if {![string equal $ui_options(ports_verbose) $portverbose]} {
     481            set macports::portverbose $ui_options(ports_verbose)
     482        }
     483    }
     484
     485    # Archive mode, whether to create/use binary archive packages
     486    if {![info exists portarchivemode]} {
     487        set macports::portarchivemode "yes"
     488        global macports::portarchivemode
     489    }
     490
     491    # Archive path, where to store/retrieve binary archive packages
     492    if {![info exists portarchivepath]} {
     493        set macports::portarchivepath [file join $portdbpath packages]
     494        global macports::portarchivepath
     495    }
     496    if {$portarchivemode == "yes"} {
     497        if {![file isdirectory $portarchivepath]} {
     498            if {![file exists $portarchivepath]} {
     499                if {[catch {file mkdir $portarchivepath} result]} {
     500                    return -code error "portarchivepath $portarchivepath does not exist and could not be created: $result"
     501                }
     502            }
     503        }
     504        if {![file isdirectory $portarchivepath]} {
     505            return -code error "$portarchivepath is not a directory. Please create the directory $portarchivepath and try again"
     506        }
     507    }
     508
     509    # Archive type, what type of binary archive to use (CPIO, gzipped
     510    # CPIO, XAR, etc.)
     511    if {![info exists portarchivetype]} {
     512        set macports::portarchivetype "cpgz"
     513        global macports::portarchivetype
     514    }
     515    # Convert archive type to a list for multi-archive support, colon or
     516    # comma separators indicates to use multiple archive formats
     517    # (reading and writing)
     518    set macports::portarchivetype [split $portarchivetype {:,}]
     519
     520    # Set rync options
     521    if {![info exists rsync_server]} {
     522        set macports::rsync_server rsync.macports.org
     523        global macports::rsync_server
     524    }
     525    if {![info exists rsync_dir]} {
     526        set macports::rsync_dir release/base/
     527        global macports::rsync_dir
     528    }
     529    if {![info exists rsync_options]} {
     530        set rsync_options "-rtzv --delete-after"
     531        global macports::rsync_options
     532    }
    532533
    533534    set portsharepath ${prefix}/share/macports
    534535    if {![file isdirectory $portsharepath]} {
    535         return -code error "Data files directory '$portsharepath' must exist"
     536    return -code error "Data files directory '$portsharepath' must exist"
    536537    }
    537538   
    538539    if {![info exists libpath]} {
    539         set libpath "${prefix}/share/macports/Tcl"
     540    set libpath "${prefix}/share/macports/Tcl"
    540541    }
    541542
    542543    if {![info exists binpath]} {
    543         set env(PATH) "${prefix}/bin:${prefix}/sbin:/bin:/sbin:/usr/bin:/usr/sbin:/usr/X11R6/bin"
    544     } else {
    545         set env(PATH) "$binpath"
     544    set env(PATH) "${prefix}/bin:${prefix}/sbin:/bin:/sbin:/usr/bin:/usr/sbin:/usr/X11R6/bin"
     545    } else {
     546    set env(PATH) "$binpath"
    546547    }
    547548   
    548549    # Set startupitem default type (can be overridden by portfile)
    549550    if {![info exists macports::startupitem_type]} {
    550         set macports::startupitem_type "default"
     551        set macports::startupitem_type "default"
    551552    }
    552553
    553554    # Default place_worksymlink
    554555    if {![info exists macports::place_worksymlink]} {
    555         set macports::place_worksymlink yes
     556    set macports::place_worksymlink yes
    556557    }
    557558
    558559    # Default mp remote options
    559560    if {![info exists macports::mp_remote_url]} {
    560         set macports::mp_remote_url "http://db.macports.org"
     561    set macports::mp_remote_url "http://db.macports.org"
    561562    }
    562563    if {![info exists macports::mp_remote_submit_url]} {
    563         set macports::mp_remote_submit_url "${macports::mp_remote_url}/submit"
     564    set macports::mp_remote_submit_url "${macports::mp_remote_url}/submit"
    564565    }
    565566   
    566567    # Default mp build options
    567568    if {![info exists macports::buildnicevalue]} {
    568         set macports::buildnicevalue 0
     569    set macports::buildnicevalue 0
    569570    }
    570571    if {![info exists macports::buildmakejobs]} {
    571         set macports::buildmakejobs 1
     572    set macports::buildmakejobs 1
    572573    }
    573574   
    574575    # ENV cleanup.
    575         set keepenvkeys { DISPLAY DYLD_FALLBACK_FRAMEWORK_PATH
    576                           DYLD_FALLBACK_LIBRARY_PATH DYLD_FRAMEWORK_PATH
    577                           DYLD_LIBRARY_PATH DYLD_INSERT_LIBRARIES
    578                           HOME JAVA_HOME LD_PREBIND
    579                           LD_PREBIND_ALLOW_OVERLAP MASTER_SITE_LOCAL
    580                           PATCH_SITE_LOCAL PATH PORTSRC RSYNC_PROXY TMP TMPDIR
    581                           USER GROUP
    582                           http_proxy HTTPS_PROXY FTP_PROXY ALL_PROXY NO_PROXY
    583                                         }
     576    set keepenvkeys { DISPLAY DYLD_FALLBACK_FRAMEWORK_PATH
     577                      DYLD_FALLBACK_LIBRARY_PATH DYLD_FRAMEWORK_PATH
     578                      DYLD_LIBRARY_PATH DYLD_INSERT_LIBRARIES
     579                      HOME JAVA_HOME LD_PREBIND
     580                      LD_PREBIND_ALLOW_OVERLAP MASTER_SITE_LOCAL
     581                      PATCH_SITE_LOCAL PATH PORTSRC RSYNC_PROXY TMP TMPDIR
     582                      USER GROUP
     583                      http_proxy HTTPS_PROXY FTP_PROXY ALL_PROXY NO_PROXY
     584                    }
    584585    if {[info exists extra_env]} {
    585         set keepenvkeys [concat ${keepenvkeys} ${extra_env}]
    586     }
    587        
    588         foreach envkey [array names env] {
    589                 if {[lsearch $keepenvkeys $envkey] == -1} {
    590                         array unset env $envkey
    591                 }
    592         }
    593 
    594         if {![info exists xcodeversion] || ![info exists xcodebuildcmd]} {
    595                 # We'll resolve these later (if needed)
    596                 trace add variable macports::xcodeversion read macports::setxcodeinfo
    597                 trace add variable macports::xcodebuildcmd read macports::setxcodeinfo
    598         }
     586        set keepenvkeys [concat ${keepenvkeys} ${extra_env}]
     587    }
     588   
     589    foreach envkey [array names env] {
     590        if {[lsearch $keepenvkeys $envkey] == -1} {
     591            array unset env $envkey
     592        }
     593    }
     594
     595    if {![info exists xcodeversion] || ![info exists xcodebuildcmd]} {
     596        # We'll resolve these later (if needed)
     597        trace add variable macports::xcodeversion read macports::setxcodeinfo
     598        trace add variable macports::xcodebuildcmd read macports::setxcodeinfo
     599    }
    599600
    600601    # Set the default umask
     
    604605
    605606    if {[info exists master_site_local] && ![info exists env(MASTER_SITE_LOCAL)]} {
    606         set env(MASTER_SITE_LOCAL) "$master_site_local"
    607     }
    608 
    609         # Prebinding. useful with MacOS X's ld, harmless elsewhere.
    610         # With both variables, prebinding will always succeed but we might need
    611         # to redo it.
     607    set env(MASTER_SITE_LOCAL) "$master_site_local"
     608    }
     609
     610    # Prebinding. useful with MacOS X's ld, harmless elsewhere.
     611    # With both variables, prebinding will always succeed but we might need
     612    # to redo it.
    612613    if {![info exists env(LD_PREBIND)] && ![info exists env(LD_PREBIND_ALLOW_OVERLAP)]} {
    613         set env(LD_PREBIND) "1"
    614         set env(LD_PREBIND_ALLOW_OVERLAP) "1"
     614    set env(LD_PREBIND) "1"
     615    set env(LD_PREBIND_ALLOW_OVERLAP) "1"
    615616    }
    616617
    617618    if {[file isdirectory $libpath]} {
    618                 lappend auto_path $libpath
    619                 set macports::auto_path $auto_path
    620 
    621                 # XXX: not sure if this the best place, but it needs to happen
    622                 # early, and after auto_path has been set.  Or maybe Pextlib
    623                 # should ship with macports1.0 API?
    624                 package require Pextlib 1.0
    625                 package require registry 1.0
    626     } else {
    627                 return -code error "Library directory '$libpath' must exist"
     619        lappend auto_path $libpath
     620        set macports::auto_path $auto_path
     621
     622        # XXX: not sure if this the best place, but it needs to happen
     623        # early, and after auto_path has been set.  Or maybe Pextlib
     624        # should ship with macports1.0 API?
     625        package require Pextlib 1.0
     626        package require registry 1.0
     627    } else {
     628        return -code error "Library directory '$libpath' must exist"
    628629    }
    629630}
     
    636637    interp hide $workername exit
    637638
    638         # Tell the sub interpreter about all the Tcl packages we already
    639         # know about so it won't glob for packages.
    640         foreach pkgName [package names] {
    641                 foreach pkgVers [package versions $pkgName] {
    642                         set pkgLoadScript [package ifneeded $pkgName $pkgVers]
    643                         $workername eval "package ifneeded $pkgName $pkgVers {$pkgLoadScript}"
    644                 }
    645         }
     639    # Tell the sub interpreter about all the Tcl packages we already
     640    # know about so it won't glob for packages.
     641    foreach pkgName [package names] {
     642        foreach pkgVers [package versions $pkgName] {
     643            set pkgLoadScript [package ifneeded $pkgName $pkgVers]
     644            $workername eval "package ifneeded $pkgName $pkgVers {$pkgLoadScript}"
     645        }
     646    }
    646647
    647648    # Create package require abstraction procedure
    648649    $workername eval "proc PortSystem \{version\} \{ \n\
    649                         package require port \$version \}"
     650            package require port \$version \}"
    650651
    651652    # Clearly separate slave interpreters and the master interpreter.
    652         $workername alias mport_exec mportexec
    653         $workername alias mport_open mportopen
    654         $workername alias mport_close mportclose
    655         $workername alias mport_search mportsearch
     653    $workername alias mport_exec mportexec
     654    $workername alias mport_open mportopen
     655    $workername alias mport_close mportclose
     656    $workername alias mport_search mportsearch
    656657
    657658    # instantiate the UI call-backs
    658         foreach priority ${macports::ui_priorities} {
    659                 $workername alias ui_$priority ui_$priority
    660         }
    661         $workername alias ui_prefix ui_prefix
    662         $workername alias ui_channels ui_channels
     659    foreach priority ${macports::ui_priorities} {
     660        $workername alias ui_$priority ui_$priority
     661    }
     662    $workername alias ui_prefix ui_prefix
     663    $workername alias ui_channels ui_channels
    663664   
    664665    # Export some utility functions defined here.
     
    666667    $workername alias getportworkpath_from_buildpath macports::getportworkpath_from_buildpath
    667668
    668         # New Registry/Receipts stuff
    669         $workername alias registry_new registry::new_entry
    670         $workername alias registry_open registry::open_entry
    671         $workername alias registry_write registry::write_entry
    672         $workername alias registry_prop_store registry::property_store
    673         $workername alias registry_prop_retr registry::property_retrieve
    674         $workername alias registry_delete registry::delete_entry
    675         $workername alias registry_exists registry::entry_exists
    676         $workername alias registry_activate portimage::activate
    677         $workername alias registry_deactivate portimage::deactivate
    678         $workername alias registry_register_deps registry::register_dependencies
    679         $workername alias registry_fileinfo_for_index registry::fileinfo_for_index
    680         $workername alias registry_bulk_register_files registry::register_bulk_files
    681         $workername alias registry_installed registry::installed
    682         $workername alias registry_active registry::active
    683 
    684         # deferred options processing.
    685         $workername alias getoption macports::getoption
     669    # New Registry/Receipts stuff
     670    $workername alias registry_new registry::new_entry
     671    $workername alias registry_open registry::open_entry
     672    $workername alias registry_write registry::write_entry
     673    $workername alias registry_prop_store registry::property_store
     674    $workername alias registry_prop_retr registry::property_retrieve
     675    $workername alias registry_delete registry::delete_entry
     676    $workername alias registry_exists registry::entry_exists
     677    $workername alias registry_activate portimage::activate
     678    $workername alias registry_deactivate portimage::deactivate
     679    $workername alias registry_register_deps registry::register_dependencies
     680    $workername alias registry_fileinfo_for_index registry::fileinfo_for_index
     681    $workername alias registry_bulk_register_files registry::register_bulk_files
     682    $workername alias registry_installed registry::installed
     683    $workername alias registry_active registry::active
     684
     685    # deferred options processing.
     686    $workername alias getoption macports::getoption
    686687
    687688    foreach opt $portinterp_options {
    688                 if {![info exists $opt]} {
    689                     global macports::$opt
    690                 }
     689        if {![info exists $opt]} {
     690            global macports::$opt
     691        }
    691692        if {[info exists $opt]} {
    692693            $workername eval set system_options($opt) \{[set $opt]\}
     
    695696    }
    696697   
    697         foreach opt $portinterp_deferred_options {
    698                 global macports::$opt
    699                 # define the trace hook.
    700                 $workername eval \
    701                         "proc trace_$opt {name1 name2 op} { \n\
    702                                 trace remove variable ::$opt read ::trace_$opt \n\
    703                                 global $opt \n\
    704                                 set $opt \[getoption $opt\] \n\
    705                         }"
    706                 # next access will actually define the variable.
    707                 $workername eval "trace add variable ::$opt read ::trace_$opt"
    708                 # define some value now
    709                 $workername eval set $opt "?"
    710         }               
     698    foreach opt $portinterp_deferred_options {
     699        global macports::$opt
     700        # define the trace hook.
     701        $workername eval \
     702            "proc trace_$opt {name1 name2 op} { \n\
     703                trace remove variable ::$opt read ::trace_$opt \n\
     704                global $opt \n\
     705                set $opt \[getoption $opt\] \n\
     706            }"
     707        # next access will actually define the variable.
     708        $workername eval "trace add variable ::$opt read ::trace_$opt"
     709        # define some value now
     710        $workername eval set $opt "?"
     711    }       
    711712
    712713    foreach {opt val} $options {
     
    720721
    721722    if { [info exists registry.installtype] } {
    722             $workername eval set installtype ${registry.installtype}
     723        $workername eval set installtype ${registry.installtype}
    723724    }
    724725}
     
    732733    global macports::portinterp_options
    733734
    734         # Create the thread.
    735         set result [thread::create -preserved {thread::wait}]
    736 
    737         # Tell the thread about all the Tcl packages we already
    738         # know about so it won't glob for packages.
    739         foreach pkgName [package names] {
    740                 foreach pkgVers [package versions $pkgName] {
    741                         set pkgLoadScript [package ifneeded $pkgName $pkgVers]
    742                         thread::send -async $result "package ifneeded $pkgName $pkgVers {$pkgLoadScript}"
    743                 }
    744         }
    745 
    746         # inherit configuration variables.
    747         thread::send -async $result "namespace eval macports {}"
    748         foreach opt $portinterp_options {
    749                 if {![info exists $opt]} {
    750                         global macports::$opt
    751                 }
     735    # Create the thread.
     736    set result [thread::create -preserved {thread::wait}]
     737
     738    # Tell the thread about all the Tcl packages we already
     739    # know about so it won't glob for packages.
     740    foreach pkgName [package names] {
     741        foreach pkgVers [package versions $pkgName] {
     742            set pkgLoadScript [package ifneeded $pkgName $pkgVers]
     743            thread::send -async $result "package ifneeded $pkgName $pkgVers {$pkgLoadScript}"
     744        }
     745    }
     746
     747    # inherit configuration variables.
     748    thread::send -async $result "namespace eval macports {}"
     749    foreach opt $portinterp_options {
     750        if {![info exists $opt]} {
     751            global macports::$opt
     752        }
    752753        if {[info exists $opt]} {
    753                         thread::send -async $result "global macports::$opt"
    754                         set val [set macports::$opt]
    755                         thread::send -async $result "set macports::$opt \"$val\""
    756                 }
    757         }
    758        
    759         return $result
     754            thread::send -async $result "global macports::$opt"
     755            set val [set macports::$opt]
     756            thread::send -async $result "set macports::$opt \"$val\""
     757        }
     758    }
     759   
     760    return $result
    760761}
    761762
     
    766767    file mkdir $fetchdir
    767768    if {![file writable $fetchdir]} {
    768         return -code error "Port remote fetch failed: You do not have permission to write to $fetchdir"
     769        return -code error "Port remote fetch failed: You do not have permission to write to $fetchdir"
    769770    }
    770771    if {[catch {exec curl -L -s -S -o [file join $fetchdir $fetchfile] $url} result]} {
     
    773774    cd $fetchdir
    774775    if {[catch {exec tar -zxf $fetchfile} result]} {
    775         return -code error "Port extract failed: $result"
     776    return -code error "Port extract failed: $result"
    776777    }
    777778    if {[regexp {(.+).tgz} $fetchfile match portdir] != 1} {
     
    794795# mports:// sources).
    795796proc macports::getportdir {url {destdir "."}} {
    796         if {[regexp {(?x)([^:]+)://(.+)} $url match protocol string] == 1} {
    797                 switch -regexp -- ${protocol} {
    798                         {^file$} {
    799                             return [file normalize $string]
    800                         }
    801                         {^mports$} {
    802                                 return [macports::index::fetch_port $url $destdir]
    803                         }
    804                         {^https?$|^ftp$} {
    805                                 return [macports::fetch_port $url]
    806                         }
    807                         default {
    808                                 return -code error "Unsupported protocol $protocol"
    809                         }
    810                 }
    811         } else {
    812                 return -code error "Can't parse url $url"
    813         }
     797    if {[regexp {(?x)([^:]+)://(.+)} $url match protocol string] == 1} {
     798        switch -regexp -- ${protocol} {
     799            {^file$} {
     800                return [file normalize $string]
     801            }
     802            {^mports$} {
     803                return [macports::index::fetch_port $url $destdir]
     804            }
     805            {^https?$|^ftp$} {
     806                return [macports::fetch_port $url]
     807            }
     808            default {
     809                return -code error "Unsupported protocol $protocol"
     810            }
     811        }
     812    } else {
     813        return -code error "Can't parse url $url"
     814    }
    814815}
    815816
     
    831832    global macports::portdbpath macports::portconf macports::open_mports auto_path
    832833
    833         # Look for an already-open MPort with the same URL.
    834         # XXX: should compare options and variations here too.
    835         # if found, return the existing reference and bump the refcount.
    836         if {$nocache != ""} {
    837                 set mport {}
    838         } else {
    839                 set mport [dlist_search $macports::open_mports porturl $porturl]
    840         }
    841         if {$mport != {}} {
    842                 set refcnt [ditem_key $mport refcnt]
    843                 incr refcnt
    844                 ditem_key $mport refcnt $refcnt
    845                 return $mport
    846         }
    847 
    848         array set options_array $options
    849         if {[info exists options_array(portdir)]} {
    850                 set portdir $options_array(portdir)
    851         } else {
    852                 set portdir ""
    853         }
    854 
    855         set portpath [macports::getportdir $porturl $portdir]
    856         ui_debug "Changing to port directory: $portpath"
    857         cd $portpath
     834    # Look for an already-open MPort with the same URL.
     835    # XXX: should compare options and variations here too.
     836    # if found, return the existing reference and bump the refcount.
     837    if {$nocache != ""} {
     838        set mport {}
     839    } else {
     840        set mport [dlist_search $macports::open_mports porturl $porturl]
     841    }
     842    if {$mport != {}} {
     843        set refcnt [ditem_key $mport refcnt]
     844        incr refcnt
     845        ditem_key $mport refcnt $refcnt
     846        return $mport
     847    }
     848
     849    array set options_array $options
     850    if {[info exists options_array(portdir)]} {
     851        set portdir $options_array(portdir)
     852    } else {
     853        set portdir ""
     854    }
     855
     856    set portpath [macports::getportdir $porturl $portdir]
     857    ui_debug "Changing to port directory: $portpath"
     858    cd $portpath
    858859    if {![file isfile Portfile]} {
    859860        return -code error "Could not find Portfile in $portpath"
    860861    }
    861862
    862         set workername [interp create]
    863 
    864         set mport [ditem_create]
    865         lappend macports::open_mports $mport
    866         ditem_key $mport porturl $porturl
    867         ditem_key $mport portpath $portpath
    868         ditem_key $mport workername $workername
    869         ditem_key $mport options $options
    870         ditem_key $mport variations $variations
    871         ditem_key $mport refcnt 1
    872        
     863    set workername [interp create]
     864
     865    set mport [ditem_create]
     866    lappend macports::open_mports $mport
     867    ditem_key $mport porturl $porturl
     868    ditem_key $mport portpath $portpath
     869    ditem_key $mport workername $workername
     870    ditem_key $mport options $options
     871    ditem_key $mport variations $variations
     872    ditem_key $mport refcnt 1
     873   
    873874    macports::worker_init $workername $portpath [macports::getportbuildpath $portpath] $options $variations
    874875
     
    877878    # evaluate the variants
    878879    if {[$workername eval eval_variants variations] != 0} {
    879         mportclose $mport
    880         error "Error evaluating variants"
     880    mportclose $mport
     881    error "Error evaluating variants"
    881882    }
    882883
     
    892893# with a Portfile file in category/port/
    893894#
    894 # func:         function to call on every port directory (it is passed
    895 #                       category/port/ as its parameter)
    896 # root:         the directory with all the categories directories.
     895# func:     function to call on every port directory (it is passed
     896#           category/port/ as its parameter)
     897# root:     the directory with all the categories directories.
    897898proc mporttraverse {func {root .}} {
    898         # Save the current directory
    899         set pwd [pwd]
    900        
    901         # Join the root.
    902         set pathToRoot [file join $pwd $root]
    903 
    904         # Go to root because some callers expects us to be there.
    905         cd $pathToRoot
     899    # Save the current directory
     900    set pwd [pwd]
     901   
     902    # Join the root.
     903    set pathToRoot [file join $pwd $root]
     904
     905    # Go to root because some callers expects us to be there.
     906    cd $pathToRoot
    906907
    907908    foreach category [lsort -increasing -unique [readdir $root]] {
    908         set pathToCategory [file join $root $category]
     909        set pathToCategory [file join $root $category]
    909910        if {[file isdirectory $pathToCategory]} {
    910                 # Iterate on port directories.
    911                         foreach port [lsort -increasing -unique [readdir $pathToCategory]] {
    912                                 set pathToPort [file join $pathToCategory $port]
    913                                 if {[file isdirectory $pathToPort] &&
    914                                         [file exists [file join $pathToPort "Portfile"]]} {
    915                                         # Call the function.
    916                                         $func [file join $category $port]
    917                                        
    918                                         # Restore the current directory because some
    919                                         # functions changes it.
    920                                         cd $pathToRoot
    921                                 }
    922                         }
    923         }
    924         }
    925        
    926         # Restore the current directory.
    927         cd $pwd
     911            # Iterate on port directories.
     912            foreach port [lsort -increasing -unique [readdir $pathToCategory]] {
     913                set pathToPort [file join $pathToCategory $port]
     914                if {[file isdirectory $pathToPort] &&
     915                    [file exists [file join $pathToPort "Portfile"]]} {
     916                    # Call the function.
     917                    $func [file join $category $port]
     918                   
     919                    # Restore the current directory because some
     920                    # functions changes it.
     921                    cd $pathToRoot
     922                }
     923            }
     924        }
     925    }
     926   
     927    # Restore the current directory.
     928    cd $pwd
    928929}
    929930
     
    933934# search_path -> directories to search
    934935# executable -> whether we want to check that the file is executable by current
    935 #                               user or not.
     936#               user or not.
    936937proc _mportsearchpath {depregex search_path {executable 0}} {
    937938    set found 0
    938939    foreach path $search_path {
    939         if {![file isdirectory $path]} {
    940             continue
    941         }
    942 
    943         if {[catch {set filelist [readdir $path]} result]} {
    944                 return -code error "$result ($path)"
    945                 set filelist ""
    946         }
    947 
    948         foreach filename $filelist {
    949             if {[regexp $depregex $filename] &&
    950                 (($executable == 0) || [file executable [file join $path $filename]])} {
    951                 ui_debug "Found Dependency: path: $path filename: $filename regex: $depregex"
    952                 set found 1
    953                 break
    954             }
    955         }
     940    if {![file isdirectory $path]} {
     941        continue
     942    }
     943
     944    if {[catch {set filelist [readdir $path]} result]} {
     945        return -code error "$result ($path)"
     946        set filelist ""
     947    }
     948
     949    foreach filename $filelist {
     950        if {[regexp $depregex $filename] &&
     951            (($executable == 0) || [file executable [file join $path $filename]])} {
     952        ui_debug "Found Dependency: path: $path filename: $filename regex: $depregex"
     953        set found 1
     954        break
     955        }
     956    }
    956957    }
    957958    return $found
     
    970971proc _libtest {mport depspec} {
    971972    global env tcl_platform
    972         set depline [lindex [split $depspec :] 1]
    973         set prefix [_mportkey $mport prefix]
    974        
    975         if {[info exists env(DYLD_FRAMEWORK_PATH)]} {
    976             lappend search_path $env(DYLD_FRAMEWORK_PATH)
    977         } else {
    978             lappend search_path /Library/Frameworks /Network/Library/Frameworks /System/Library/Frameworks
    979         }
    980         if {[info exists env(DYLD_FALLBACK_FRAMEWORK_PATH)]} {
    981             lappend search_path $env(DYLD_FALLBACK_FRAMEWORK_PATH)
    982         }
    983         if {[info exists env(DYLD_LIBRARY_PATH)]} {
    984             lappend search_path $env(DYLD_LIBRARY_PATH)
    985         }
    986         lappend search_path /lib /usr/lib /usr/X11R6/lib ${prefix}/lib
    987         if {[info exists env(DYLD_FALLBACK_LIBRARY_PATH)]} {
    988             lappend search_path $env(DYLD_FALLBACK_LIBRARY_PATH)
    989         }
    990 
    991         set i [string first . $depline]
    992         if {$i < 0} {set i [string length $depline]}
    993         set depname [string range $depline 0 [expr $i - 1]]
    994         set depversion [string range $depline $i end]
    995         regsub {\.} $depversion {\.} depversion
    996         if {$tcl_platform(os) == "Darwin"} {
    997                 set depregex \^${depname}${depversion}\\.dylib\$
    998         } else {
    999                 set depregex \^${depname}\\.so${depversion}\$
    1000         }
    1001 
    1002         return [_mportsearchpath $depregex $search_path]
     973    set depline [lindex [split $depspec :] 1]
     974    set prefix [_mportkey $mport prefix]
     975   
     976    if {[info exists env(DYLD_FRAMEWORK_PATH)]} {
     977        lappend search_path $env(DYLD_FRAMEWORK_PATH)
     978    } else {
     979        lappend search_path /Library/Frameworks /Network/Library/Frameworks /System/Library/Frameworks
     980    }
     981    if {[info exists env(DYLD_FALLBACK_FRAMEWORK_PATH)]} {
     982        lappend search_path $env(DYLD_FALLBACK_FRAMEWORK_PATH)
     983    }
     984    if {[info exists env(DYLD_LIBRARY_PATH)]} {
     985        lappend search_path $env(DYLD_LIBRARY_PATH)
     986    }
     987    lappend search_path /lib /usr/lib /usr/X11R6/lib ${prefix}/lib
     988    if {[info exists env(DYLD_FALLBACK_LIBRARY_PATH)]} {
     989        lappend search_path $env(DYLD_FALLBACK_LIBRARY_PATH)
     990    }
     991
     992    set i [string first . $depline]
     993    if {$i < 0} {set i [string length $depline]}
     994    set depname [string range $depline 0 [expr $i - 1]]
     995    set depversion [string range $depline $i end]
     996    regsub {\.} $depversion {\.} depversion
     997    if {$tcl_platform(os) == "Darwin"} {
     998        set depregex \^${depname}${depversion}\\.dylib\$
     999    } else {
     1000        set depregex \^${depname}\\.so${depversion}\$
     1001    }
     1002
     1003    return [_mportsearchpath $depregex $search_path]
    10031004}
    10041005
     
    10071008proc _bintest {mport depspec} {
    10081009    global env
    1009         set depregex [lindex [split $depspec :] 1]
    1010         set prefix [_mportkey $mport prefix]
    1011        
    1012         set search_path [split $env(PATH) :]
    1013        
    1014         set depregex \^$depregex\$
    1015        
    1016         return [_mportsearchpath $depregex $search_path 1]
     1010    set depregex [lindex [split $depspec :] 1]
     1011    set prefix [_mportkey $mport prefix]
     1012   
     1013    set search_path [split $env(PATH) :]
     1014   
     1015    set depregex \^$depregex\$
     1016   
     1017    return [_mportsearchpath $depregex $search_path 1]
    10171018}
    10181019
     
    10211022proc _pathtest {mport depspec} {
    10221023    global env
    1023         set depregex [lindex [split $depspec :] 1]
    1024         set prefix [_mportkey $mport prefix]
    1025    
    1026         # separate directory from regex
    1027         set fullname $depregex
    1028 
    1029         regexp {^(.*)/(.*?)$} "$fullname" match search_path depregex
    1030 
    1031         if {[string index $search_path 0] != "/"} {
    1032                 # Prepend prefix if not an absolute path
    1033                 set search_path "${prefix}/${search_path}"
    1034         }
    1035 
    1036         set depregex \^$depregex\$
    1037 
    1038         return [_mportsearchpath $depregex $search_path]
     1024    set depregex [lindex [split $depspec :] 1]
     1025    set prefix [_mportkey $mport prefix]
     1026   
     1027    # separate directory from regex
     1028    set fullname $depregex
     1029
     1030    regexp {^(.*)/(.*?)$} "$fullname" match search_path depregex
     1031
     1032    if {[string index $search_path 0] != "/"} {
     1033        # Prepend prefix if not an absolute path
     1034        set search_path "${prefix}/${search_path}"
     1035    }
     1036
     1037    set depregex \^$depregex\$
     1038
     1039    return [_mportsearchpath $depregex $search_path]
    10391040}
    10401041
     
    10421043
    10431044proc _porttest {mport depspec} {
    1044         # We don't actually look for the port, but just return false
    1045         # in order to let the mportdepends handle the dependency
    1046         return 0
     1045    # We don't actually look for the port, but just return false
     1046    # in order to let the mportdepends handle the dependency
     1047    return 0
    10471048}
    10481049
     
    10511052# Determine if a port is already *installed*, as in "in the registry".
    10521053proc _mportinstalled {mport} {
    1053         # Check for the presense of the port in the registry
    1054         set workername [ditem_key $mport workername]
    1055         set res [$workername eval registry_exists \${portname} \${portversion}]
    1056         if {$res != 0} {
    1057                 ui_debug "[ditem_key $mport provides] is installed"
    1058                 return 1
    1059         } else {
    1060                 return 0
    1061         }
     1054    # Check for the presense of the port in the registry
     1055    set workername [ditem_key $mport workername]
     1056    set res [$workername eval registry_exists \${portname} \${portversion}]
     1057    if {$res != 0} {
     1058        ui_debug "[ditem_key $mport provides] is installed"
     1059        return 1
     1060    } else {
     1061        return 0
     1062    }
    10621063}
    10631064
     
    10671068# We actually start with the registry (faster?)
    10681069#
    1069 # mport         the port to test (to figure out if it's present)
    1070 # depspec       the dependency test specification (path, bin, lib, etc.)
     1070# mport     the port to test (to figure out if it's present)
     1071# depspec   the dependency test specification (path, bin, lib, etc.)
    10711072proc _mportispresent {mport depspec} {
    1072         # Check for the presense of the port in the registry
    1073         set workername [ditem_key $mport workername]
    1074         ui_debug "Searching for dependency: [ditem_key $mport provides]"
    1075         if {[catch {set reslist [$workername eval registry_installed \${portname}]} res]} {
    1076                 set res 0
    1077         } else {
    1078                 set res [llength $reslist]
    1079         }
    1080         if {$res != 0} {
    1081                 ui_debug "Found Dependency: receipt exists for [ditem_key $mport provides]"
    1082                 return 1
    1083         } else {
    1084                 # The receipt test failed, use one of the depspec regex mechanisms
    1085                 ui_debug "Didn't find receipt, going to depspec regex for: [ditem_key $mport provides]"
    1086                 set type [lindex [split $depspec :] 0]
    1087                 switch $type {
    1088                         lib { return [_libtest $mport $depspec] }
    1089                         bin { return [_bintest $mport $depspec] }
    1090                         path { return [_pathtest $mport $depspec] }
    1091                         port { return [_porttest $mport $depspec] }
    1092                         default {return -code error "unknown depspec type: $type"}
    1093                 }
    1094                 return 0
    1095         }
     1073    # Check for the presense of the port in the registry
     1074    set workername [ditem_key $mport workername]
     1075    ui_debug "Searching for dependency: [ditem_key $mport provides]"
     1076    if {[catch {set reslist [$workername eval registry_installed \${portname}]} res]} {
     1077        set res 0
     1078    } else {
     1079        set res [llength $reslist]
     1080    }
     1081    if {$res != 0} {
     1082        ui_debug "Found Dependency: receipt exists for [ditem_key $mport provides]"
     1083        return 1
     1084    } else {
     1085        # The receipt test failed, use one of the depspec regex mechanisms
     1086        ui_debug "Didn't find receipt, going to depspec regex for: [ditem_key $mport provides]"
     1087        set type [lindex [split $depspec :] 0]
     1088        switch $type {
     1089            lib { return [_libtest $mport $depspec] }
     1090            bin { return [_bintest $mport $depspec] }
     1091            path { return [_pathtest $mport $depspec] }
     1092            port { return [_porttest $mport $depspec] }
     1093            default {return -code error "unknown depspec type: $type"}
     1094        }
     1095        return 0
     1096    }
    10961097}
    10971098
     
    10991100
    11001101proc _mportexec {target mport} {
    1101         # xxx: set the work path?
    1102         set workername [ditem_key $mport workername]
    1103         if {![catch {$workername eval check_variants variations $target} result] && $result == 0 &&
    1104                 ![catch {$workername eval eval_targets $target} result] && $result == 0} {
    1105                 # If auto-clean mode, clean-up after dependency install
    1106                 if {[string equal ${macports::portautoclean} "yes"]} {
    1107                         # Make sure we are back in the port path before clean
    1108                         # otherwise if the current directory had been changed to
    1109                         # inside the port,  the next port may fail when trying to
    1110                         # install because [pwd] will return a "no file or directory"
    1111                         # error since the directory it was in is now gone.
    1112                         set portpath [ditem_key $mport portpath]
    1113                         catch {cd $portpath}
    1114                         $workername eval eval_targets clean
    1115                 }
    1116                 return 0
    1117         } else {
    1118                 # An error occurred.
    1119                 return 1
    1120         }
     1102    # xxx: set the work path?
     1103    set workername [ditem_key $mport workername]
     1104    if {![catch {$workername eval check_variants variations $target} result] && $result == 0 &&
     1105        ![catch {$workername eval eval_targets $target} result] && $result == 0} {
     1106        # If auto-clean mode, clean-up after dependency install
     1107        if {[string equal ${macports::portautoclean} "yes"]} {
     1108            # Make sure we are back in the port path before clean
     1109            # otherwise if the current directory had been changed to
     1110            # inside the port,  the next port may fail when trying to
     1111            # install because [pwd] will return a "no file or directory"
     1112            # error since the directory it was in is now gone.
     1113            set portpath [ditem_key $mport portpath]
     1114            catch {cd $portpath}
     1115            $workername eval eval_targets clean
     1116        }
     1117        return 0
     1118    } else {
     1119        # An error occurred.
     1120        return 1
     1121    }
    11211122}
    11221123
     
    11341135    global macports::registry.installtype
    11351136
    1136         set workername [ditem_key $mport workername]
    1137 
    1138         # check variants
    1139         if {[$workername eval check_variants variations $target] != 0} {
    1140                 return 1
    1141         }
    1142        
    1143         # Before we build the port, we must build its dependencies.
    1144         # XXX: need a more general way of comparing against targets
    1145         set dlist {}
    1146         if {$target == "configure" || $target == "build"
    1147                 || $target == "test"
    1148                 || $target == "destroot" || $target == "install"
    1149                 || $target == "archive"
    1150                 || $target == "pkg" || $target == "mpkg"
    1151                 || $target == "rpm" || $target == "dpkg" } {
    1152 
    1153                 if {[mportdepends $mport $target] != 0} {
    1154                         return 1
    1155                 }
    1156                
    1157                 # Select out the dependents along the critical path,
    1158                 # but exclude this mport, we might not be installing it.
    1159                 set dlist [dlist_append_dependents $macports::open_mports $mport {}]
    1160                
    1161                 dlist_delete dlist $mport
    1162 
    1163                 # install them
    1164                 # xxx: as with below, this is ugly.  and deps need to be fixed to
    1165                 # understand Port Images before this can get prettier
    1166                 if { [string equal ${macports::registry.installtype} "image"] } {
    1167                         set result [dlist_eval $dlist _mportinstalled [list _mportexec "activate"]]
    1168                 } else {
    1169                         set result [dlist_eval $dlist _mportinstalled [list _mportexec "install"]]
    1170                 }
    1171                
    1172                 if {$result != {}} {
    1173                         set errstring "The following dependencies failed to build:"
    1174                         foreach ditem $result {
    1175                                 append errstring " [ditem_key $ditem provides]"
    1176                         }
    1177                         ui_error $errstring
    1178                         return 1
    1179                 }
    1180                
    1181                 # Close the dependencies, we're done installing them.
    1182                 foreach ditem $dlist {
    1183                         mportclose $ditem
    1184                 }
    1185         }
    1186 
    1187         # If we're doing an install, check if we should clean after
    1188         set clean 0
    1189         if {[string equal ${macports::portautoclean} "yes"] && [string equal $target "install"] } {
    1190                 set clean 1
    1191         }
    1192 
    1193         # If we're doing image installs, then we should activate after install
    1194         # xxx: This isn't pretty
    1195         if { [string equal ${macports::registry.installtype} "image"] && [string equal $target "install"] } {
    1196                 set target activate
    1197         }
    1198        
    1199         # Build this port with the specified target
    1200         set result [$workername eval eval_targets $target]
    1201 
    1202         # If auto-clean mode and successful install, clean-up after install
    1203         if {$result == 0 && $clean == 1} {
    1204                 # Make sure we are back in the port path, just in case
    1205                 set portpath [ditem_key $mport portpath]
    1206                 catch {cd $portpath}
    1207                 $workername eval eval_targets clean
    1208         }
    1209 
    1210         return $result
     1137    set workername [ditem_key $mport workername]
     1138
     1139    # check variants
     1140    if {[$workername eval check_variants variations $target] != 0} {
     1141        return 1
     1142    }
     1143   
     1144    # Before we build the port, we must build its dependencies.
     1145    # XXX: need a more general way of comparing against targets
     1146    set dlist {}
     1147    if {$target == "configure" || $target == "build"
     1148        || $target == "test"
     1149        || $target == "destroot" || $target == "install"
     1150        || $target == "archive"
     1151        || $target == "pkg" || $target == "mpkg"
     1152        || $target == "rpm" || $target == "dpkg" } {
     1153
     1154        if {[mportdepends $mport $target] != 0} {
     1155            return 1
     1156        }
     1157       
     1158        # Select out the dependents along the critical path,
     1159        # but exclude this mport, we might not be installing it.
     1160        set dlist [dlist_append_dependents $macports::open_mports $mport {}]
     1161       
     1162        dlist_delete dlist $mport
     1163
     1164        # install them
     1165        # xxx: as with below, this is ugly.  and deps need to be fixed to
     1166        # understand Port Images before this can get prettier
     1167        if { [string equal ${macports::registry.installtype} "image"] } {
     1168            set result [dlist_eval $dlist _mportinstalled [list _mportexec "activate"]]
     1169        } else {
     1170            set result [dlist_eval $dlist _mportinstalled [list _mportexec "install"]]
     1171        }
     1172       
     1173        if {$result != {}} {
     1174            set errstring "The following dependencies failed to build:"
     1175            foreach ditem $result {
     1176                append errstring " [ditem_key $ditem provides]"
     1177            }
     1178            ui_error $errstring
     1179            return 1
     1180        }
     1181       
     1182        # Close the dependencies, we're done installing them.
     1183        foreach ditem $dlist {
     1184            mportclose $ditem
     1185        }
     1186    }
     1187
     1188    # If we're doing an install, check if we should clean after
     1189    set clean 0
     1190    if {[string equal ${macports::portautoclean} "yes"] && [string equal $target "install"] } {
     1191        set clean 1
     1192    }
     1193
     1194    # If we're doing image installs, then we should activate after install
     1195    # xxx: This isn't pretty
     1196    if { [string equal ${macports::registry.installtype} "image"] && [string equal $target "install"] } {
     1197        set target activate
     1198    }
     1199   
     1200    # Build this port with the specified target
     1201    set result [$workername eval eval_targets $target]
     1202
     1203    # If auto-clean mode and successful install, clean-up after install
     1204    if {$result == 0 && $clean == 1} {
     1205        # Make sure we are back in the port path, just in case
     1206        set portpath [ditem_key $mport portpath]
     1207        catch {cd $portpath}
     1208        $workername eval eval_targets clean
     1209    }
     1210
     1211    return $result
    12111212}
    12121213
     
    12181219
    12191220proc macports::getportbuildpath {id} {
    1220         global macports::portdbpath
    1221         regsub {://} $id {.} port_path
    1222         regsub -all {/} $port_path {_} port_path
    1223         return [file join $portdbpath build $port_path]
     1221    global macports::portdbpath
     1222    regsub {://} $id {.} port_path
     1223    regsub -all {/} $port_path {_} port_path
     1224    return [file join $portdbpath build $port_path]
    12241225}
    12251226
     
    12331234
    12341235proc macports::getindex {source} {
    1235         # Special case file:// sources
    1236         if {[macports::getprotocol $source] == "file"} {
    1237                 return [file join [macports::getportdir $source] PortIndex]
    1238         }
    1239 
    1240         return [file join [macports::getsourcepath $source] PortIndex]
     1236    # Special case file:// sources
     1237    if {[macports::getprotocol $source] == "file"} {
     1238        return [file join [macports::getportdir $source] PortIndex]
     1239    }
     1240
     1241    return [file join [macports::getsourcepath $source] PortIndex]
    12411242}
    12421243
     
    12551256    ui_debug "Synchronizing ports tree(s)"
    12561257    foreach source $sources {
    1257         set flags [lrange $source 1 end]
    1258         set source [lindex $source 0]
    1259         if {[lsearch -exact $flags nosync] != -1} {
    1260             ui_debug "Skipping $source"
    1261             continue
    1262         }
    1263         ui_info "Synchronizing from $source"
    1264         switch -regexp -- [macports::getprotocol $source] {
    1265             {^file$} {
    1266                 set portdir [macports::getportdir $source]
    1267                 if {[file exists $portdir/.svn]} {
    1268                     set svn_commandline "[macports::findBinary svn ${macports::autoconf::svn_path}] update --non-interactive ${portdir}"
    1269                     ui_debug $svn_commandline
    1270                     if {[catch {
    1271                         set euid [geteuid]
    1272                         set egid [getegid]
    1273                         ui_debug "changing euid/egid - current euid: $euid - current egid: $egid"
    1274                         setegid [name_to_gid [file attributes $portdir -group]]
    1275                         seteuid [name_to_uid [file attributes $portdir -owner]]
    1276                         system $svn_commandline
    1277                         seteuid $euid
    1278                         setegid $egid
    1279                     }]} {
    1280                         ui_debug "$::errorInfo"
    1281                         return -code error "sync failed doing svn update"
    1282                     }
    1283                 }
    1284             }
    1285             {^mports$} {
    1286                 macports::index::sync $macports::portdbpath $source
    1287             }
    1288             {^rsync$} {
    1289                 # Where to, boss?
    1290                 set destdir [file dirname [macports::getindex $source]]
    1291 
    1292                 file mkdir $destdir
    1293                
    1294                 # Keep rsync happy with a trailing slash
    1295                 if {[string index $source end] != "/"} {
    1296                     set source "${source}/"
    1297                 }
    1298 
    1299                 # Do rsync fetch
    1300                 set rsync_commandline "${macports::autoconf::rsync_path} ${rsync_options} ${source} ${destdir}"
    1301                 ui_debug $rsync_commandline
    1302                 if {[catch {system $rsync_commandline}]} {
    1303                     return -code error "sync failed doing rsync"
    1304                 }
    1305                 if {[catch {system "chmod -R a+r \"$destdir\""}]} {
    1306                     ui_warn "Setting world read permissions on parts of the ports tree failed, need root?"
    1307                 }
    1308             }
    1309             {^https?$|^ftp$} {
    1310                 set indexfile [macports::getindex $source]
    1311                 file mkdir [file dirname $indexfile]
    1312                 exec curl -L -s -S -o $indexfile $source/PortIndex
    1313             }
    1314             default {
    1315                 ui_warn "Unknown protocol for $source"
    1316             }
    1317         }
     1258    set flags [lrange $source 1 end]
     1259    set source [lindex $source 0]
     1260    if {[lsearch -exact $flags nosync] != -1} {
     1261        ui_debug "Skipping $source"
     1262        continue
     1263    }
     1264    ui_info "Synchronizing from $source"
     1265    switch -regexp -- [macports::getprotocol $source] {
     1266        {^file$} {
     1267        set portdir [macports::getportdir $source]
     1268        if {[file exists $portdir/.svn]} {
     1269            set svn_commandline "[macports::findBinary svn ${macports::autoconf::svn_path}] update --non-interactive ${portdir}"
     1270            ui_debug $svn_commandline
     1271            if {[catch {
     1272            set euid [geteuid]
     1273            set egid [getegid]
     1274            ui_debug "changing euid/egid - current euid: $euid - current egid: $egid"
     1275            setegid [name_to_gid [file attributes $portdir -group]]
     1276            seteuid [name_to_uid [file attributes $portdir -owner]]
     1277            system $svn_commandline
     1278            seteuid $euid
     1279            setegid $egid
     1280            }]} {
     1281            ui_debug "$::errorInfo"
     1282            return -code error "sync failed doing svn update"
     1283            }
     1284        }
     1285        }
     1286        {^mports$} {
     1287        macports::index::sync $macports::portdbpath $source
     1288        }
     1289        {^rsync$} {
     1290        # Where to, boss?
     1291        set destdir [file dirname [macports::getindex $source]]
     1292
     1293        file mkdir $destdir
     1294       
     1295        # Keep rsync happy with a trailing slash
     1296        if {[string index $source end] != "/"} {
     1297            set source "${source}/"
     1298        }
     1299
     1300        # Do rsync fetch
     1301        set rsync_commandline "${macports::autoconf::rsync_path} ${rsync_options} ${source} ${destdir}"
     1302        ui_debug $rsync_commandline
     1303        if {[catch {system $rsync_commandline}]} {
     1304            return -code error "sync failed doing rsync"
     1305        }
     1306        if {[catch {system "chmod -R a+r \"$destdir\""}]} {
     1307            ui_warn "Setting world read permissions on parts of the ports tree failed, need root?"
     1308        }
     1309        }
     1310        {^https?$|^ftp$} {
     1311        set indexfile [macports::getindex $source]
     1312        file mkdir [file dirname $indexfile]
     1313        exec curl -L -s -S -o $indexfile $source/PortIndex
     1314        }
     1315        default {
     1316        ui_warn "Unknown protocol for $source"
     1317        }
     1318    }
    13181319    }
    13191320}
     
    13281329
    13291330proc mportsearch {pattern {case_sensitive yes} {matchstyle regexp} {field name}} {
    1330         global macports::portdbpath macports::sources
    1331         set matches [list]
    1332         set easy [expr { $field == "name" }]
    1333        
    1334         set found 0
    1335         foreach source $sources {
    1336                 set flags [lrange $source 1 end]
    1337                 set source [lindex $source 0]
    1338                 if {[macports::getprotocol $source] == "mports"} {
    1339                         array set attrs [list name $pattern]
    1340                         set res [macports::index::search $macports::portdbpath $source [array get attrs]]
    1341                         eval lappend matches $res
    1342                 } else {
    1343                         if {[catch {set fd [open [macports::getindex $source] r]} result]} {
    1344                                 ui_warn "Can't open index file for source: $source"
    1345                         } else {
    1346                             try {
    1347                                 incr found 1
    1348                                 while {[gets $fd line] >= 0} {
    1349                                         array unset portinfo
    1350                                         set name [lindex $line 0]
    1351                                         set len [lindex $line 1]
    1352                                         set line [read $fd $len]
    1353 
    1354                                                 if {$easy} {
    1355                                                     set target $name
    1356                                                 } else {
    1357                                                         array set portinfo $line
    1358                                                     if {![info exists portinfo($field)]} continue
    1359                                                     set target $portinfo($field)
    1360                                                 }
    1361 
    1362                                     switch $matchstyle {
    1363                                         exact { set matchres [expr 0 == ( {$case_sensitive == "yes"} ? [string compare $pattern $target] : [string compare -nocase $pattern $target] )] }
    1364                                         glob { set matchres [expr {$case_sensitive == "yes"} ? [string match $pattern $target] : [string match -nocase $pattern $target]] }
    1365                                         regexp -
    1366                                         default { set matchres [expr {$case_sensitive == "yes"} ? [regexp -- $pattern $target] : [regexp -nocase -- $pattern $target]] }
    1367                                     }
    1368 
    1369                                     if {$matchres == 1} {
    1370                                         if {$easy} {
    1371                                             array set portinfo $line
    1372                                         }
    1373                                         switch -regexp -- [macports::getprotocol ${source}] {
    1374                                             {^rsync$} {
    1375                                                 # Rsync files are local
    1376                                                 set source_url "file://[macports::getsourcepath $source]"
    1377                                             }
    1378                                             default {
    1379                                                 set source_url $source
    1380                                             }
    1381                                         }
    1382                                         if {[info exists portinfo(portarchive)]} {
    1383                                             set porturl ${source_url}/$portinfo(portarchive)
    1384                                         } elseif {[info exists portinfo(portdir)]} {
    1385                                             set porturl ${source_url}/$portinfo(portdir)
    1386                                         }
    1387                                         if {[info exists porturl]} {
    1388                                             lappend line porturl $porturl
    1389                                             ui_debug "Found port in $porturl"
    1390                                         } else {
    1391                                             ui_debug "Found port info: $line"
    1392                                         }
    1393                                         lappend matches $name
    1394                                         lappend matches $line
    1395                                     }
    1396                                 }
    1397                             } catch {*} {
    1398                                 ui_warn "It looks like your PortIndex file may be corrupt."
    1399                                 throw
    1400                             } finally {
    1401                                 close $fd
    1402                             }
    1403                         }
    1404                 }
    1405         }
    1406         if {!$found} {
    1407                 return -code error "No index(es) found! Have you synced your source indexes?"
    1408         }
    1409 
    1410         return $matches
     1331    global macports::portdbpath macports::sources
     1332    set matches [list]
     1333    set easy [expr { $field == "name" }]
     1334   
     1335    set found 0
     1336    foreach source $sources {
     1337            set flags [lrange $source 1 end]
     1338            set source [lindex $source 0]
     1339        if {[macports::getprotocol $source] == "mports"} {
     1340            array set attrs [list name $pattern]
     1341            set res [macports::index::search $macports::portdbpath $source [array get attrs]]
     1342            eval lappend matches $res
     1343        } else {
     1344            if {[catch {set fd [open [macports::getindex $source] r]} result]} {
     1345                ui_warn "Can't open index file for source: $source"
     1346            } else {
     1347                try {
     1348                incr found 1
     1349                while {[gets $fd line] >= 0} {
     1350                    array unset portinfo
     1351                    set name [lindex $line 0]
     1352                        set len [lindex $line 1]
     1353                        set line [read $fd $len]
     1354
     1355                        if {$easy} {
     1356                            set target $name
     1357                        } else {
     1358                            array set portinfo $line
     1359                            if {![info exists portinfo($field)]} continue
     1360                            set target $portinfo($field)
     1361                        }
     1362
     1363                    switch $matchstyle {
     1364                    exact { set matchres [expr 0 == ( {$case_sensitive == "yes"} ? [string compare $pattern $target] : [string compare -nocase $pattern $target] )] }
     1365                    glob { set matchres [expr {$case_sensitive == "yes"} ? [string match $pattern $target] : [string match -nocase $pattern $target]] }
     1366                    regexp -
     1367                    default { set matchres [expr {$case_sensitive == "yes"} ? [regexp -- $pattern $target] : [regexp -nocase -- $pattern $target]] }
     1368                    }
     1369
     1370                    if {$matchres == 1} {
     1371                    if {$easy} {
     1372                        array set portinfo $line
     1373                    }
     1374                    switch -regexp -- [macports::getprotocol ${source}] {
     1375                        {^rsync$} {
     1376                        # Rsync files are local
     1377                        set source_url "file://[macports::getsourcepath $source]"
     1378                        }
     1379                        default {
     1380                        set source_url $source
     1381                        }
     1382                    }
     1383                    if {[info exists portinfo(portarchive)]} {
     1384                        set porturl ${source_url}/$portinfo(portarchive)
     1385                    } elseif {[info exists portinfo(portdir)]} {
     1386                        set porturl ${source_url}/$portinfo(portdir)
     1387                    }
     1388                    if {[info exists porturl]} {
     1389                        lappend line porturl $porturl
     1390                        ui_debug "Found port in $porturl"
     1391                    } else {
     1392                        ui_debug "Found port info: $line"
     1393                    }
     1394                    lappend matches $name
     1395                    lappend matches $line
     1396                    }
     1397                }
     1398                } catch {*} {
     1399                ui_warn "It looks like your PortIndex file may be corrupt."
     1400                throw
     1401                } finally {
     1402                close $fd
     1403                }
     1404            }
     1405        }
     1406    }
     1407    if {!$found} {
     1408        return -code error "No index(es) found! Have you synced your source indexes?"
     1409    }
     1410
     1411    return $matches
    14111412}
    14121413
     
    14201421
    14211422proc mportinfo {mport} {
    1422         set workername [ditem_key $mport workername]
     1423    set workername [ditem_key $mport workername]
    14231424    return [$workername eval array get PortInfo]
    14241425}
     
    14331434
    14341435proc mportclose {mport} {
    1435         global macports::open_mports
    1436         set refcnt [ditem_key $mport refcnt]
    1437         incr refcnt -1
    1438         ditem_key $mport refcnt $refcnt
    1439         if {$refcnt == 0} {
    1440                 dlist_delete macports::open_mports $mport
    1441                 set workername [ditem_key $mport workername]
    1442                 interp delete $workername
    1443         }
     1436    global macports::open_mports
     1437    set refcnt [ditem_key $mport refcnt]
     1438    incr refcnt -1
     1439    ditem_key $mport refcnt $refcnt
     1440    if {$refcnt == 0} {
     1441        dlist_delete macports::open_mports $mport
     1442        set workername [ditem_key $mport workername]
     1443        interp delete $workername
     1444    }
    14441445}
    14451446
     
    14521453
    14531454proc _mportkey {mport key} {
    1454         set workername [ditem_key $mport workername]
    1455         return [$workername eval "return \$${key}"]
     1455    set workername [ditem_key $mport workername]
     1456    return [$workername eval "return \$${key}"]
    14561457}
    14571458
     
    14731474proc mportdepends {mport {target ""} {recurseDeps 1} {skipSatisfied 1} {accDeps {}}} {
    14741475
    1475         array set portinfo [mportinfo $mport]
    1476         set depends {}
    1477         set deptypes {}
    1478                
    1479         # Determine deptypes to look for based on target
    1480         switch $target {
    1481                 configure       { set deptypes "depends_lib" }
    1482                
    1483                 build           { set deptypes "depends_lib depends_build" }
    1484                
    1485                 test            -
    1486                 destroot        -
    1487                 install         -
    1488                 archive         -
    1489                 pkg                     -
    1490                 mpkg            -
    1491                 rpm             -
    1492                 dpkg            -
    1493                 ""                      { set deptypes "depends_lib depends_build depends_run" }
    1494         }
    1495        
    1496         # Gather the dependencies for deptypes
    1497         foreach deptype $deptypes {
    1498                 # Add to the list of dependencies if the option exists and isn't empty.
    1499                 if {[info exists portinfo($deptype)] && $portinfo($deptype) != ""} {
    1500                         set depends [concat $depends $portinfo($deptype)]
    1501                 }
    1502         }
    1503 
    1504         set subPorts {}
    1505        
    1506         foreach depspec $depends {
    1507                 # grab the portname portion of the depspec
    1508                 set dep_portname [lindex [split $depspec :] end]
    1509                
    1510                 # Find the porturl
    1511                 if {[catch {set res [mportsearch $dep_portname false exact]} error]} {
    1512                         global errorInfo
    1513                         ui_debug "$errorInfo"
    1514                         ui_error "Internal error: port search failed: $error"
    1515                         return 1
    1516                 }
    1517                 foreach {name array} $res {
    1518                         array set portinfo $array
    1519                         if {[info exists portinfo(porturl)]} {
    1520                                 set porturl $portinfo(porturl)
    1521                                 break
    1522                         }
    1523                 }
    1524 
    1525                 if {![info exists porturl]} {
    1526                         ui_error "Dependency '$dep_portname' not found."
    1527                         return 1
    1528                 }
    1529 
    1530                 set options [ditem_key $mport options]
    1531                 set variations [ditem_key $mport variations]
    1532 
    1533                 # Figure out the subport.       
    1534                 set subport [mportopen $porturl $options $variations]
    1535 
    1536                 # Is that dependency satisfied or this port installed?
    1537                 # If we don't skip or if it is not, add it to the list.
    1538                 if {!$skipSatisfied || ![_mportispresent $subport $depspec]} {
    1539                         # Append the sub-port's provides to the port's requirements list.
    1540                         ditem_append_unique $mport requires "[ditem_key $subport provides]"
    1541        
    1542                         if {$recurseDeps} {
    1543                                 # Skip the port if it's already in the accumulated list.
    1544                                 if {[lsearch $accDeps $dep_portname] == -1} {
    1545                                         # Add it to the list
    1546                                         lappend accDeps $dep_portname
    1547                                
    1548                                         # We'll recursively iterate on it.
    1549                                         lappend subPorts $subport
    1550                                 }
    1551                         }
    1552                 }
    1553         }
    1554 
    1555         # Loop on the subports.
    1556         if {$recurseDeps} {
    1557                 foreach subport $subPorts {
    1558                         # Sub ports should be installed (all dependencies must be satisfied).
    1559                         set res [mportdepends $subport "" $recurseDeps $skipSatisfied $accDeps]
    1560                         if {$res != 0} {
    1561                                 return $res
    1562                         }
    1563                 }
    1564         }
    1565        
    1566         return 0
     1476    array set portinfo [mportinfo $mport]
     1477    set depends {}
     1478    set deptypes {}
     1479       
     1480    # Determine deptypes to look for based on target
     1481    switch $target {
     1482        configure   { set deptypes "depends_lib" }
     1483       
     1484        build       { set deptypes "depends_lib depends_build" }
     1485       
     1486        test        -
     1487        destroot    -
     1488        install     -
     1489        archive     -
     1490        pkg         -
     1491        mpkg        -
     1492                rpm         -
     1493        dpkg        -
     1494        ""          { set deptypes "depends_lib depends_build depends_run" }
     1495    }
     1496   
     1497    # Gather the dependencies for deptypes
     1498    foreach deptype $deptypes {
     1499        # Add to the list of dependencies if the option exists and isn't empty.
     1500        if {[info exists portinfo($deptype)] && $portinfo($deptype) != ""} {
     1501            set depends [concat $depends $portinfo($deptype)]
     1502        }
     1503    }
     1504
     1505    set subPorts {}
     1506   
     1507    foreach depspec $depends {
     1508        # grab the portname portion of the depspec
     1509        set dep_portname [lindex [split $depspec :] end]
     1510       
     1511        # Find the porturl
     1512        if {[catch {set res [mportsearch $dep_portname false exact]} error]} {
     1513            global errorInfo
     1514            ui_debug "$errorInfo"
     1515            ui_error "Internal error: port search failed: $error"
     1516            return 1
     1517        }
     1518        foreach {name array} $res {
     1519            array set portinfo $array
     1520            if {[info exists portinfo(porturl)]} {
     1521                set porturl $portinfo(porturl)
     1522                break
     1523            }
     1524        }
     1525
     1526        if {![info exists porturl]} {
     1527            ui_error "Dependency '$dep_portname' not found."
     1528            return 1
     1529        }
     1530
     1531        set options [ditem_key $mport options]
     1532        set variations [ditem_key $mport variations]
     1533
     1534        # Figure out the subport.   
     1535        set subport [mportopen $porturl $options $variations]
     1536
     1537        # Is that dependency satisfied or this port installed?
     1538        # If we don't skip or if it is not, add it to the list.
     1539        if {!$skipSatisfied || ![_mportispresent $subport $depspec]} {
     1540            # Append the sub-port's provides to the port's requirements list.
     1541            ditem_append_unique $mport requires "[ditem_key $subport provides]"
     1542   
     1543            if {$recurseDeps} {
     1544                # Skip the port if it's already in the accumulated list.
     1545                if {[lsearch $accDeps $dep_portname] == -1} {
     1546                    # Add it to the list
     1547                    lappend accDeps $dep_portname
     1548               
     1549                    # We'll recursively iterate on it.
     1550                    lappend subPorts $subport
     1551                }
     1552            }
     1553        }
     1554    }
     1555
     1556    # Loop on the subports.
     1557    if {$recurseDeps} {
     1558        foreach subport $subPorts {
     1559            # Sub ports should be installed (all dependencies must be satisfied).
     1560            set res [mportdepends $subport "" $recurseDeps $skipSatisfied $accDeps]
     1561            if {$res != 0} {
     1562                return $res
     1563            }
     1564        }
     1565    }
     1566   
     1567    return 0
    15671568}
    15681569
    15691570# selfupdate procedure
    15701571proc macports::selfupdate {{optionslist {}}} {
    1571         global macports::prefix macports::portdbpath macports::rsync_server macports::rsync_dir macports::rsync_options
    1572         global macports::autoconf::macports_conf_path macports::autoconf::rsync_path
    1573         array set options $optionslist
    1574        
    1575         if { [info exists options(ports_force)] && $options(ports_force) == "yes" } {
    1576                 set use_the_force_luke yes
    1577                 ui_debug "Forcing a rebuild of the MacPorts base system."
    1578         } else {
    1579                 set use_the_force_luke no
    1580                 ui_debug "Rebuilding the MacPorts base system if needed."
    1581         }
    1582         # syncing ports tree. We expect the user have rsync:// in the sources.conf
    1583         if {[catch {mportsync} result]} {
    1584                 return -code error "Couldn't sync the ports tree: $result"
    1585         }
    1586 
    1587         set mp_base_path [file join $portdbpath sources ${rsync_server} ${rsync_dir}/]
    1588         if {![file exists $mp_base_path]} {
    1589                 file mkdir $mp_base_path
    1590         }
    1591         ui_debug "MacPorts base dir: $mp_base_path"
    1592 
    1593         # get user of the MacPorts system
    1594         set user [file attributes [file join $portdbpath sources/] -owner]
    1595         ui_debug "Setting user: $user"
    1596 
    1597         # get MacPorts version
     1572    global macports::prefix macports::portdbpath macports::rsync_server macports::rsync_dir macports::rsync_options
     1573    global macports::autoconf::macports_conf_path macports::autoconf::rsync_path
     1574    array set options $optionslist
     1575   
     1576    if { [info exists options(ports_force)] && $options(ports_force) == "yes" } {
     1577        set use_the_force_luke yes
     1578        ui_debug "Forcing a rebuild of the MacPorts base system."
     1579    } else {
     1580        set use_the_force_luke no
     1581        ui_debug "Rebuilding the MacPorts base system if needed."
     1582    }
     1583    # syncing ports tree. We expect the user have rsync:// in the sources.conf
     1584    if {[catch {mportsync} result]} {
     1585        return -code error "Couldn't sync the ports tree: $result"
     1586    }
     1587
     1588    set mp_base_path [file join $portdbpath sources ${rsync_server} ${rsync_dir}/]
     1589    if {![file exists $mp_base_path]} {
     1590        file mkdir $mp_base_path
     1591    }
     1592    ui_debug "MacPorts base dir: $mp_base_path"
     1593
     1594    # get user of the MacPorts system
     1595    set user [file attributes [file join $portdbpath sources/] -owner]
     1596    ui_debug "Setting user: $user"
     1597
     1598    # get MacPorts version
    15981599    set mp_version_path [file join ${macports_conf_path} mp_version]
    1599         if { [file exists $mp_version_path]} {
    1600                 set fd [open $mp_version_path r]
    1601                 gets $fd mp_version_old
    1602                 close $fd
    1603         } else {
    1604                 set mp_version_old 0
    1605         }
    1606         ui_msg "MacPorts base version $mp_version_old installed"
    1607 
    1608         ui_debug "Updating using rsync"
    1609         if { [catch { system "$rsync_path $rsync_options rsync://${rsync_server}/${rsync_dir} $mp_base_path" } ] } {
    1610                 return -code error "Error: rsync failed in selfupdate"
    1611         }
    1612 
    1613         # get downloaded macports version and write the old version back
    1614         set fd [open [file join $mp_base_path config mp_version] r]
    1615         gets $fd mp_version_new
    1616         close $fd
    1617         ui_msg "Downloaded MacPorts base version $mp_version_new"
    1618 
    1619         # check if we we need to rebuild base
    1620         if {$mp_version_new > $mp_version_old || $use_the_force_luke == "yes"} {
    1621                 ui_msg "Configuring, Building and Installing new MacPorts base"
    1622                 # check if $prefix/bin/port is writable, if so we go !
    1623                 # get installation user / group
    1624                 set owner root
    1625                 set group admin
    1626                 set portprog [file join $prefix bin port]
    1627                 if {[file exists $portprog ]} {
    1628                         # set owner
    1629                         set owner [file attributes $portprog -owner]
    1630                         # set group
    1631                         set group [file attributes $portprog -group]
    1632                 }
    1633                 set p_user [exec /usr/bin/whoami]
    1634                 if {[file writable $portprog] || [string equal $p_user $owner] } {
    1635                         ui_debug "permissions OK"
    1636                 } else {
    1637                         return -code error "Error: $p_user cannot write to ${prefix}/bin - try using sudo"
    1638                 }
    1639                 ui_debug "Setting owner: $owner group: $group"
    1640 
    1641                 set mp_tclpackage_path [file join $portdbpath .tclpackage]
    1642                 if { [file exists $mp_tclpackage_path]} {
    1643                         set fd [open $mp_tclpackage_path r]
    1644                         gets $fd tclpackage
    1645                         close $fd
    1646                 } else {
    1647                         set tclpackage [file join ${prefix} share macports Tcl]
    1648                 }
    1649                 # do the actual installation of new base
    1650                 ui_debug "Install in: $prefix as $owner : $group - TCL-PACKAGE in $tclpackage"
    1651                 if { [catch { system "cd $mp_base_path && ./configure --prefix=$prefix --with-install-user=$owner --with-install-group=$group --with-tclpackage=$tclpackage && make && make install" } result] } {
    1652                         return -code error "Error installing new MacPorts base: $result"
    1653                 }
    1654         } else {
    1655                 ui_msg "The MacPorts installation is not outdated and so was not updated"
    1656         }
    1657 
    1658         # set the macports system to the right owner
    1659         ui_debug "Setting ownership to $user"
    1660         if { [catch { exec chown -R $user [file join $portdbpath sources/] } result] } {
    1661                 return -code error "Couldn't change permissions: $result"
    1662         }
    1663 
    1664         # set the right version
    1665         ui_msg "selfupdate done!"
    1666 
    1667         return 0
     1600    if { [file exists $mp_version_path]} {
     1601        set fd [open $mp_version_path r]
     1602        gets $fd mp_version_old
     1603        close $fd
     1604    } else {
     1605        set mp_version_old 0
     1606    }
     1607    ui_msg "MacPorts base version $mp_version_old installed"
     1608
     1609    ui_debug "Updating using rsync"
     1610    if { [catch { system "$rsync_path $rsync_options rsync://${rsync_server}/${rsync_dir} $mp_base_path" } ] } {
     1611        return -code error "Error: rsync failed in selfupdate"
     1612    }
     1613
     1614    # get downloaded macports version and write the old version back
     1615    set fd [open [file join $mp_base_path config mp_version] r]
     1616    gets $fd mp_version_new
     1617    close $fd
     1618    ui_msg "Downloaded MacPorts base version $mp_version_new"
     1619
     1620    # check if we we need to rebuild base
     1621    if {$mp_version_new > $mp_version_old || $use_the_force_luke == "yes"} {
     1622        ui_msg "Configuring, Building and Installing new MacPorts base"
     1623        # check if $prefix/bin/port is writable, if so we go !
     1624        # get installation user / group
     1625        set owner root
     1626        set group admin
     1627            set portprog [file join $prefix bin port]
     1628        if {[file exists $portprog ]} {
     1629            # set owner
     1630            set owner [file attributes $portprog -owner]
     1631            # set group
     1632            set group [file attributes $portprog -group]
     1633        }
     1634        set p_user [exec /usr/bin/whoami]
     1635        if {[file writable $portprog] || [string equal $p_user $owner] } {
     1636            ui_debug "permissions OK"
     1637        } else {
     1638            return -code error "Error: $p_user cannot write to ${prefix}/bin - try using sudo"
     1639        }
     1640        ui_debug "Setting owner: $owner group: $group"
     1641
     1642        set mp_tclpackage_path [file join $portdbpath .tclpackage]
     1643        if { [file exists $mp_tclpackage_path]} {
     1644            set fd [open $mp_tclpackage_path r]
     1645            gets $fd tclpackage
     1646            close $fd
     1647        } else {
     1648            set tclpackage [file join ${prefix} share macports Tcl]
     1649        }
     1650        # do the actual installation of new base
     1651        ui_debug "Install in: $prefix as $owner : $group - TCL-PACKAGE in $tclpackage"
     1652        if { [catch { system "cd $mp_base_path && ./configure --prefix=$prefix --with-install-user=$owner --with-install-group=$group --with-tclpackage=$tclpackage && make && make install" } result] } {
     1653            return -code error "Error installing new MacPorts base: $result"
     1654        }
     1655    } else {
     1656        ui_msg "The MacPorts installation is not outdated and so was not updated"
     1657    }
     1658
     1659    # set the macports system to the right owner
     1660    ui_debug "Setting ownership to $user"
     1661    if { [catch { exec chown -R $user [file join $portdbpath sources/] } result] } {
     1662        return -code error "Couldn't change permissions: $result"
     1663    }
     1664
     1665    # set the right version
     1666    ui_msg "selfupdate done!"
     1667
     1668    return 0
    16681669}
    16691670
    16701671proc macports::version {} {
    1671         global macports::rsync_server macports::rsync_dir
     1672    global macports::rsync_server macports::rsync_dir
    16721673        global macports::autoconf::macports_conf_path
    1673        
     1674   
    16741675    set mp_version_path [file join ${macports_conf_path} mp_version]
    16751676
    1676         if [file exists $mp_version_path] {
    1677                 set fd [open $mp_version_path r]
    1678                 gets $fd retval
    1679                 close $fd
    1680                 return $retval
    1681         } else {
    1682                 return -1
    1683         }
     1677    if [file exists $mp_version_path] {
     1678        set fd [open $mp_version_path r]
     1679        gets $fd retval
     1680            close $fd
     1681        return $retval
     1682    } else {
     1683        return -1
     1684    }
    16841685}
    16851686
    16861687# upgrade procedure
    16871688proc macports::upgrade {portname dspec variationslist optionslist {depscachename ""}} {
    1688         global macports::registry.installtype
    1689         global macports::portarchivemode
    1690         array set options $optionslist
    1691         array set variations $variationslist
    1692         if {![string match "" $depscachename]} {
    1693                 upvar $depscachename depscache
    1694         }
    1695 
    1696         # set to no-zero is epoch overrides version
    1697         set epoch_override 0
    1698 
    1699         # check if the port is in tree
    1700         if {[catch {mportsearch $portname false exact} result]} {
    1701                 global errorInfo
    1702                 ui_debug "$errorInfo"
    1703                 ui_error "port search failed: $result"
    1704                 return 1
    1705         }
    1706         # argh! port doesnt exist!
    1707         if {$result == ""} {
    1708                 ui_error "No port $portname found."
    1709                 return 1
    1710         }
    1711         # fill array with information
    1712         array set portinfo [lindex $result 1]
    1713 
    1714         # set version_in_tree and revision_in_tree
    1715         if {![info exists portinfo(version)]} {
    1716                 ui_error "Invalid port entry for $portname, missing version"
    1717                 return 1
    1718         }
    1719         set version_in_tree "$portinfo(version)"
    1720         set revision_in_tree "$portinfo(revision)"
    1721         set epoch_in_tree "$portinfo(epoch)"
    1722 
    1723         # the depflag tells us if we should follow deps (this is for stuff installed outside MacPorts)
    1724         # if this is set (not 0) we dont follow the deps
    1725         set depflag 0
    1726 
    1727         # set version_installed and revision_installed
    1728         set ilist {}
    1729         if { [catch {set ilist [registry::installed $portname ""]} result] } {
    1730                 if {$result == "Registry error: $portname not registered as installed." } {
    1731                         ui_debug "$portname is *not* installed by MacPorts"
    1732                         # open porthandle   
    1733                         set porturl $portinfo(porturl)
    1734                     if {![info exists porturl]} {
    1735                         set porturl file://./   
    1736                         }   
    1737                         if {[catch {set workername [mportopen $porturl [array get options] ]} result]} {
    1738                                         global errorInfo
    1739                                         ui_debug "$errorInfo"
    1740                                 ui_error "Unable to open port: $result"       
    1741                                         return 1
    1742                     }
    1743 
    1744                         if {![_mportispresent $workername $dspec ] } {
    1745                                 # port in not installed - install it!
    1746                                 if {[catch {set result [mportexec $workername install]} result]} {
    1747                                         global errorInfo
    1748                                         ui_debug "$errorInfo"
    1749                                         ui_error "Unable to exec port: $result"
    1750                                         return 1
    1751                                 }
    1752                         } else {
    1753                                 # port installed outside MacPorts
    1754                                 ui_debug "$portname installed outside the MacPorts system"
    1755                                 set depflag 1
    1756                         }
    1757 
    1758                 } else {
    1759                         ui_error "Checking installed version failed: $result"
    1760                         exit 1
    1761                 }
    1762         }
    1763         set anyactive 0
    1764         set version_installed {}
    1765         set revision_installed {}
    1766         set epoch_installed 0
    1767         if {$ilist == ""} {
    1768                 # XXX  this sets $version_installed to $version_in_tree even if not installed!!
    1769                 set version_installed $version_in_tree
    1770                 set revision_installed $revision_in_tree
    1771                 # That was a very dirty hack showing how ugly our depencendy and upgrade code is.
    1772                 # To get it working when user provides -f, we also need to set the variant to
    1773                 # avoid a future failure.
    1774                 set variant ""
    1775         } else {
    1776                 # a port could be installed but not activated
    1777                 # so, deactivate all and save newest for activation later
    1778                 set num 0
    1779                 set variant ""
    1780                 foreach i $ilist {
    1781                         set variant [lindex $i 3]
    1782                         set version [lindex $i 1]
    1783                         set revision [lindex $i 2]
    1784                         if { $version_installed == {} ||
    1785                                         [rpm-vercomp $version $version_installed] > 0
    1786                                         || ([rpm-vercomp $version $version_installed] == 0
    1787                                                 && [rpm-vercomp $revision $revision_installed] > 0)} {
    1788                                 set version_installed $version
    1789                                 set revision_installed $revision
    1790                                 set epoch_installed [registry::property_retrieve [registry::open_entry $portname [lindex $i 1] [lindex $i 2] $variant] epoch]
    1791                                 set num $i
    1792                         }
    1793 
    1794                         set isactive [lindex $i 4]
    1795                         if {$isactive == 1} {
    1796                                 if { [rpm-vercomp $version_installed $version] < 0
    1797                                                 || ([rpm-vercomp $version_installed $version] == 0
    1798                                                         && [rpm-vercomp $revision_installed $revision] < 0)} {
    1799                                         # deactivate version
    1800                                 if {[catch {portimage::deactivate $portname $version $optionslist} result]} {
    1801                                                 global errorInfo
    1802                                                 ui_debug "$errorInfo"
    1803                                 ui_error "Deactivating $portname $version_installed_$revision_installed failed: $result"
    1804                                 return 1
    1805                                 }
    1806                                 }
    1807                         }
    1808                 }
     1689    global macports::registry.installtype
     1690    global macports::portarchivemode
     1691    array set options $optionslist
     1692    array set variations $variationslist
     1693    if {![string match "" $depscachename]} {
     1694        upvar $depscachename depscache
     1695    }
     1696
     1697    # set to no-zero is epoch overrides version
     1698    set epoch_override 0
     1699
     1700    # check if the port is in tree
     1701    if {[catch {mportsearch $portname false exact} result]} {
     1702        global errorInfo
     1703        ui_debug "$errorInfo"
     1704        ui_error "port search failed: $result"
     1705        return 1
     1706    }
     1707    # argh! port doesnt exist!
     1708    if {$result == ""} {
     1709        ui_error "No port $portname found."
     1710        return 1
     1711    }
     1712    # fill array with information
     1713    array set portinfo [lindex $result 1]
     1714
     1715    # set version_in_tree and revision_in_tree
     1716    if {![info exists portinfo(version)]} {
     1717        ui_error "Invalid port entry for $portname, missing version"
     1718        return 1
     1719    }
     1720    set version_in_tree "$portinfo(version)"
     1721    set revision_in_tree "$portinfo(revision)"
     1722    set epoch_in_tree "$portinfo(epoch)"
     1723
     1724    # the depflag tells us if we should follow deps (this is for stuff installed outside MacPorts)
     1725    # if this is set (not 0) we dont follow the deps
     1726    set depflag 0
     1727
     1728    # set version_installed and revision_installed
     1729    set ilist {}
     1730    if { [catch {set ilist [registry::installed $portname ""]} result] } {
     1731        if {$result == "Registry error: $portname not registered as installed." } {
     1732            ui_debug "$portname is *not* installed by MacPorts"
     1733            # open porthandle   
     1734            set porturl $portinfo(porturl)
     1735            if {![info exists porturl]} {
     1736                set porturl file://./   
     1737            }   
     1738            if {[catch {set workername [mportopen $porturl [array get options] ]} result]} {
     1739                    global errorInfo
     1740                    ui_debug "$errorInfo"
     1741                    ui_error "Unable to open port: $result"       
     1742                    return 1
     1743            }
     1744
     1745            if {![_mportispresent $workername $dspec ] } {
     1746                # port in not installed - install it!
     1747                if {[catch {set result [mportexec $workername install]} result]} {
     1748                    global errorInfo
     1749                    ui_debug "$errorInfo"
     1750                    ui_error "Unable to exec port: $result"
     1751                    return 1
     1752                }
     1753            } else {
     1754                # port installed outside MacPorts
     1755                ui_debug "$portname installed outside the MacPorts system"
     1756                set depflag 1
     1757            }
     1758
     1759        } else {
     1760            ui_error "Checking installed version failed: $result"
     1761            exit 1
     1762        }
     1763    }
     1764    set anyactive 0
     1765    set version_installed {}
     1766    set revision_installed {}
     1767    set epoch_installed 0
     1768    if {$ilist == ""} {
     1769        # XXX  this sets $version_installed to $version_in_tree even if not installed!!
     1770        set version_installed $version_in_tree
     1771        set revision_installed $revision_in_tree
     1772        # That was a very dirty hack showing how ugly our depencendy and upgrade code is.
     1773        # To get it working when user provides -f, we also need to set the variant to
     1774        # avoid a future failure.
     1775        set variant ""
     1776    } else {
     1777        # a port could be installed but not activated
     1778        # so, deactivate all and save newest for activation later
     1779        set num 0
     1780        set variant ""
     1781        foreach i $ilist {
     1782            set variant [lindex $i 3]
     1783            set version [lindex $i 1]
     1784            set revision [lindex $i 2]
     1785            if { $version_installed == {} ||
     1786                    [rpm-vercomp $version $version_installed] > 0
     1787                    || ([rpm-vercomp $version $version_installed] == 0
     1788                        && [rpm-vercomp $revision $revision_installed] > 0)} {
     1789                set version_installed $version
     1790                set revision_installed $revision
     1791                set epoch_installed [registry::property_retrieve [registry::open_entry $portname [lindex $i 1] [lindex $i 2] $variant] epoch]
     1792                set num $i
     1793            }
     1794
     1795            set isactive [lindex $i 4]
     1796            if {$isactive == 1} {
     1797                if { [rpm-vercomp $version_installed $version] < 0
     1798                        || ([rpm-vercomp $version_installed $version] == 0
     1799                            && [rpm-vercomp $revision_installed $revision] < 0)} {
     1800                    # deactivate version
     1801                    if {[catch {portimage::deactivate $portname $version $optionslist} result]} {
     1802                        global errorInfo
     1803                        ui_debug "$errorInfo"
     1804                        ui_error "Deactivating $portname $version_installed_$revision_installed failed: $result"
     1805                        return 1
     1806                    }
     1807                }
     1808            }
     1809        }
    18091810        if { [lindex $num 4] == 0 && 0 == [string compare "image" ${macports::registry.installtype}] } {
    1810                         # activate the latest installed version
    1811                         if {[catch {portimage::activate $portname ${version_installed}_$revision_installed$variant $optionslist} result]} {
    1812                                 global errorInfo
    1813                                 ui_debug "$errorInfo"
    1814                         ui_error "Activating $portname ${version_installed}_$revision_installed failed: $result"
    1815                                 return 1
    1816                         }
    1817                 }
    1818         }
    1819 
    1820         # output version numbers
    1821         ui_debug "epoch: in tree: $epoch_in_tree installed: $epoch_installed"
    1822         ui_debug "$portname ${version_in_tree}_$revision_in_tree exists in the ports tree"
    1823         ui_debug "$portname ${version_installed}_$revision_installed is installed"
    1824 
    1825         # set the nodeps option 
    1826         if {![info exists options(ports_nodeps)]} {
    1827                 set nodeps no
    1828         } else {
    1829                 set nodeps yes
    1830         }
    1831 
    1832         if {$nodeps == "yes" || $depflag == 1} {
    1833                 ui_debug "Not following dependencies"
    1834                 set depflag 0
    1835         } else {
    1836                 # build depends is upgraded
    1837                 if {[info exists portinfo(depends_build)]} {
    1838                         foreach i $portinfo(depends_build) {
    1839                                 if {![llength [array get depscache $i]]} {
    1840                                 set d [lindex [split $i :] end]
    1841                                         set depscache($i) 1
    1842                                         upgrade $d $i $variationslist $optionslist depscache
    1843                                 }
    1844                         }
    1845                 }
    1846                 # library depends is upgraded
    1847                 if {[info exists portinfo(depends_lib)]} {
    1848                         foreach i $portinfo(depends_lib) {
    1849                                 if {![llength [array get depscache $i]]} {
    1850                                 set d [lindex [split $i :] end]
    1851                                         set depscache($i) 1
    1852                                         upgrade $d $i $variationslist $optionslist depscache
    1853                                 }
    1854                         }
    1855                 }
    1856                 # runtime depends is upgraded
    1857                 if {[info exists portinfo(depends_run)]} {
    1858                         foreach i $portinfo(depends_run) {
    1859                                 if {![llength [array get depscache $i]]} {
    1860                                 set d [lindex [split $i :] end]
    1861                                         set depscache($i) 1
    1862                                         upgrade $d $i $variationslist $optionslist depscache
    1863                                 }
    1864                         }
    1865                 }
    1866         }
    1867 
    1868         # check installed version against version in ports
    1869         if { ( [rpm-vercomp $version_installed $version_in_tree] > 0
    1870                         || ([rpm-vercomp $version_installed $version_in_tree] == 0
    1871                                 && [rpm-vercomp $revision_installed $revision_in_tree] >= 0 ))
    1872                 && ![info exists options(ports_force)] } {
    1873                 ui_debug "No need to upgrade! $portname ${version_installed}_$revision_installed >= $portname ${version_in_tree}_$revision_in_tree"
    1874                 if { $epoch_installed >= $epoch_in_tree } {
    1875                         # Check if we have to do dependents
    1876                         if {[info exists options(ports_do_dependents)]} {
    1877                                 # We do dependents ..
    1878                                 set options(ports_nodeps) 1
    1879 
    1880                                 registry::open_dep_map
    1881                                 set deplist [registry::list_dependents $portname]
    1882 
    1883                                 if { [llength deplist] > 0 } {
    1884                                         foreach dep $deplist {
    1885                                                 set mpname [lindex $dep 2]
    1886                                                 macports::upgrade $mpname "port:$mpname" [array get variations] [array get options]
    1887                                         }
    1888                                 }
    1889                         }
    1890 
    1891                         return 0
    1892                 } else {
    1893                         ui_debug "epoch override ... upgrading!"
    1894                         set epoch_override 1
    1895                 }
    1896         }
    1897 
    1898         # open porthandle
    1899         set porturl $portinfo(porturl)
    1900         if {![info exists porturl]} {
    1901                 set porturl file://./
    1902         }
    1903 
    1904         # check if the variants is present in $version_in_tree
    1905         set oldvariant $variant
    1906         set variant [split $variant +]
    1907         ui_debug "variants to install $variant"
    1908         if {[info exists portinfo(variants)]} {
    1909                 set avariants $portinfo(variants)
    1910         } else {
    1911                 set avariants {}
    1912         }
    1913         ui_debug "available variants are : $avariants"
    1914         foreach v $variant {
    1915                 if {[lsearch $avariants $v] == -1} {
    1916                 } else {
    1917                         ui_debug "variant $v is present in $portname ${version_in_tree}_$revision_in_tree"
    1918                         set variations($v) "+"
    1919                 }
    1920         }
    1921         ui_debug "new portvariants: [array get variations]"
    1922        
    1923         if {[catch {set workername [mportopen $porturl [array get options] [array get variations]]} result]} {
    1924                 global errorInfo
    1925                 ui_debug "$errorInfo"
    1926                 ui_error "Unable to open port: $result"
    1927                 return 1
    1928         }
    1929 
    1930         # install version_in_tree
    1931         if {0 == [string compare "yes" ${macports::portarchivemode}]} {
    1932                 set upgrade_action "archive"
    1933         } else {
    1934                 set upgrade_action "destroot"
    1935         }
    1936 
    1937         if {[catch {set result [mportexec $workername $upgrade_action]} result] || $result != 0} {
    1938                 global errorInfo
    1939                 ui_debug "$errorInfo"
    1940                 ui_error "Unable to upgrade port: $result"
    1941                 return 1
    1942         }
    1943 
    1944         # uninstall old ports
     1811            # activate the latest installed version
     1812            if {[catch {portimage::activate $portname ${version_installed}_$revision_installed$variant $optionslist} result]} {
     1813                global errorInfo
     1814                ui_debug "$errorInfo"
     1815                ui_error "Activating $portname ${version_installed}_$revision_installed failed: $result"
     1816                return 1
     1817            }
     1818        }
     1819    }
     1820
     1821    # output version numbers
     1822    ui_debug "epoch: in tree: $epoch_in_tree installed: $epoch_installed"
     1823    ui_debug "$portname ${version_in_tree}_$revision_in_tree exists in the ports tree"
     1824    ui_debug "$portname ${version_installed}_$revision_installed is installed"
     1825
     1826    # set the nodeps option 
     1827    if {![info exists options(ports_nodeps)]} {
     1828        set nodeps no
     1829    } else {
     1830        set nodeps yes
     1831    }
     1832
     1833    if {$nodeps == "yes" || $depflag == 1} {
     1834        ui_debug "Not following dependencies"
     1835        set depflag 0
     1836    } else {
     1837        # build depends is upgraded
     1838        if {[info exists portinfo(depends_build)]} {
     1839            foreach i $portinfo(depends_build) {
     1840                if {![llength [array get depscache $i]]} {
     1841                set d [lindex [split $i :] end]
     1842                    set depscache($i) 1
     1843                    upgrade $d $i $variationslist $optionslist depscache
     1844                }
     1845            }
     1846        }
     1847        # library depends is upgraded
     1848        if {[info exists portinfo(depends_lib)]} {
     1849            foreach i $portinfo(depends_lib) {
     1850                if {![llength [array get depscache $i]]} {
     1851                set d [lindex [split $i :] end]
     1852                    set depscache($i) 1
     1853                    upgrade $d $i $variationslist $optionslist depscache
     1854                }
     1855            }
     1856        }
     1857        # runtime depends is upgraded
     1858        if {[info exists portinfo(depends_run)]} {
     1859            foreach i $portinfo(depends_run) {
     1860                if {![llength [array get depscache $i]]} {
     1861                set d [lindex [split $i :] end]
     1862                    set depscache($i) 1
     1863                    upgrade $d $i $variationslist $optionslist depscache
     1864                }
     1865            }
     1866        }
     1867    }
     1868
     1869    # check installed version against version in ports
     1870    if { ( [rpm-vercomp $version_installed $version_in_tree] > 0
     1871            || ([rpm-vercomp $version_installed $version_in_tree] == 0
     1872                && [rpm-vercomp $revision_installed $revision_in_tree] >= 0 ))
     1873        && ![info exists options(ports_force)] } {
     1874        ui_debug "No need to upgrade! $portname ${version_installed}_$revision_installed >= $portname ${version_in_tree}_$revision_in_tree"
     1875        if { $epoch_installed >= $epoch_in_tree } {
     1876            # Check if we have to do dependents
     1877            if {[info exists options(ports_do_dependents)]} {
     1878                # We do dependents ..
     1879                set options(ports_nodeps) 1
     1880
     1881                registry::open_dep_map
     1882                set deplist [registry::list_dependents $portname]
     1883
     1884                if { [llength deplist] > 0 } {
     1885                    foreach dep $deplist {
     1886                        set mpname [lindex $dep 2]
     1887                        macports::upgrade $mpname "port:$mpname" [array get variations] [array get options]
     1888                    }
     1889                }
     1890            }
     1891
     1892            return 0
     1893        } else {
     1894            ui_debug "epoch override ... upgrading!"
     1895            set epoch_override 1
     1896        }
     1897    }
     1898
     1899    # open porthandle
     1900    set porturl $portinfo(porturl)
     1901    if {![info exists porturl]} {
     1902        set porturl file://./
     1903    }
     1904
     1905    # check if the variants is present in $version_in_tree
     1906    set oldvariant $variant
     1907    set variant [split $variant +]
     1908    ui_debug "variants to install $variant"
     1909    if {[info exists portinfo(variants)]} {
     1910        set avariants $portinfo(variants)
     1911    } else {
     1912        set avariants {}
     1913    }
     1914    ui_debug "available variants are : $avariants"
     1915    foreach v $variant {
     1916        if {[lsearch $avariants $v] == -1} {
     1917        } else {
     1918            ui_debug "variant $v is present in $portname ${version_in_tree}_$revision_in_tree"
     1919            set variations($v) "+"
     1920        }
     1921    }
     1922    ui_debug "new portvariants: [array get variations]"
     1923   
     1924    if {[catch {set workername [mportopen $porturl [array get options] [array get variations]]} result]} {
     1925        global errorInfo
     1926        ui_debug "$errorInfo"
     1927        ui_error "Unable to open port: $result"
     1928        return 1
     1929    }
     1930
     1931    # install version_in_tree
     1932    if {0 == [string compare "yes" ${macports::portarchivemode}]} {
     1933        set upgrade_action "archive"
     1934    } else {
     1935        set upgrade_action "destroot"
     1936    }
     1937
     1938    if {[catch {set result [mportexec $workername $upgrade_action]} result] || $result != 0} {
     1939        global errorInfo
     1940        ui_debug "$errorInfo"
     1941        ui_error "Unable to upgrade port: $result"
     1942        return 1
     1943    }
     1944
     1945    # uninstall old ports
    19451946    if {[info exists options(port_uninstall_old)] || $epoch_override == 1 || [info exists options(ports_force)] || 0 != [string compare "image" ${macports::registry.installtype}] } {
    1946                 # uninstall old
    1947                 ui_debug "Uninstalling $portname ${version_installed}_$revision_installed$oldvariant"
    1948                 if {[catch {portuninstall::uninstall $portname ${version_installed}_$revision_installed$oldvariant $optionslist} result]} {
    1949                         global errorInfo
    1950                         ui_debug "$errorInfo"
    1951                 ui_error "Uninstall $portname ${version_installed}_$revision_installed$oldvariant failed: $result"
    1952                 return 1
    1953         }
    1954         } else {
    1955                 # XXX deactivate version_installed
    1956                 if {[catch {portimage::deactivate $portname ${version_installed}_$revision_installed$oldvariant $optionslist} result]} {
    1957                         global errorInfo
    1958                         ui_debug "$errorInfo"
    1959                         ui_error "Deactivating $portname ${version_installed}_$revision_installed failed: $result"
    1960                         return 1
    1961                 }
    1962         }
    1963 
    1964         if {[catch {set result [mportexec $workername install]} result]} {
    1965                 global errorInfo
    1966                 ui_debug "$errorInfo"
    1967                 ui_error "Couldn't activate $portname ${version_in_tree}_$revision_in_tree$oldvariant: $result"
    1968                 return 1
    1969         }
    1970 
    1971         # Check if we have to do dependents
    1972         if {[info exists options(ports_do_dependents)]} {
    1973                 # We do dependents ..
    1974                 set options(ports_nodeps) 1
    1975 
    1976                 registry::open_dep_map
    1977                 set deplist [registry::list_dependents $portname]
    1978 
    1979                 if { [llength deplist] > 0 } {
    1980                         foreach dep $deplist {
    1981                                 set mpname [lindex $dep 2]
    1982                                 macports::upgrade $mpname "port:$mpname" [array get variations] [array get options]
    1983                         }
    1984                 }
    1985         }
    1986 
    1987        
    1988         # close the port handle
    1989         mportclose $workername
    1990 }
     1947        # uninstall old
     1948        ui_debug "Uninstalling $portname ${version_installed}_$revision_installed$oldvariant"
     1949        if {[catch {portuninstall::uninstall $portname ${version_installed}_$revision_installed$oldvariant $optionslist} result]} {
     1950            global errorInfo
     1951            ui_debug "$errorInfo"
     1952            ui_error "Uninstall $portname ${version_installed}_$revision_installed$oldvariant failed: $result"
     1953            return 1
     1954        }
     1955    } else {
     1956        # XXX deactivate version_installed
     1957        if {[catch {portimage::deactivate $portname ${version_installed}_$revision_installed$oldvariant $optionslist} result]} {
     1958            global errorInfo
     1959            ui_debug "$errorInfo"
     1960            ui_error "Deactivating $portname ${version_installed}_$revision_installed failed: $result"
     1961            return 1
     1962        }
     1963    }
     1964
     1965    if {[catch {set result [mportexec $workername install]} result]} {
     1966        global errorInfo
     1967        ui_debug "$errorInfo"
     1968        ui_error "Couldn't activate $portname ${version_in_tree}_$revision_in_tree$oldvariant: $result"
     1969        return 1
     1970    }
     1971
     1972    # Check if we have to do dependents
     1973    if {[info exists options(ports_do_dependents)]} {
     1974        # We do dependents ..
     1975        set options(ports_nodeps) 1
     1976
     1977        registry::open_dep_map
     1978        set deplist [registry::list_dependents $portname]
     1979
     1980        if { [llength deplist] > 0 } {
     1981            foreach dep $deplist {
     1982                set mpname [lindex $dep 2]
     1983                macports::upgrade $mpname "port:$mpname" [array get variations] [array get options]
     1984            }
     1985        }
     1986    }
     1987
     1988   
     1989    # close the port handle
     1990    mportclose $workername
     1991}
Note: See TracChangeset for help on using the changeset viewer.