Changeset 109659


Ignore:
Timestamp:
Aug 19, 2013, 3:09:48 PM (7 years ago)
Author:
cal@…
Message:

macports1.0/port1.0: remove mports:// and non-tarball (?:https?|ftp): sources, https://lists.macosforge.org/pipermail/macports-dev/2013-February/022133.html

Also:

  • add doxygen comments to some of the mport* functions in macports1.0
  • fix the --regex option of port search passing an invalid matchstyle to mportsearch
  • remove the possibility to generate mports:// sources using portindex
Location:
trunk/base/src
Files:
1 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/base/src/macports1.0/Makefile

    r82111 r109659  
    11SRCS=           macports.tcl macports_dlist.tcl macports_util.tcl \
    2                 macports_autoconf.tcl macports_index.tcl macports_fastload.tcl
     2                macports_autoconf.tcl macports_fastload.tcl
    33OBJS=           macports.o get_systemconfiguration_proxies.o sysctl.o
    44SHLIB_NAME=     MacPorts${SHLIB_SUFFIX}
  • trunk/base/src/macports1.0/macports.tcl

    r109649 r109659  
    3636package provide macports 1.0
    3737package require macports_dlist 1.0
    38 package require macports_index 1.0
    3938package require macports_util 1.0
    4039
     
    14601459}
    14611460
    1462 # XXX: this really needs to be rethought in light of the remote index
    1463 # I've added the destdir parameter.  This is the location a remotely
    1464 # fetched port will be downloaded to (currently only applies to
    1465 # mports:// sources).
    1466 proc macports::getportdir {url {destdir .}} {
    1467     global macports::extracted_portdirs
     1461##
     1462# Return the directory where the port identified by the given \c url is
     1463# located. This used to be called with remote URLs, but this feature (and
     1464# a formerly existing second parameter) has been removed in MacPorts 2.3. Only
     1465# called with file:// port URLs at the moment.
     1466#
     1467# @param url URL identifying the port to be installed
     1468# @return normalized path to the port's directory, or error when called with an
     1469#         unsupported protocl
     1470proc macports::getportdir {url} {
    14681471    set protocol [macports::getprotocol $url]
    14691472    switch -- $protocol {
    14701473        file {
    1471             set path [file normalize [string range $url [expr {[string length $protocol] + 3}] end]]
    1472             if {![file isfile $path]} {
    1473                 return $path
    1474             } else {
    1475                 # need to create a local dir for the exracted port, but only once
    1476                 if {![info exists macports::extracted_portdirs($url)]} {
    1477                     set macports::extracted_portdirs($url) [macports::fetch_port $path 1]
    1478                 }
    1479                 return $macports::extracted_portdirs($url)
    1480             }
    1481         }
    1482         mports {
    1483             return [macports::index::fetch_port $url $destdir]
    1484         }
    1485         https -
    1486         http -
    1487         ftp {
    1488             if {![info exists macports::extracted_portdirs($url)]} {
    1489                 set macports::extracted_portdirs($url) [macports::fetch_port $url 0]
    1490             }
    1491             return $macports::extracted_portdirs($url)
     1474            return [file normalize [string range $url [expr {[string length $protocol] + 3}] end]]
    14921475        }
    14931476        default {
     
    15781561    }
    15791562
    1580     array set options_array $options
    1581     if {[info exists options_array(portdir)]} {
    1582         set portdir $options_array(portdir)
    1583     } else {
    1584         set portdir {}
    1585     }
    1586 
    1587     set portpath [macports::getportdir $porturl $portdir]
     1563    set portpath [macports::getportdir $porturl]
    15881564    ui_debug "Changing to port directory: $portpath"
    15891565    cd $portpath
     
    22602236                }
    22612237                set needs_portindex 1
    2262             }
    2263             {^mports$} {
    2264                 macports::index::sync $macports::portdbpath $source
    22652238            }
    22662239            {^rsync$} {
     
    23972370            }
    23982371            {^https?$|^ftp$} {
    2399                 if {[_source_is_snapshot $source filename extension]} {
    2400                     # sync a daily port snapshot tarball
    2401                     set indexfile [macports::getindex $source]
    2402                     set destdir [file dirname $indexfile]
    2403                     set tarpath [file join [file normalize [file join $destdir ..]] $filename]
    2404 
    2405                     set updated 1
    2406                     if {[file isdirectory $destdir]} {
    2407                         set moddate [file mtime $destdir]
    2408                         if {[catch {set updated [curl isnewer $source $moddate]} error]} {
    2409                             ui_warn "Cannot check if $source was updated, ($error)"
    2410                         }
    2411                     }
    2412 
    2413                     if {(![info exists options(ports_force)] || $options(ports_force) ne {yes}) && $updated <= 0} {
    2414                         ui_info "No updates for $source"
    2415                         continue
    2416                     }
    2417 
    2418                     file mkdir $destdir
    2419 
    2420                     set verboseflag {}
    2421                     if {$macports::portverbose eq {yes}} {
    2422                         set verboseflag -v
    2423                     }
    2424 
    2425                     if {[catch {eval curl fetch $verboseflag {$source} {$tarpath}} error]} {
    2426                         ui_error "Fetching $source failed ($error)"
    2427                         incr numfailed
    2428                         continue
    2429                     }
    2430 
    2431                     set extflag {}
    2432                     switch -- $extension {
    2433                         {tar.gz} {
    2434                             set extflag -z
    2435                         }
    2436                         {tar.bz2} {
    2437                             set extflag -j
    2438                         }
    2439                     }
    2440 
    2441                     set tar [macports::findBinary tar $macports::autoconf::tar_path]
    2442                     if {[catch {system "cd ${destdir}/.. && $tar $verboseflag $extflag -xf $filename"} error]} {
    2443                         ui_error "Extracting $source failed ($error)"
    2444                         incr numfailed
    2445                         continue
    2446                     }
    2447 
    2448                     if {[catch {system "chmod -R a+r \"$destdir\""}]} {
    2449                         ui_warn "Setting world read permissions on parts of the ports tree failed, need root?"
    2450                     }
    2451 
    2452                     set platindex "PortIndex_${macports::os_platform}_${macports::os_major}_${macports::os_arch}/PortIndex"
    2453                     if {[file isfile ${destdir}/$platindex] && [file isfile ${destdir}/${platindex}.quick]} {
    2454                         file rename -force ${destdir}/$platindex ${destdir}/${platindex}.quick $destdir
    2455                     }
    2456 
    2457                     file delete $tarpath
    2458                 } else {
    2459                     # sync just a PortIndex file
    2460                     set indexfile [macports::getindex $source]
    2461                     file mkdir [file dirname $indexfile]
    2462                     curl fetch ${source}/PortIndex $indexfile
    2463                     curl fetch ${source}/PortIndex.quick ${indexfile}.quick
    2464                 }
     2372                if {![_source_is_snapshot $source filename extension]} {
     2373                    ui_error "Synchronization using http, https and ftp only supported with tarballs."
     2374                    ui_error "The source ${source} doesn't seem to point to a tarball."
     2375                    ui_error "Please switch to a different sync protocol (e.g. rsync) in your sources.conf"
     2376                    ui_error "Remove the line mentioned above from your sources.conf to silence this error."
     2377                    incr numfailed
     2378                    continue
     2379                }
     2380                # sync a daily port snapshot tarball
     2381                set indexfile [macports::getindex $source]
     2382                set destdir [file dirname $indexfile]
     2383                set tarpath [file join [file normalize [file join $destdir ..]] $filename]
     2384
     2385                set updated 1
     2386                if {[file isdirectory $destdir]} {
     2387                    set moddate [file mtime $destdir]
     2388                    if {[catch {set updated [curl isnewer $source $moddate]} error]} {
     2389                        ui_warn "Cannot check if $source was updated, ($error)"
     2390                    }
     2391                }
     2392
     2393                if {(![info exists options(ports_force)] || $options(ports_force) ne {yes}) && $updated <= 0} {
     2394                    ui_info "No updates for $source"
     2395                    continue
     2396                }
     2397
     2398                file mkdir $destdir
     2399
     2400                set verboseflag {}
     2401                if {$macports::portverbose eq {yes}} {
     2402                    set verboseflag -v
     2403                }
     2404
     2405                if {[catch {eval curl fetch $verboseflag {$source} {$tarpath}} error]} {
     2406                    ui_error "Fetching $source failed ($error)"
     2407                    incr numfailed
     2408                    continue
     2409                }
     2410
     2411                set extflag {}
     2412                switch -- $extension {
     2413                    {tar.gz} {
     2414                        set extflag -z
     2415                    }
     2416                    {tar.bz2} {
     2417                        set extflag -j
     2418                    }
     2419                }
     2420
     2421                set tar [macports::findBinary tar $macports::autoconf::tar_path]
     2422                if {[catch {system "cd ${destdir}/.. && $tar $verboseflag $extflag -xf $filename"} error]} {
     2423                    ui_error "Extracting $source failed ($error)"
     2424                    incr numfailed
     2425                    continue
     2426                }
     2427
     2428                if {[catch {system "chmod -R a+r \"$destdir\""}]} {
     2429                    ui_warn "Setting world read permissions on parts of the ports tree failed, need root?"
     2430                }
     2431
     2432                set platindex "PortIndex_${macports::os_platform}_${macports::os_major}_${macports::os_arch}/PortIndex"
     2433                if {[file isfile ${destdir}/$platindex] && [file isfile ${destdir}/${platindex}.quick]} {
     2434                    file rename -force ${destdir}/$platindex ${destdir}/${platindex}.quick $destdir
     2435                }
     2436
     2437                file delete $tarpath
     2438            }
     2439            {^mports$} {
     2440                ui_error "Synchronization using the mports protocol no longer supported."
     2441                ui_error "Please switch to a different sync protocol (e.g. rsync) in your sources.conf"
     2442                ui_error "Remove the line starting with mports:// from your sources.conf to silence this error."
     2443                incr numfailed
     2444                continue
    24652445            }
    24662446            default {
     
    24912471}
    24922472
     2473##
     2474# Searches all configured port sources for a given pattern in a given field
     2475# using a given matching style and optional case-sensitivity.
     2476#
     2477# @param pattern pattern to search for; will be interpreted according to the \a
     2478#                matchstyle parameter
     2479# @param case_sensitive "yes", if a case-sensitive search should be performed,
     2480#                       "no" otherwise. Defaults to "yes".
     2481# @param matchstyle One of the values \c exact, \c glob and \c regexp, where \c
     2482#                   exact performs a standard string comparison, \c glob
     2483#                   performs Tcl string matching using <tt>[string match]</tt>
     2484#                   and \c regexp interprets \a pattern as a regular
     2485#                   expression.
     2486# @param field name of the field to apply \a pattern to. Must be one of the
     2487#              fields available in the used portindex. The portindex currently
     2488#              contains
     2489#                \li \c name (the default)
     2490#                \li \c homepage
     2491#                \li \c description
     2492#                \li \c long_description
     2493#                \li \c license
     2494#                \li \c categories
     2495#                \li \c platforms
     2496#                \li \c maintainers
     2497#                \li \c variants
     2498#                \li \c portdir
     2499#                \li all \c depends_* values
     2500#                \li \c epoch
     2501#                \li \c version
     2502#                \li \c revision
     2503#                \li \c replaced_by
     2504#                \li \c installs_libs
     2505# @return a list where each even index (starting with 0) contains the name of
     2506#         a matching port. Each entry at an odd index is followed by its
     2507#         corresponding line from the portindex, which can be passed to
     2508#         <tt>array set</tt>. The whole return value can also be passed to
     2509#         <tt>array set</tt> to create an associate array where the port names
     2510#         are the keys and the lines from portindex are the values.
    24932511proc mportsearch {pattern {case_sensitive yes} {matchstyle regexp} {field name}} {
    2494     global macports::portdbpath macports::sources
     2512    global macports::sources
    24952513    set matches [list]
    24962514    set easy [expr {$field eq {name}}]
     
    25002518        set source [lindex $source 0]
    25012519        set protocol [macports::getprotocol $source]
    2502         if {$protocol eq {mports}} {
    2503             set res [macports::index::search $macports::portdbpath $source [list name $pattern]]
    2504             eval lappend matches $res
     2520        if {[catch {set fd [open [macports::getindex $source] r]} result]} {
     2521            ui_warn "Can't open index file for source: $source"
    25052522        } else {
    2506             if {[catch {set fd [open [macports::getindex $source] r]} result]} {
    2507                 ui_warn "Can't open index file for source: $source"
    2508             } else {
    2509                 try {
    2510                     incr found 1
    2511                     while {[gets $fd line] >= 0} {
    2512                         array unset portinfo
    2513                         set name [lindex $line 0]
    2514                         set len [lindex $line 1]
    2515                         set line [read $fd $len]
    2516 
    2517                         if {$easy} {
    2518                             set target $name
    2519                         } else {
    2520                             array set portinfo $line
    2521                             if {![info exists portinfo($field)]} continue
    2522                             set target $portinfo($field)
     2523            try {
     2524                incr found 1
     2525                while {[gets $fd line] >= 0} {
     2526                    array unset portinfo
     2527                    set name [lindex $line 0]
     2528                    set len  [lindex $line 1]
     2529                    set line [read $fd $len]
     2530
     2531                    if {$easy} {
     2532                        set target $name
     2533                    } else {
     2534                        array set portinfo $line
     2535                        if {![info exists portinfo($field)]} {
     2536                            continue
    25232537                        }
    2524 
    2525                         switch -- $matchstyle {
    2526                             exact {
    2527                                 set matchres [expr {0 == ($case_sensitive eq {yes} ? [string compare $pattern $target] : [string compare -nocase $pattern $target])}]
     2538                        set target $portinfo($field)
     2539                    }
     2540
     2541                    switch -- $matchstyle {
     2542                        exact {
     2543                            if {$case_sensitive eq yes} {
     2544                                set compres [string compare $pattern $target]
     2545                            } else {
     2546                                set compres [string compare -nocase $pattern $target]
    25282547                            }
    2529                             glob {
    2530                                 set matchres [expr {$case_sensitive eq {yes} ? [string match $pattern $target] : [string match -nocase $pattern $target]}]
    2531                             }
    2532                             regexp -
    2533                             default {
    2534                                 set matchres [expr {$case_sensitive eq {yes} ? [regexp -- $pattern $target] : [regexp -nocase -- $pattern $target]}]
     2548                            set matchres [expr 0 == $compres]
     2549                        }
     2550                        glob {
     2551                            if {$case_sensitive eq yes} {
     2552                                set matchres [string match $pattern $target]
     2553                            } else {
     2554                                set matchres [string match -nocase $pattern $target]
    25352555                            }
    25362556                        }
    2537 
    2538                         if {$matchres == 1} {
    2539                             if {$easy} {
    2540                                 array set portinfo $line
     2557                        regexp {
     2558                            if {$case_sensitive eq yes} {
     2559                                set matchres [regexp -- $pattern $target]
     2560                            } else {
     2561                                set matchres [regexp -nocase -- $pattern $target]
    25412562                            }
    2542                             switch -- $protocol {
    2543                                 rsync {
    2544                                     # Rsync files are local
    2545                                     set source_url file://[macports::getsourcepath $source]
    2546                                 }
    2547                                 https -
    2548                                 http -
    2549                                 ftp {
    2550                                     if {[_source_is_snapshot $source filename extension]} {
    2551                                         # daily snapshot tarball
    2552                                         set source_url file://[macports::getsourcepath $source]
    2553                                     } else {
    2554                                         # default action
    2555                                         set source_url $source
    2556                                     }
    2557                                 }
    2558                                 default {
    2559                                     set source_url $source
    2560                                 }
     2563                        }
     2564                        default {
     2565                            return -code error "mportsearch: Unsupported matching style: ${matchstyle}."
     2566                        }
     2567                    }
     2568
     2569                    if {$matchres == 1} {
     2570                        if {$easy} {
     2571                            array set portinfo $line
     2572                        }
     2573                        switch -- $protocol {
     2574                            rsync {
     2575                                # Rsync files are local
     2576                                set source_url file://[macports::getsourcepath $source]
    25612577                            }
    2562                             if {[info exists portinfo(portarchive)]} {
    2563                                 set porturl ${source_url}/$portinfo(portarchive)
    2564                             } elseif {[info exists portinfo(portdir)]} {
    2565                                 set porturl ${source_url}/$portinfo(portdir)
     2578                            https -
     2579                            http -
     2580                            ftp {
     2581                                # daily snapshot tarball
     2582                                set source_url file://[macports::getsourcepath $source]
    25662583                            }
    2567                             if {[info exists porturl]} {
    2568                                 lappend line porturl $porturl
    2569                                 ui_debug "Found port in $porturl"
    2570                             } else {
    2571                                 ui_debug "Found port info: $line"
     2584                            default {
     2585                                set source_url $source
    25722586                            }
    2573                             lappend matches $name
    2574                             lappend matches $line
    25752587                        }
    2576                     }
    2577                 } catch * {
    2578                     ui_warn "It looks like your PortIndex file for $source may be corrupt."
    2579                     throw
    2580                 } finally {
    2581                     close $fd
    2582                 }
     2588                        if {[info exists portinfo(portdir)]} {
     2589                            set porturl ${source_url}/$portinfo(portdir)
     2590                            lappend line porturl $porturl
     2591                            ui_debug "Found port in $porturl"
     2592                        } else {
     2593                            ui_debug "Found port info: $line"
     2594                        }
     2595                        lappend matches $name
     2596                        lappend matches $line
     2597                    }
     2598                }
     2599            } catch * {
     2600                ui_warn "It looks like your PortIndex file for $source may be corrupt."
     2601                throw
     2602            } finally {
     2603                close $fd
    25832604            }
    25842605        }
     
    25912612}
    25922613
     2614##
    25932615# Returns the PortInfo for a single named port. The info comes from the
    25942616# PortIndex, and name matching is case-insensitive. Unlike mportsearch, only
    25952617# the first match is returned, but the return format is otherwise identical.
    2596 # The advantage is that mportlookup is much faster than mportsearch, due to
    2597 # the use of the quick index.
     2618# The advantage is that mportlookup is usually much faster than mportsearch,
     2619# due to the use of the quick index, which is a name-based index into the
     2620# PortIndex.
     2621#
     2622# @param name name of the port to look up. Returns the first match while
     2623#             traversing the sources in-order.
     2624# @return associative array in list form where the first field is the port name
     2625#         and the second field is the line from PortIndex containing the port
     2626#         info. See the return value of mportsearch().
     2627# @see mportsearch()
    25982628proc mportlookup {name} {
    2599     global macports::portdbpath macports::sources
     2629    global macports::portdbpath macports::sources macports::quick_index
    26002630
    26012631    set sourceno 0
     
    26042634        set source [lindex $source 0]
    26052635        set protocol [macports::getprotocol $source]
    2606         if {$protocol ne {mports}} {
    2607             global macports::quick_index
    2608             if {![info exists quick_index(${sourceno},[string tolower $name])]} {
    2609                 incr sourceno 1
    2610                 continue
    2611             }
    2612             # The quick index is keyed on the port name, and provides the
    2613             # offset in the main PortIndex where the given port's PortInfo
    2614             # line can be found.
    2615             set offset $quick_index(${sourceno},[string tolower $name])
     2636        if {![info exists quick_index(${sourceno},[string tolower $name])]} {
     2637            # no entry in this source, advance to next source
    26162638            incr sourceno 1
    2617             if {[catch {set fd [open [macports::getindex $source] r]} result]} {
    2618                 ui_warn "Can't open index file for source: $source"
    2619             } else {
    2620                 try {
    2621                     seek $fd $offset
    2622                     gets $fd line
     2639            continue
     2640        }
     2641        # The quick index is keyed on the port name, and provides the offset in
     2642        # the main PortIndex where the given port's PortInfo line can be found.
     2643        set offset $quick_index(${sourceno},[string tolower $name])
     2644        incr sourceno 1
     2645        if {[catch {set fd [open [macports::getindex $source] r]} result]} {
     2646            ui_warn "Can't open index file for source: $source"
     2647        } else {
     2648            try {
     2649                seek $fd $offset
     2650                gets $fd line
     2651                set name [lindex $line 0]
     2652                set len  [lindex $line 1]
     2653                set line [read $fd $len]
     2654
     2655                array set portinfo $line
     2656
     2657                switch -- $protocol {
     2658                    rsync {
     2659                        set source_url file://[macports::getsourcepath $source]
     2660                    }
     2661                    https -
     2662                    http -
     2663                    ftp {
     2664                        set source_url file://[macports::getsourcepath $source]
     2665                    }
     2666                    default {
     2667                        set source_url $source
     2668                    }
     2669                }
     2670                if {[info exists portinfo(portdir)]} {
     2671                    lappend line porturl ${source_url}/$portinfo(portdir)
     2672                }
     2673                lappend matches $name
     2674                lappend matches $line
     2675                close $fd
     2676                set fd -1
     2677            } catch * {
     2678                ui_warn "It looks like your PortIndex file for $source may be corrupt."
     2679            } finally {
     2680                if {$fd != -1} {
     2681                    close $fd
     2682                }
     2683            }
     2684            if {[llength $matches] > 0} {
     2685                # if we have a match, exit. If we don't, continue with the next
     2686                # source.
     2687                break
     2688            }
     2689        }
     2690    }
     2691
     2692    return $matches
     2693}
     2694
     2695##
     2696# Returns all ports in the indices. Faster than 'mportsearch .*' because of the
     2697# lack of matching.
     2698#
     2699# @return associative array in list form where the first field is the port name
     2700#         and the second field is the line from PortIndex containing the port
     2701#         info. See the return value of mportsearch().
     2702# @see mportsearch()
     2703proc mportlistall {} {
     2704    global macports::sources
     2705    set matches [list]
     2706
     2707    set found 0
     2708    foreach source $sources {
     2709        set source [lindex $source 0]
     2710        set protocol [macports::getprotocol $source]
     2711        if {![catch {set fd [open [macports::getindex $source] r]} result]} {
     2712            try {
     2713                incr found 1
     2714                while {[gets $fd line] >= 0} {
     2715                    array unset portinfo
    26232716                    set name [lindex $line 0]
    2624                     set len [lindex $line 1]
     2717                    set len  [lindex $line 1]
    26252718                    set line [read $fd $len]
    26262719
     
    26342727                        http -
    26352728                        ftp {
    2636                             if {[_source_is_snapshot $source filename extension]} {
    2637                                 set source_url file://[macports::getsourcepath $source]
    2638                              } else {
    2639                                 set source_url $source
    2640                              }
     2729                            set source_url file://[macports::getsourcepath $source]
    26412730                        }
    26422731                        default {
     
    26442733                        }
    26452734                    }
    2646                     if {[info exists portinfo(portarchive)]} {
    2647                         set porturl ${source_url}/$portinfo(portarchive)
    2648                     } elseif {[info exists portinfo(portdir)]} {
    2649                         set porturl ${source_url}/$portinfo(portdir)
    2650                     }
    2651                     if {[info exists porturl]} {
    2652                         lappend line porturl $porturl
    2653                     }
    2654                     lappend matches $name
    2655                     lappend matches $line
    2656                     close $fd
    2657                     set fd -1
    2658                 } catch * {
    2659                     ui_warn "It looks like your PortIndex file for $source may be corrupt."
    2660                 } finally {
    2661                     if {$fd != -1} {
    2662                         close $fd
    2663                     }
    2664                 }
    2665                 if {[llength $matches] > 0} {
    2666                     break
    2667                 }
     2735                    if {[info exists portinfo(portdir)]} {
     2736                        lappend line porturl ${source_url}/$portinfo(portdir)
     2737                    }
     2738                    lappend matches $name $line
     2739                }
     2740            } catch * {
     2741                ui_warn "It looks like your PortIndex file for $source may be corrupt."
     2742                throw
     2743            } finally {
     2744                close $fd
    26682745            }
    26692746        } else {
    2670             set res [macports::index::search $macports::portdbpath $source [list name $name]]
    2671             if {[llength $res] > 0} {
    2672                 eval lappend matches $res
    2673                 break
    2674             }
    2675         }
    2676     }
    2677 
    2678     return $matches
    2679 }
    2680 
    2681 # Returns all ports in the indices. Faster than 'mportsearch .*'
    2682 proc mportlistall {args} {
    2683     global macports::portdbpath macports::sources
    2684     set matches [list]
    2685 
    2686     set found 0
    2687     foreach source $sources {
    2688         set source [lindex $source 0]
    2689         set protocol [macports::getprotocol $source]
    2690         if {$protocol ne {mports}} {
    2691             if {![catch {set fd [open [macports::getindex $source] r]} result]} {
    2692                 try {
    2693                     incr found 1
    2694                     while {[gets $fd line] >= 0} {
    2695                         array unset portinfo
    2696                         set name [lindex $line 0]
    2697                         set len [lindex $line 1]
    2698                         set line [read $fd $len]
    2699 
    2700                         array set portinfo $line
    2701 
    2702                         switch -- $protocol {
    2703                             rsync {
    2704                                 set source_url file://[macports::getsourcepath $source]
    2705                             }
    2706                             https -
    2707                             http -
    2708                             ftp {
    2709                                 if {[_source_is_snapshot $source filename extension]} {
    2710                                     set source_url file://[macports::getsourcepath $source]
    2711                                 } else {
    2712                                     set source_url $source
    2713                                 }
    2714                             }
    2715                             default {
    2716                                 set source_url $source
    2717                             }
    2718                         }
    2719                         if {[info exists portinfo(portdir)]} {
    2720                             set porturl ${source_url}/$portinfo(portdir)
    2721                         } elseif {[info exists portinfo(portarchive)]} {
    2722                             set porturl ${source_url}/$portinfo(portarchive)
    2723                         }
    2724                         if {[info exists porturl]} {
    2725                             lappend line porturl $porturl
    2726                         }
    2727                         lappend matches $name $line
    2728                     }
    2729                 } catch * {
    2730                     ui_warn "It looks like your PortIndex file for $source may be corrupt."
    2731                     throw
    2732                 } finally {
    2733                     close $fd
    2734                 }
    2735             } else {
    2736                 ui_warn "Can't open index file for source: $source"
    2737             }
    2738         } else {
    2739             set res [macports::index::search $macports::portdbpath $source [list name .*]]
    2740             eval lappend matches $res
     2747            ui_warn "Can't open index file for source: $source"
    27412748        }
    27422749    }
     
    27482755}
    27492756
    2750 
    2751 # Loads PortIndex.quick from each source into the quick_index, generating
    2752 # it first if necessary.
    2753 proc _mports_load_quickindex {args} {
     2757##
     2758# Loads PortIndex.quick from each source into the quick_index, generating it
     2759# first if necessary. Private API of macports1.0, do not use this from outside
     2760# macports1.0.
     2761proc _mports_load_quickindex {} {
    27542762    global macports::sources macports::quick_index
    27552763
     
    27942802}
    27952803
     2804##
     2805# Generates a PortIndex.quick file from a PortIndex by using the name field as
     2806# key. This allows fast indexing into the PortIndex when using the port name as
     2807# key.
     2808#
     2809# @param index the PortIndex file to create the index for. The resulting quick
     2810#              index will be in a file named like \a index, but with ".quick"
     2811#              appended.
     2812# @return a list of entries written to the quick index file in the same format
     2813#         if the file would just have been written.
     2814# @throws if the given \a index cannot be opened, the output file cannot be
     2815#         opened, an error occurs while using the PortIndex (e.g., because it
     2816#         is corrupt), or the quick index generation failed for some other
     2817#         reason.
    27962818proc mports_generate_quickindex {index} {
    27972819    if {[catch {set indexfd [open $index r]} result] || [catch {set quickfd [open ${index}.quick w]} result]} {
  • trunk/base/src/port/port.tcl

    r108016 r109659  
    35663566        switch -- $opt {
    35673567            exact -
    3568             glob -
     3568            glob {
     3569                set filter_matchstyle $opt
     3570                continue
     3571            }
    35693572            regex {
    3570                 set filter_matchstyle $opt
     3573                set filter_matchstyle regexp
    35713574                continue
    35723575            }
     
    36083611            set opt [map_friendly_field_names $opt]
    36093612
    3610             if {[catch {eval set matches \[mportsearch \$searchstring $filter_case $matchstyle $opt\]} result]} {
     3613            if {[catch {eval set matches \[mportsearch \$searchstring $filter_case \$matchstyle $opt\]} result]} {
    36113614                global errorInfo
    36123615                ui_debug "$errorInfo"
  • trunk/base/src/port/portindex.tcl

    r96181 r109659  
    1313
    1414# Globals
    15 set archive 0
    1615set full_reindex 0
    1716set stats(total) 0
     
    3029    global argv0
    3130    puts "Usage: $argv0 \[-adf\] \[-p plat_ver_arch\] \[-o output directory\] \[directory\]"
    32     puts "-a:\tArchive port directories (for remote sites). Requires -o option"
    3331    puts "-o:\tOutput all files to specified directory"
    3432    puts "-d:\tOutput debugging information"
     
    3836
    3937proc pindex {portdir} {
    40     global target oldfd oldmtime newest qindex fd directory archive outdir stats full_reindex \
     38    global target oldfd oldmtime newest qindex fd directory outdir stats full_reindex \
    4139           ui_options port_options save_prefix keepkeys
    4240
    4341    # try to reuse the existing entry if it's still valid
    44     if {$full_reindex != "1" && $archive != "1" && [info exists qindex([string tolower [file tail $portdir]])]} {
     42    if {$full_reindex != "1" && [info exists qindex([string tolower [file tail $portdir]])]} {
    4543        try {
    4644            set mtime [file mtime [file join $directory $portdir Portfile]]
     
    102100        set portinfo(portdir) $portdir
    103101        puts "Adding port $portdir"
    104         if {$archive == "1"} {
    105             if {![file isdirectory [file join $outdir [file dirname $portdir]]]} {
    106                 if {[catch {file mkdir [file join $outdir [file dirname $portdir]]} result]} {
    107                     puts stderr "$result"
    108                     exit 1
    109                 }
    110             }
    111             set portinfo(portarchive) [file join [file dirname $portdir] [file tail $portdir]].tgz
    112             cd [file join $directory [file dirname $portinfo(portdir)]]
    113             puts "Archiving port $portinfo(name) to [file join $outdir $portinfo(portarchive)]"
    114             set tar [macports::findBinary tar $macports::autoconf::tar_path]
    115             set gzip [macports::findBinary gzip $macports::autoconf::gzip_path]
    116             if {[catch {exec $tar -cf - [file tail $portdir] | $gzip -c >[file join $outdir $portinfo(portarchive)]} result]} {
    117                 puts stderr "Failed to create port archive $portinfo(portarchive): $result"
    118                 exit 1
    119             }
    120         }
    121102
    122103        foreach availkey [array names portinfo] {
     
    175156    switch -regex -- $arg {
    176157        {^-.+} {
    177             if {$arg == "-a"} { # Turn on archiving
    178                 set archive 1
    179             } elseif {$arg == "-d"} { # Turn on debug output
     158            if {$arg == "-d"} { # Turn on debug output
    180159                set ui_options(ports_debug) yes
    181160            } elseif {$arg == "-o"} { # Set output directory
     
    207186}
    208187
    209 if {$archive == 1 && ![info exists outdir]} {
    210     puts stderr "You must specify an output directory with -o when using the -a option"
    211     print_usage
    212     exit 1
    213 }
    214 
    215188if {![info exists directory]} {
    216189    set directory .
     
    265238             depends_lib depends_run description epoch homepage \
    266239             long_description maintainers name platforms revision variants \
    267              version portdir portarchive replaced_by license installs_libs} {
     240             version portdir replaced_by license installs_libs} {
    268241    set keepkeys($key) 1
    269242}
Note: See TracChangeset for help on using the changeset viewer.